goscript 0.1.0 → 0.1.2

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

@@ -2,7 +2,58 @@ import { describe, expect, it } from 'vitest'
 
 import * as $ from '@goscript/builtin/index.js'
 
-import { Read, Reader, Text } from './index.js'
+import { Int, Prime, Read, Reader, Text } from './index.js'
+
+class TestInt {
+  private value = 0
+
+  constructor(value = 0) {
+    this.value = value
+  }
+
+  Sign(): number {
+    return Math.sign(this.value)
+  }
+
+  BitLen(): number {
+    return this.value.toString(2).length
+  }
+
+  SetBytes(bytes: Uint8Array): TestInt {
+    this.value = 0
+    for (const b of bytes) {
+      this.value = this.value * 256 + b
+    }
+    return this
+  }
+
+  Cmp(other: TestInt): number {
+    return Math.sign(this.value - other.value)
+  }
+
+  Value(): number {
+    return this.value
+  }
+
+  ProbablyPrime(): boolean {
+    if (this.value < 2) {
+      return false
+    }
+    for (let i = 2; i * i <= this.value; i++) {
+      if (this.value % i === 0) {
+        return false
+      }
+    }
+    return true
+  }
+}
+
+TestInt.__typeInfo = $.registerStructType(
+  'big.Int',
+  () => new TestInt(),
+  [],
+  TestInt,
+)
 
 describe('crypto/rand override', () => {
   it('fills byte slices from Web Crypto', () => {
@@ -29,4 +80,41 @@ describe('crypto/rand override', () => {
     expect(token).toHaveLength(26)
     expect(token).toMatch(/^[A-Z2-7]+$/)
   })
+
+  it('generates integers below max from an io.Reader', () => {
+    const reader = {
+      Read(dst: Uint8Array): [number, $.GoError] {
+        dst[0] = 42
+        return [dst.length, null]
+      },
+    }
+
+    const [n, err] = Int(reader, new TestInt(100))
+
+    expect(err).toBeNull()
+    expect(n.Value()).toBe(42)
+  })
+
+  it('generates probable primes with the requested bit length', async () => {
+    const reader = {
+      Read(dst: Uint8Array): [number, $.GoError] {
+        dst.fill(0)
+        return [dst.length, null]
+      },
+    }
+
+    const [prime, err] = await Prime(reader, 8)
+
+    expect(err).toBeNull()
+    expect(prime.Value()).toBe(193)
+    expect(prime.BitLen()).toBe(8)
+    expect(prime.ProbablyPrime()).toBe(true)
+  })
+
+  it('rejects prime sizes below two bits', async () => {
+    const [prime, err] = await Prime(Reader, 1)
+
+    expect(prime).toBeNull()
+    expect(err?.Error()).toBe('crypto/rand: prime size must be at least 2-bit')
+  })
 })

package/gs/crypto/rand/index.ts

@@ -35,6 +35,75 @@ export function Read(b: $.Bytes): [number, $.GoError] {
   return [n, null]
 }
 
+export function Int(rand: io.Reader | null, max: any): [any, $.GoError] {
+  if (max == null || typeof max.Sign !== 'function' || max.Sign() <= 0) {
+    return [null, new RandError('crypto/rand: argument to Int is <= 0')]
+  }
+
+  const bitLen = max.BitLen()
+  const byteLen = Math.ceil(bitLen / 8)
+  const excessBits = byteLen * 8 - bitLen
+  const reader = rand ?? Reader
+
+  while (true) {
+    const bytes = new Uint8Array(byteLen)
+    const [n, err] = reader.Read(bytes)
+    if (err != null) {
+      return [null, err]
+    }
+    if (n !== byteLen) {
+      return [null, io.ErrUnexpectedEOF]
+    }
+    if (excessBits > 0) {
+      bytes[0] &= 0xff >>> excessBits
+    }
+
+    const candidate = new max.constructor()
+    candidate.SetBytes(bytes)
+    if (candidate.Cmp(max) < 0) {
+      return [candidate, null]
+    }
+  }
+}
+
+export async function Prime(
+  rand: io.Reader | null,
+  bits: number,
+): Promise<[any, $.GoError]> {
+  if (bits < 2) {
+    return [null, new RandError('crypto/rand: prime size must be at least 2-bit')]
+  }
+
+  const bitOffset = bits % 8
+  const topBits = bitOffset === 0 ? 8 : bitOffset
+  const bytes = new Uint8Array(Math.ceil(bits / 8))
+  const reader = rand ?? Reader
+
+  while (true) {
+    const err = readFull(reader, bytes)
+    if (err != null) {
+      return [null, err]
+    }
+
+    bytes[0] &= (1 << topBits) - 1
+    if (topBits >= 2) {
+      bytes[0] |= 3 << (topBits - 2)
+    } else {
+      bytes[0] |= 1
+      if (bytes.length > 1) {
+        bytes[1] |= 0x80
+      }
+    }
+    bytes[bytes.length - 1] |= 1
+
+    const candidate = newBigInt()
+    candidate.SetBytes(bytes)
+    if (await candidate.ProbablyPrime(20)) {
+      return [candidate, null]
+    }
+  }
+}
+
 export function Text(): string {
   const src = new Uint8Array(26)
   const [, err] = Read(src)
@@ -49,6 +118,37 @@ export function Text(): string {
   return out
 }
 
+function newBigInt(): any {
+  const info = $.getTypeByName('big.Int') as
+    | { zeroValue?: unknown; ctor?: new () => unknown }
+    | undefined
+  if (info?.zeroValue !== undefined) {
+    return typeof info.zeroValue === 'function'
+      ? (info.zeroValue as () => unknown)()
+      : info.zeroValue
+  }
+  if (info?.ctor != null) {
+    return new info.ctor()
+  }
+  throw new Error('crypto/rand: math/big.Int type is not registered')
+}
+
+function readFull(reader: io.Reader, dst: Uint8Array): $.GoError {
+  let offset = 0
+  while (offset < dst.length) {
+    const chunk = dst.subarray(offset)
+    const [n, err] = reader.Read(chunk)
+    if (err != null) {
+      return err
+    }
+    if (n <= 0) {
+      return io.ErrUnexpectedEOF
+    }
+    offset += n
+  }
+  return null
+}
+
 function fillSecureBytes(dst: $.Bytes): $.GoError {
   const length = $.len(dst)
   if (length === 0) {
@@ -57,7 +157,9 @@ function fillSecureBytes(dst: $.Bytes): $.GoError {
 
   const crypto = secureCrypto()
   if (crypto == null) {
-    return new RandError('crypto/rand: Web Crypto getRandomValues is unavailable')
+    return new RandError(
+      'crypto/rand: Web Crypto getRandomValues is unavailable',
+    )
   }
 
   if (dst instanceof Uint8Array) {

package/gs/crypto/rand/meta.json

@@ -1,5 +1,8 @@
 {
   "dependencies": [
     "io"
-  ]
+  ],
+  "asyncFunctions": {
+    "Prime": true
+  }
 }

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

@@ -0,0 +1,78 @@
+import { describe, expect, test } from 'vitest'
+import * as $ from '@goscript/builtin/index.js'
+
+import { New, New224, Size, Size224, Sum224, Sum256 } from './index.js'
+
+describe('crypto/sha256 override', () => {
+  test('sums with WebCrypto', async () => {
+    const sum = await Sum256($.stringToBytes('abc'))
+    expect(Array.from(sum)).toEqual([
+      186, 120, 22, 191, 143, 1, 207, 234, 65, 65, 64, 222, 93, 174, 34, 35,
+      176, 3, 97, 163, 150, 23, 122, 156, 180, 16, 255, 97, 242, 0, 21, 173,
+    ])
+  })
+
+  test('streaming digest appends to prefix', async () => {
+    const digest = New()
+    expect(digest.Write($.stringToBytes('a'))).toEqual([1, null])
+    expect(digest.Write($.stringToBytes('bc'))).toEqual([2, null])
+
+    const out = await digest.Sum(new Uint8Array([1, 2]))
+    expect(Array.from(out).slice(0, 2)).toEqual([1, 2])
+    expect(out.length).toBe(Size + 2)
+    expect(Array.from(out).slice(2)).toEqual(
+      Array.from(await Sum256($.stringToBytes('abc'))),
+    )
+  })
+
+  test('sums SHA-224 with host crypto', async () => {
+    const sum = await Sum224($.stringToBytes('abc'))
+    expect(Array.from(sum)).toEqual([
+      35, 9, 125, 34, 52, 5, 216, 34, 134, 66, 164, 119, 189, 162, 85, 179,
+      42, 173, 188, 228, 189, 160, 179, 247, 227, 108, 157, 167,
+    ])
+  })
+
+  test('streaming SHA-224 digest appends to prefix', async () => {
+    const digest = New224()
+    expect(digest.Write($.stringToBytes('a'))).toEqual([1, null])
+    expect(digest.Write($.stringToBytes('bc'))).toEqual([2, null])
+
+    const out = await digest.Sum(new Uint8Array([1, 2]))
+    expect(Array.from(out).slice(0, 2)).toEqual([1, 2])
+    expect(out.length).toBe(Size224 + 2)
+    expect(Array.from(out).slice(2)).toEqual(
+      Array.from(await Sum224($.stringToBytes('abc'))),
+    )
+  })
+
+  test('streaming Sum does not finalize the digest', async () => {
+    const digest = New()
+    expect(digest.Write($.stringToBytes('abc'))).toEqual([3, null])
+
+    const first = await digest.Sum(null)
+    expect(Array.from(first)).toEqual(
+      Array.from(await Sum256($.stringToBytes('abc'))),
+    )
+
+    expect(digest.Write($.stringToBytes('d'))).toEqual([1, null])
+    const second = await digest.Sum(null)
+    expect(Array.from(second)).toEqual(
+      Array.from(await Sum256($.stringToBytes('abcd'))),
+    )
+  })
+
+  test('streaming digest handles many small writes', async () => {
+    const digest = New()
+    let data = ''
+    for (let i = 0; i < 4096; i++) {
+      const part = `key-${i};`
+      data += part
+      expect(digest.Write($.stringToBytes(part))).toEqual([part.length, null])
+    }
+
+    expect(Array.from(await digest.Sum(null))).toEqual(
+      Array.from(await Sum256($.stringToBytes(data))),
+    )
+  })
+})

package/gs/crypto/sha256/index.ts

@@ -0,0 +1,150 @@
+import * as $ from '@goscript/builtin/index.js'
+import {
+  getHostRuntime,
+  type NodeCryptoHash,
+} from '@goscript/builtin/hostio.js'
+
+export const Size = 32
+export const Size224 = 28
+export const BlockSize = 64
+
+type ShaAlgorithm = 'sha224' | 'sha256'
+
+class Sha256Error {
+  constructor(private readonly message: string) {}
+
+  Error(): string {
+    return this.message
+  }
+}
+
+class Digest {
+  private chunks: Uint8Array[] = []
+  private dataLength = 0
+  private hash: NodeCryptoHash | null
+  private canCopyHash: boolean
+
+  constructor(private readonly algorithm: ShaAlgorithm) {
+    this.hash = createNodeHash(algorithm)
+    this.canCopyHash = typeof this.hash?.copy === 'function'
+  }
+
+  Write(p: $.Bytes): [number, $.GoError] {
+    const bytes = $.bytesToUint8Array(p)
+    this.hash?.update(bytes)
+    if (!this.canCopyHash) {
+      this.chunks.push(bytes.slice())
+      this.dataLength += bytes.length
+    }
+    return [bytes.length, null]
+  }
+
+  async Sum(b: $.Bytes): Promise<$.Bytes> {
+    const digest =
+      this.canCopyHash ?
+        new Uint8Array(this.hash!.copy!().digest())
+      : await sum(this.algorithm, this.snapshotBytes())
+    return appendDigest($.bytesToUint8Array(b), digest)
+  }
+
+  Reset(): void {
+    this.chunks = []
+    this.dataLength = 0
+    this.hash = createNodeHash(this.algorithm)
+    this.canCopyHash = typeof this.hash?.copy === 'function'
+  }
+
+  Size(): number {
+    return this.algorithm === 'sha224' ? Size224 : Size
+  }
+
+  BlockSize(): number {
+    return BlockSize
+  }
+
+  private snapshotBytes(): Uint8Array {
+    return concatChunks(this.chunks, this.dataLength)
+  }
+}
+
+export function New(): any {
+  return new Digest('sha256')
+}
+
+export function New224(): any {
+  return new Digest('sha224')
+}
+
+export async function Sum224(data: $.Bytes): Promise<Uint8Array> {
+  return sum('sha224', data)
+}
+
+export async function Sum256(data: $.Bytes): Promise<Uint8Array> {
+  return sum('sha256', data)
+}
+
+async function sum(
+  algorithm: ShaAlgorithm,
+  data: $.Bytes,
+): Promise<Uint8Array> {
+  const hash = createNodeHash(algorithm)
+  if (hash != null) {
+    return new Uint8Array(hash.update($.bytesToUint8Array(data)).digest())
+  }
+
+  if (algorithm === 'sha224') {
+    throw new Error(
+      new Sha256Error('crypto/sha256: SHA-224 digest is unavailable').Error(),
+    )
+  }
+
+  const subtle = subtleCrypto()
+  if (subtle == null) {
+    throw new Error(
+      new Sha256Error('crypto/sha256: WebCrypto digest is unavailable').Error(),
+    )
+  }
+
+  const digest = await subtle.digest(
+    'SHA-256',
+    $.bytesToUint8Array(data) as unknown as BufferSource,
+  )
+  return new Uint8Array(digest)
+}
+
+function appendDigest(prefix: Uint8Array, digest: Uint8Array): Uint8Array {
+  const out = new Uint8Array(prefix.length + digest.length)
+  out.set(prefix)
+  out.set(digest, prefix.length)
+  return out
+}
+
+function createNodeHash(algorithm: ShaAlgorithm): NodeCryptoHash | null {
+  const nodeCrypto = getHostRuntime().nodeCrypto
+  if (!nodeCrypto?.createHash) {
+    return null
+  }
+  try {
+    return nodeCrypto.createHash(algorithm)
+  } catch {
+    return null
+  }
+}
+
+function concatChunks(chunks: Uint8Array[], length: number): Uint8Array {
+  const out = new Uint8Array(length)
+  let offset = 0
+  for (const chunk of chunks) {
+    out.set(chunk, offset)
+    offset += chunk.length
+  }
+  return out
+}
+
+function subtleCrypto(): SubtleCrypto | null {
+  const crypto = globalThis.crypto
+  if (crypto?.subtle && typeof crypto.subtle.digest === 'function') {
+    return crypto.subtle
+  }
+  return null
+}

package/gs/crypto/sha256/meta.json

@@ -0,0 +1,9 @@
+{
+  "asyncFunctions": {
+    "Sum224": true,
+    "Sum256": true
+  },
+  "asyncMethods": {
+    "Digest.Sum": true
+  }
+}

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

@@ -0,0 +1,31 @@
+import { createHash } from 'node:crypto'
+import { describe, expect, it } from 'vitest'
+
+import { New, Sum384, Sum512, Sum512_224, Sum512_256 } from './index.js'
+
+describe('crypto/sha512 override', () => {
+  it('matches Node digests', async () => {
+    const data = new TextEncoder().encode('goscript sha512')
+
+    expect(toHex(await Sum512(data))).toBe(nodeHash('sha512', data))
+    expect(toHex(await Sum384(data))).toBe(nodeHash('sha384', data))
+    expect(toHex(await Sum512_224(data))).toBe(nodeHash('sha512-224', data))
+    expect(toHex(await Sum512_256(data))).toBe(nodeHash('sha512-256', data))
+  })
+
+  it('supports incremental hash.Hash use', async () => {
+    const h = New()
+    h.Write(new TextEncoder().encode('go'))
+    h.Write(new TextEncoder().encode('script'))
+
+    expect(toHex(await h.Sum(null))).toBe(nodeHash('sha512', new TextEncoder().encode('goscript')))
+  })
+})
+
+function nodeHash(algorithm: string, data: Uint8Array): string {
+  return createHash(algorithm).update(data).digest('hex')
+}
+
+function toHex(value: Uint8Array): string {
+  return Buffer.from(value).toString('hex')
+}

package/gs/crypto/sha512/index.ts

@@ -0,0 +1,161 @@
+import * as $ from '@goscript/builtin/index.js'
+import {
+  getHostRuntime,
+  type NodeCryptoHash,
+} from '@goscript/builtin/hostio.js'
+
+export const Size = 64
+export const Size224 = 28
+export const Size256 = 32
+export const Size384 = 48
+export const BlockSize = 128
+
+type ShaAlgorithm = 'sha384' | 'sha512' | 'sha512-224' | 'sha512-256'
+
+class Digest {
+  private chunks: Uint8Array[] = []
+  private dataLength = 0
+  private hash: NodeCryptoHash | null
+  private canCopyHash: boolean
+
+  constructor(private readonly algorithm: ShaAlgorithm) {
+    this.hash = createNodeHash(algorithm)
+    this.canCopyHash = typeof this.hash?.copy === 'function'
+  }
+
+  Write(p: $.Bytes): [number, $.GoError] {
+    const bytes = $.bytesToUint8Array(p)
+    this.hash?.update(bytes)
+    if (!this.canCopyHash) {
+      this.chunks.push(bytes.slice())
+      this.dataLength += bytes.length
+    }
+    return [bytes.length, null]
+  }
+
+  async Sum(b: $.Bytes): Promise<$.Bytes> {
+    const digest =
+      this.canCopyHash ?
+        new Uint8Array(this.hash!.copy!().digest())
+      : await sum(this.algorithm, this.snapshotBytes())
+    return appendDigest($.bytesToUint8Array(b), digest)
+  }
+
+  Reset(): void {
+    this.chunks = []
+    this.dataLength = 0
+    this.hash = createNodeHash(this.algorithm)
+    this.canCopyHash = typeof this.hash?.copy === 'function'
+  }
+
+  Size(): number {
+    switch (this.algorithm) {
+      case 'sha384':
+        return Size384
+      case 'sha512-224':
+        return Size224
+      case 'sha512-256':
+        return Size256
+      default:
+        return Size
+    }
+  }
+
+  BlockSize(): number {
+    return BlockSize
+  }
+
+  private snapshotBytes(): Uint8Array {
+    return concatChunks(this.chunks, this.dataLength)
+  }
+}
+
+export function New(): any {
+  return new Digest('sha512')
+}
+
+export function New384(): any {
+  return new Digest('sha384')
+}
+
+export function New512_224(): any {
+  return new Digest('sha512-224')
+}
+
+export function New512_256(): any {
+  return new Digest('sha512-256')
+}
+
+export async function Sum384(data: $.Bytes): Promise<Uint8Array> {
+  return sum('sha384', data)
+}
+
+export async function Sum512(data: $.Bytes): Promise<Uint8Array> {
+  return sum('sha512', data)
+}
+
+export async function Sum512_224(data: $.Bytes): Promise<Uint8Array> {
+  return sum('sha512-224', data)
+}
+
+export async function Sum512_256(data: $.Bytes): Promise<Uint8Array> {
+  return sum('sha512-256', data)
+}
+
+async function sum(
+  algorithm: ShaAlgorithm,
+  data: $.Bytes,
+): Promise<Uint8Array> {
+  const hash = createNodeHash(algorithm)
+  if (hash != null) {
+    return new Uint8Array(hash.update($.bytesToUint8Array(data)).digest())
+  }
+
+  const subtle = subtleCrypto()
+  if (subtle == null || (algorithm !== 'sha384' && algorithm !== 'sha512')) {
+    throw new Error(`crypto/sha512: ${algorithm} digest is unavailable`)
+  }
+
+  const digest = await subtle.digest(
+    algorithm === 'sha384' ? 'SHA-384' : 'SHA-512',
+    $.bytesToUint8Array(data) as unknown as BufferSource,
+  )
+  return new Uint8Array(digest)
+}
+
+function appendDigest(prefix: Uint8Array, digest: Uint8Array): Uint8Array {
+  const out = new Uint8Array(prefix.length + digest.length)
+  out.set(prefix)
+  out.set(digest, prefix.length)
+  return out
+}
+
+function createNodeHash(algorithm: ShaAlgorithm): NodeCryptoHash | null {
+  const nodeCrypto = getHostRuntime().nodeCrypto
+  if (!nodeCrypto?.createHash) {
+    return null
+  }
+  try {
+    return nodeCrypto.createHash(algorithm)
+  } catch {
+    return null
+  }
+}
+
+function concatChunks(chunks: Uint8Array[], length: number): Uint8Array {
+  const out = new Uint8Array(length)
+  let offset = 0
+  for (const chunk of chunks) {
+    out.set(chunk, offset)
+    offset += chunk.length
+  }
+  return out
+}
+
+function subtleCrypto(): SubtleCrypto | null {
+  const crypto = globalThis.crypto
+  if (crypto?.subtle && typeof crypto.subtle.digest === 'function') {
+    return crypto.subtle
+  }
+  return null
+}

package/gs/crypto/sha512/meta.json

@@ -0,0 +1,11 @@
+{
+  "asyncFunctions": {
+    "Sum384": true,
+    "Sum512": true,
+    "Sum512_224": true,
+    "Sum512_256": true
+  },
+  "asyncMethods": {
+    "Digest.Sum": true
+  }
+}

package/gs/embed/index.ts

@@ -0,0 +1,20 @@
+import * as $ from '@goscript/builtin/index.js'
+import * as fs from '@goscript/io/fs/index.js'
+
+export class FS {
+  Open(name: string): [fs.File, $.GoError] {
+    return [null, pathError('open', name)]
+  }
+
+  ReadDir(name: string): [$.Slice<fs.DirEntry>, $.GoError] {
+    return [null, pathError('read', name)]
+  }
+
+  ReadFile(name: string): [Uint8Array, $.GoError] {
+    return [new Uint8Array(0), pathError('read', name)]
+  }
+}
+
+function pathError(op: string, name: string): $.GoError {
+  return new fs.PathError({ Op: op, Path: name, Err: fs.ErrNotExist })
+}

package/gs/embed/meta.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": [
+    "io/fs"
+  ]
+}