goscript 0.1.1 → 0.1.3

package/gs/compress/zlib/index.ts

@@ -0,0 +1,200 @@
+import * as $ from '@goscript/builtin/index.js'
+import * as errors from '@goscript/errors/index.js'
+import * as io from '@goscript/io/index.js'
+
+export type Resetter = {
+  Reset(r: io.Reader | null, dict: $.Bytes | null): Promise<$.GoError>
+}
+
+export let ErrChecksum = errors.New('zlib: invalid checksum')
+export let ErrDictionary = errors.New('zlib: invalid dictionary')
+export let ErrHeader = errors.New('zlib: invalid header')
+
+export function __goscript_set_ErrChecksum(value: $.GoError): void {
+  ErrChecksum = value
+}
+
+export function __goscript_set_ErrDictionary(value: $.GoError): void {
+  ErrDictionary = value
+}
+
+export function __goscript_set_ErrHeader(value: $.GoError): void {
+  ErrHeader = value
+}
+
+class zlibReader implements io.ReadCloser {
+  private offset = 0
+
+  constructor(private data: Uint8Array) {}
+
+  Read(p: $.Bytes): [number, $.GoError] {
+    if (this.offset >= this.data.length) {
+      return [0, io.EOF]
+    }
+    const out = $.bytesToUint8Array(p)
+    const n = Math.min(out.length, this.data.length - this.offset)
+    out.set(this.data.subarray(this.offset, this.offset + n))
+    this.offset += n
+    return [n, null]
+  }
+
+  Close(): $.GoError {
+    return null
+  }
+}
+
+export class Writer {
+  private chunks: Uint8Array[] = []
+  private closed = false
+
+  constructor(private w: io.Writer | null) {}
+
+  Write(p: $.Bytes): [number, $.GoError] {
+    if (this.closed) {
+      return [0, errors.New('zlib: writer closed')]
+    }
+    const data = $.bytesToUint8Array(p)
+    this.chunks.push(data.slice())
+    return [data.length, null]
+  }
+
+  Close(): $.GoError {
+    if (this.closed) {
+      return null
+    }
+    this.closed = true
+    if (this.w == null) {
+      return errors.New('zlib: nil writer')
+    }
+    const compressed = deflate(concat(this.chunks))
+    const [, err] = this.w.Write(compressed)
+    return err
+  }
+
+  Flush(): $.GoError {
+    return null
+  }
+
+  Reset(w: io.Writer | null): void {
+    this.w = w
+    this.chunks = []
+    this.closed = false
+  }
+}
+
+export function NewWriter(w: io.Writer | null): Writer {
+  return new Writer(w)
+}
+
+export function NewWriterLevel(
+  w: io.Writer | null,
+  _level: number,
+): [Writer | null, $.GoError] {
+  return [new Writer(w), null]
+}
+
+export function NewWriterLevelDict(
+  w: io.Writer | null,
+  _level: number,
+  _dict: $.Bytes | null,
+): [Writer | null, $.GoError] {
+  return [new Writer(w), null]
+}
+
+export function NewReader(
+  r: io.Reader | null,
+): [io.ReadCloser | null, $.GoError] {
+  return NewReaderDict(r, null)
+}
+
+export function NewReaderDict(
+  r: io.Reader | null,
+  _dict: $.Bytes | null,
+): [io.ReadCloser | null, $.GoError] {
+  if (r == null) {
+    return [null, errors.New('zlib: nil reader')]
+  }
+  const [data, readErr] = readAll(r)
+  if (readErr != null) {
+    return [null, readErr]
+  }
+  try {
+    const out = inflate($.bytesToUint8Array(data))
+    return [new zlibReader(out), null]
+  } catch {
+    return [null, ErrHeader]
+  }
+}
+
+function deflate(data: Uint8Array): Uint8Array {
+  const zlib = nodeZlib()
+  return new Uint8Array(zlib.deflateSync(data))
+}
+
+function inflate(data: Uint8Array): Uint8Array {
+  const zlib = nodeZlib()
+  return new Uint8Array(zlib.inflateSync(data))
+}
+
+function nodeZlib(): any {
+  const processObj = (globalThis as any).process
+  if (processObj && typeof processObj.getBuiltinModule === 'function') {
+    const mod = processObj.getBuiltinModule('zlib')
+    if (mod && typeof mod.deflateSync === 'function') {
+      return mod
+    }
+  }
+  const requireFn = (() => {
+    try {
+      return Function(
+        "return typeof require !== 'undefined' ? require : null",
+      )() as ((specifier: string) => unknown) | null
+    } catch {
+      return null
+    }
+  })()
+  if (requireFn != null) {
+    for (const specifier of ['node:zlib', 'zlib']) {
+      try {
+        const mod = requireFn(specifier) as any
+        if (mod && typeof mod.deflateSync === 'function') {
+          return mod
+        }
+      } catch {
+        // Try the next fallback.
+      }
+    }
+  }
+  throw new Error('compress/zlib: node zlib module unavailable')
+}
+
+function readAll(r: io.Reader): [Uint8Array, $.GoError] {
+  const chunks: Uint8Array[] = []
+  const buf = $.makeSlice<number>(32 * 1024, undefined, 'byte')
+  while (true) {
+    const [n, err] = r.Read(buf)
+    if (n > 0) {
+      chunks.push($.bytesToUint8Array($.goSlice(buf, 0, n)).slice())
+    }
+    if (err != null) {
+      if (err === io.EOF) {
+        return [concat(chunks), null]
+      }
+      return [new Uint8Array(0), err]
+    }
+  }
+}
+
+function concat(chunks: Uint8Array[]): Uint8Array {
+  let total = 0
+  for (const chunk of chunks) {
+    total += chunk.length
+  }
+  const out = new Uint8Array(total)
+  let offset = 0
+  for (const chunk of chunks) {
+    out.set(chunk, offset)
+    offset += chunk.length
+  }
+  return out
+}

package/gs/compress/zlib/meta.json

@@ -0,0 +1,3 @@
+{
+  "dependencies": []
+}

package/gs/context/context.test.ts

@@ -1,12 +1,38 @@
 import { describe, expect, it } from 'vitest'
 
-import { AfterFunc, WithCancel, Background } from './index.js'
+import * as $ from '@goscript/builtin/index.js'
+
+import { AfterFunc, WithCancel, Background, WithValue } from './index.js'
 
 async function nextMicrotask(): Promise<void> {
   await new Promise<void>((resolve) => queueMicrotask(resolve))
 }
 
+async function nextTask(): Promise<void> {
+  await new Promise<void>((resolve) => setTimeout(resolve, 0))
+}
+
 describe('context override', () => {
+  it('matches generated struct keys by Go comparable value', () => {
+    class Key {
+      public _fields: Record<string, $.VarRef<unknown>>
+
+      constructor() {
+        this._fields = {}
+      }
+    }
+
+    const ctx = WithValue(
+      Background(),
+      $.interfaceValue($.markAsStructValue(new Key()), 'example.key'),
+      'stored',
+    )
+
+    expect(
+      ctx.Value($.interfaceValue($.markAsStructValue(new Key()), 'example.key')),
+    ).toBe('stored')
+  })
+
   it('runs AfterFunc after cancellation', async () => {
     const [ctx, cancel] = WithCancel(Background())
     let called = false
@@ -17,7 +43,7 @@ describe('context override', () => {
 
     cancel?.()
     await nextMicrotask()
-    await nextMicrotask()
+    await nextTask()
 
     expect(called).toBe(true)
     expect(stop()).toBe(false)
@@ -38,4 +64,12 @@ describe('context override', () => {
 
     expect(called).toBe(false)
   })
+
+  it('accepts nil AfterFunc callbacks for type compatibility', () => {
+    const [ctx] = WithCancel(Background())
+
+    const stop = AfterFunc(ctx, null)
+
+    expect(stop()).toBe(true)
+  })
 })

package/gs/context/context.ts

@@ -87,7 +87,7 @@ class valueContext extends baseContext {
   }
 
   Value(key: any): any {
-    if (this.key === key) {
+    if (this.key === key || $.comparableEqual(this.key, key)) {
       return this.val
     }
     return this.parent.Value(key)
@@ -388,8 +388,8 @@ export function Cause(ctx: Context): $.GoError {
   return c.Err()
 }
 
-// AfterFunc runs f in a separate goroutine after ctx is done
-export function AfterFunc(ctx: Context, f: () => void): () => boolean {
+// AfterFunc runs f in a separate goroutine after ctx is done.
+export function AfterFunc(ctx: Context, f: (() => void) | null): () => boolean {
   if (ctx === null) {
     throw new Error('cannot create context from nil parent')
   }
@@ -405,7 +405,12 @@ export function AfterFunc(ctx: Context, f: () => void): () => boolean {
     if (!stopped) {
       done = true
       // Run in next tick to simulate goroutine
-      queueMicrotask(f)
+      queueMicrotask(() => {
+        if (f === null) {
+          throw new Error('context: nil AfterFunc callback')
+        }
+        f()
+      })
     }
   })()
 

package/gs/crypto/ecdh/index.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest'
+
+import { X25519 } from './index.js'
+
+describe('crypto/ecdh override', () => {
+  it('matches the RFC 7748 X25519 test vector', () => {
+    const curve = X25519()
+    const [alice, aliceErr] = curve.NewPrivateKey(
+      hex('77076d0a7318a57d3c16c17251b26645df4c2f87ebc0992ab177fba51db92c2a'),
+    )
+    const [bobPub, bobPubErr] = curve.NewPublicKey(
+      hex('de9edb7d7b7dc1b4d35b61c2ece435373f8343c85b78674dadfc7e146f882b4f'),
+    )
+
+    expect(aliceErr).toBeNull()
+    expect(bobPubErr).toBeNull()
+    expect(toHex(alice!.PublicKey().Bytes())).toBe(
+      '8520f0098930a754748b7ddcb43ef75a0dbf3a0d26381af4eba4a98eaa9b4e6a',
+    )
+
+    const [shared, sharedErr] = alice!.ECDH(bobPub)
+    expect(sharedErr).toBeNull()
+    expect(toHex(shared)).toBe(
+      '4a5d9d5ba4ce2de1728e3bf480350f25e07e21c947d19e3376f09b3c1e161742',
+    )
+  })
+
+  it('rejects low-order remote points', () => {
+    const [priv] = X25519().NewPrivateKey(new Uint8Array(32).fill(7))
+    const [zero] = X25519().NewPublicKey(new Uint8Array(32))
+    const [, err] = priv!.ECDH(zero)
+
+    expect(err?.Error()).toContain('low order point')
+  })
+})
+
+function hex(value: string): Uint8Array {
+  return new Uint8Array(value.match(/../g)!.map((byte) => Number.parseInt(byte, 16)))
+}
+
+function toHex(value: Uint8Array | null): string {
+  return Array.from(value ?? [], (byte) => byte.toString(16).padStart(2, '0')).join('')
+}

package/gs/crypto/ecdh/index.ts

@@ -0,0 +1,274 @@
+import * as $ from '@goscript/builtin/index.js'
+import * as io from '@goscript/io/index.js'
+
+export type Curve = x25519Curve | unsupportedCurve
+export type KeyExchanger = PrivateKey
+
+const x25519PublicKeySize = 32
+const x25519PrivateKeySize = 32
+const x25519SharedSecretSize = 32
+const p = (1n << 255n) - 19n
+const a24 = 121665n
+
+export class PublicKey {
+  public curve: Curve
+  public publicKey: $.Bytes
+
+  constructor(init?: Partial<{ curve: Curve; publicKey: $.Bytes }>) {
+    this.curve = init?.curve ?? x25519
+    this.publicKey = copyBytes(init?.publicKey ?? null)
+  }
+
+  public Bytes(): $.Bytes {
+    return copyBytes(this.publicKey)
+  }
+
+  public Curve(): Curve {
+    return this.curve
+  }
+
+  public Equal(x: PublicKey | $.VarRef<PublicKey> | null): boolean {
+    const other = $.pointerValueOrNil(x)
+    return other instanceof PublicKey && bytesEqual(this.publicKey, other.publicKey)
+  }
+}
+
+export class PrivateKey {
+  public curve: Curve
+  public privateKey: $.Bytes
+  public publicKey: PublicKey
+
+  constructor(
+    init?: Partial<{ curve: Curve; privateKey: $.Bytes; publicKey: PublicKey }>,
+  ) {
+    this.curve = init?.curve ?? x25519
+    this.privateKey = copyBytes(init?.privateKey ?? null)
+    this.publicKey = init?.publicKey ?? new PublicKey({ curve: this.curve })
+  }
+
+  public Bytes(): $.Bytes {
+    return copyBytes(this.privateKey)
+  }
+
+  public Curve(): Curve {
+    return this.curve
+  }
+
+  public ECDH(remote: PublicKey | $.VarRef<PublicKey> | null): [$.Bytes, $.GoError] {
+    const remoteKey = $.pointerValueOrNil(remote)
+    if (remoteKey == null || remoteKey.curve !== this.curve) {
+      return [null, $.newError('crypto/ecdh: private key and public key curves do not match')]
+    }
+    return this.curve.ecdh(this, remoteKey)
+  }
+
+  public Equal(x: PrivateKey | $.VarRef<PrivateKey> | null): boolean {
+    const other = $.pointerValueOrNil(x)
+    return other instanceof PrivateKey && bytesEqual(this.privateKey, other.privateKey)
+  }
+
+  public Public(): PublicKey {
+    return this.publicKey
+  }
+
+  public PublicKey(): PublicKey {
+    return this.publicKey
+  }
+}
+
+export class x25519Curve {
+  public GenerateKey(r: io.Reader | null): [PrivateKey | null, $.GoError] {
+    const key = new Uint8Array(x25519PrivateKeySize)
+    if (r != null) {
+      throw new Error('crypto/ecdh: custom random readers are not implemented in GoScript')
+    }
+    globalThis.crypto.getRandomValues(key)
+    return this.NewPrivateKey(key)
+  }
+
+  public NewPrivateKey(key: $.Bytes): [PrivateKey | null, $.GoError] {
+    if ($.len(key) !== x25519PrivateKeySize) {
+      return [null, $.newError('crypto/ecdh: invalid private key size')]
+    }
+    const privateKey = copyBytes(key)
+    const publicKey = scalarMult(privateKey, basepoint())
+    return [
+      new PrivateKey({
+        curve: this,
+        privateKey,
+        publicKey: new PublicKey({ curve: this, publicKey }),
+      }),
+      null,
+    ]
+  }
+
+  public NewPublicKey(key: $.Bytes): [PublicKey | null, $.GoError] {
+    if ($.len(key) !== x25519PublicKeySize) {
+      return [null, $.newError('crypto/ecdh: invalid public key')]
+    }
+    return [new PublicKey({ curve: this, publicKey: key }), null]
+  }
+
+  public String(): string {
+    return 'X25519'
+  }
+
+  public ecdh(local: PrivateKey | null, remote: PublicKey | null): [$.Bytes, $.GoError] {
+    const out = scalarMult(local?.privateKey ?? null, remote?.publicKey ?? null)
+    if (isZero(out)) {
+      return [null, $.newError('crypto/ecdh: bad X25519 remote ECDH input: low order point')]
+    }
+    return [out, null]
+  }
+}
+
+export function X25519(): Curve {
+  return x25519
+}
+
+export const x25519 = new x25519Curve()
+
+export class unsupportedCurve {
+  constructor(private readonly name: string) {}
+
+  public GenerateKey(_r: io.Reader | null): [PrivateKey | null, $.GoError] {
+    return [null, $.newError(`crypto/ecdh: ${this.name} is not implemented in GoScript`)]
+  }
+
+  public NewPrivateKey(_key: $.Bytes): [PrivateKey | null, $.GoError] {
+    return [null, $.newError(`crypto/ecdh: ${this.name} is not implemented in GoScript`)]
+  }
+
+  public NewPublicKey(_key: $.Bytes): [PublicKey | null, $.GoError] {
+    return [null, $.newError(`crypto/ecdh: ${this.name} is not implemented in GoScript`)]
+  }
+
+  public String(): string {
+    return this.name
+  }
+
+  public ecdh(_local: PrivateKey | null, _remote: PublicKey | null): [$.Bytes, $.GoError] {
+    return [null, $.newError(`crypto/ecdh: ${this.name} is not implemented in GoScript`)]
+  }
+}
+
+export function P256(): Curve {
+  return p256
+}
+
+export function P384(): Curve {
+  return p384
+}
+
+export function P521(): Curve {
+  return p521
+}
+
+const p256 = new unsupportedCurve('P-256')
+const p384 = new unsupportedCurve('P-384')
+const p521 = new unsupportedCurve('P-521')
+
+function scalarMult(scalar: $.Bytes, point: $.Bytes): Uint8Array {
+  const e = copyBytes(scalar)
+  const uBytes = copyBytes(point)
+  e[0] &= 248
+  e[31] &= 127
+  e[31] |= 64
+  uBytes[31] &= 127
+
+  const x1 = decodeLittleEndian(uBytes)
+  let x2 = 1n
+  let z2 = 0n
+  let x3 = x1
+  let z3 = 1n
+  let swap = 0n
+
+  for (let t = 254; t >= 0; t--) {
+    const k = (BigInt(e[Math.floor(t / 8)]) >> BigInt(t & 7)) & 1n
+    swap ^= k
+    ;[x2, x3] = cswap(swap, x2, x3)
+    ;[z2, z3] = cswap(swap, z2, z3)
+    swap = k
+
+    const a = mod(x2 + z2)
+    const aa = mod(a * a)
+    const b = mod(x2 - z2)
+    const bb = mod(b * b)
+    const eDiff = mod(aa - bb)
+    const c = mod(x3 + z3)
+    const d = mod(x3 - z3)
+    const da = mod(d * a)
+    const cb = mod(c * b)
+    x3 = mod((da + cb) ** 2n)
+    z3 = mod(x1 * mod((da - cb) ** 2n))
+    x2 = mod(aa * bb)
+    z2 = mod(eDiff * mod(aa + a24 * eDiff))
+  }
+
+  x2 = cswap(swap, x2, x3)[0]
+  z2 = cswap(swap, z2, z3)[0]
+
+  return encodeLittleEndian(mod(x2 * modInverse(z2)))
+}
+
+function cswap(swap: bigint, x: bigint, y: bigint): [bigint, bigint] {
+  const mask = -swap
+  const t = mask & (x ^ y)
+  return [x ^ t, y ^ t]
+}
+
+function mod(value: bigint): bigint {
+  const result = value % p
+  return result >= 0n ? result : result + p
+}
+
+function modInverse(value: bigint): bigint {
+  let lm = 1n
+  let hm = 0n
+  let low = mod(value)
+  let high = p
+  while (low > 1n) {
+    const r = high / low
+    ;[lm, hm] = [hm - lm * r, lm]
+    ;[low, high] = [high - low * r, low]
+  }
+  return mod(lm)
+}
+
+function decodeLittleEndian(bytes: Uint8Array): bigint {
+  let out = 0n
+  for (let i = bytes.length - 1; i >= 0; i--) {
+    out = (out << 8n) | BigInt(bytes[i])
+  }
+  return out
+}
+
+function encodeLittleEndian(value: bigint): Uint8Array {
+  const out = new Uint8Array(x25519SharedSecretSize)
+  let v = mod(value)
+  for (let i = 0; i < out.length; i++) {
+    out[i] = Number(v & 0xffn)
+    v >>= 8n
+  }
+  return out
+}
+
+function basepoint(): Uint8Array {
+  const out = new Uint8Array(x25519PublicKeySize)
+  out[0] = 9
+  return out
+}
+
+function copyBytes(bytes: $.Bytes | null): Uint8Array {
+  return new Uint8Array($.bytesToUint8Array(bytes ?? null))
+}
+
+function bytesEqual(a: $.Bytes, b: $.Bytes): boolean {
+  const aa = $.bytesToUint8Array(a)
+  const bb = $.bytesToUint8Array(b)
+  return aa.length === bb.length && aa.every((v, i) => v === bb[i])
+}
+
+function isZero(bytes: Uint8Array): boolean {
+  return bytes.every((b) => b === 0)
+}

package/gs/crypto/ed25519/index.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, test } from 'vitest'
+import * as $ from '@goscript/builtin/index.js'
+
+import {
+  GenerateKey,
+  PrivateKeySize,
+  PrivateKey_Public,
+  PublicKeySize,
+  SignatureSize,
+  Sign,
+  Verify,
+} from './index.js'
+
+describe('crypto/ed25519 override', () => {
+  test('generates keys and verifies signatures', async () => {
+    const [pub, priv, err] = await GenerateKey(null)
+    expect(err).toBeNull()
+    expect($.len(pub)).toBe(PublicKeySize)
+    expect($.len(priv)).toBe(PrivateKeySize)
+
+    const message = $.stringToBytes('goscript')
+    const sig = await Sign(priv, message)
+    expect($.len(sig)).toBe(SignatureSize)
+    expect(await Verify(pub, message, sig)).toBe(true)
+    expect(await Verify(pub, $.stringToBytes('wrong'), sig)).toBe(false)
+  })
+
+  test('boxes public keys as crypto public keys', async () => {
+    const [pub, priv, err] = await GenerateKey(null)
+    expect(err).toBeNull()
+
+    const boxed = PrivateKey_Public(priv)
+    const [unboxed, ok] = $.typeAssertTuple<Uint8Array>(
+      boxed,
+      'ed25519.PublicKey',
+    )
+    expect(ok).toBe(true)
+    expect(Array.from(unboxed)).toEqual(Array.from(pub))
+    expect((boxed as any).Equal(boxed)).toBe(true)
+  })
+})