goscript 0.2.1 → 0.2.3

package/gs/golang.org/x/crypto/chacha20poly1305/index.ts

@@ -0,0 +1,245 @@
+import * as $ from '@goscript/builtin/index.js'
+import * as errors from '@goscript/errors/index.js'
+import {
+  chacha20poly1305 as nobleChaCha20Poly1305,
+  xchacha20poly1305 as nobleXChaCha20Poly1305,
+} from '@noble/ciphers/chacha.js'
+
+export const KeySize = 32
+export const NonceSize = 12
+export const NonceSizeX = 24
+export const Overhead = 16
+
+const maxIETFPlaintext = 2 ** 38 - 64
+const maxIETFCiphertext = 2 ** 38 - 48
+
+type NobleAEAD = typeof nobleChaCha20Poly1305 | typeof nobleXChaCha20Poly1305
+
+export let errOpen: $.GoError = errors.New(
+  'chacha20poly1305: message authentication failed',
+)
+
+export function __goscript_set_errOpen(value: $.GoError): void {
+  errOpen = value
+}
+
+export interface AEAD {
+  NonceSize(): number
+  Overhead(): number
+  Seal(
+    dst: $.Slice<number>,
+    nonce: $.Slice<number>,
+    plaintext: $.Slice<number>,
+    additionalData: $.Slice<number>,
+  ): $.Slice<number>
+  Open(
+    dst: $.Slice<number>,
+    nonce: $.Slice<number>,
+    ciphertext: $.Slice<number>,
+    additionalData: $.Slice<number>,
+  ): [$.Slice<number>, $.GoError]
+}
+
+export class chacha20poly1305 implements AEAD {
+  readonly key: Uint8Array
+
+  constructor(key: Uint8Array) {
+    this.key = key.slice()
+  }
+
+  NonceSize(): number {
+    return NonceSize
+  }
+
+  Overhead(): number {
+    return Overhead
+  }
+
+  Seal(
+    dst: $.Slice<number>,
+    nonce: $.Slice<number>,
+    plaintext: $.Slice<number>,
+    additionalData: $.Slice<number>,
+  ): $.Slice<number> {
+    return seal(
+      dst,
+      nobleChaCha20Poly1305,
+      this.key,
+      nonce,
+      NonceSize,
+      plaintext,
+      additionalData,
+    )
+  }
+
+  Open(
+    dst: $.Slice<number>,
+    nonce: $.Slice<number>,
+    ciphertext: $.Slice<number>,
+    additionalData: $.Slice<number>,
+  ): [$.Slice<number>, $.GoError] {
+    return open(
+      dst,
+      nobleChaCha20Poly1305,
+      this.key,
+      nonce,
+      NonceSize,
+      ciphertext,
+      additionalData,
+    )
+  }
+}
+
+export class xchacha20poly1305 implements AEAD {
+  readonly key: Uint8Array
+
+  constructor(key: Uint8Array) {
+    this.key = key.slice()
+  }
+
+  NonceSize(): number {
+    return NonceSizeX
+  }
+
+  Overhead(): number {
+    return Overhead
+  }
+
+  Seal(
+    dst: $.Slice<number>,
+    nonce: $.Slice<number>,
+    plaintext: $.Slice<number>,
+    additionalData: $.Slice<number>,
+  ): $.Slice<number> {
+    return seal(
+      dst,
+      nobleXChaCha20Poly1305,
+      this.key,
+      nonce,
+      NonceSizeX,
+      plaintext,
+      additionalData,
+    )
+  }
+
+  Open(
+    dst: $.Slice<number>,
+    nonce: $.Slice<number>,
+    ciphertext: $.Slice<number>,
+    additionalData: $.Slice<number>,
+  ): [$.Slice<number>, $.GoError] {
+    return open(
+      dst,
+      nobleXChaCha20Poly1305,
+      this.key,
+      nonce,
+      NonceSizeX,
+      ciphertext,
+      additionalData,
+    )
+  }
+}
+
+export function New(key: $.Slice<number>): [AEAD | null, $.GoError] {
+  const keyBytes = bytes(key)
+  if (keyBytes.length !== KeySize) {
+    return [null, errors.New('chacha20poly1305: bad key length')]
+  }
+  return [
+    $.interfaceValue<AEAD | null>(
+      new chacha20poly1305(keyBytes),
+      '*chacha20poly1305.chacha20poly1305',
+    ),
+    null,
+  ]
+}
+
+export function NewX(key: $.Slice<number>): [AEAD | null, $.GoError] {
+  const keyBytes = bytes(key)
+  if (keyBytes.length !== KeySize) {
+    return [null, errors.New('chacha20poly1305: bad key length')]
+  }
+  return [
+    $.interfaceValue<AEAD | null>(
+      new xchacha20poly1305(keyBytes),
+      '*chacha20poly1305.xchacha20poly1305',
+    ),
+    null,
+  ]
+}
+
+function seal(
+  dst: $.Slice<number>,
+  cipher: NobleAEAD,
+  key: Uint8Array,
+  nonce: $.Slice<number>,
+  expectedNonceSize: number,
+  plaintext: $.Slice<number>,
+  additionalData: $.Slice<number>,
+): $.Slice<number> {
+  const nonceBytes = bytes(nonce)
+  if (nonceBytes.length !== expectedNonceSize) {
+    $.panic('chacha20poly1305: bad nonce length passed to Seal')
+  }
+  const plaintextBytes = bytes(plaintext)
+  if (plaintextBytes.length > maxIETFPlaintext) {
+    $.panic('chacha20poly1305: plaintext too large')
+  }
+
+  const sealed = cipher(key, nonceBytes, bytes(additionalData)).encrypt(
+    plaintextBytes,
+  )
+  return appendBytes(dst, sealed)
+}
+
+function open(
+  dst: $.Slice<number>,
+  cipher: NobleAEAD,
+  key: Uint8Array,
+  nonce: $.Slice<number>,
+  expectedNonceSize: number,
+  ciphertext: $.Slice<number>,
+  additionalData: $.Slice<number>,
+): [$.Slice<number>, $.GoError] {
+  const nonceBytes = bytes(nonce)
+  if (nonceBytes.length !== expectedNonceSize) {
+    $.panic('chacha20poly1305: bad nonce length passed to Open')
+  }
+  const ciphertextBytes = bytes(ciphertext)
+  if (ciphertextBytes.length < Overhead) {
+    return [null, errOpen]
+  }
+  if (ciphertextBytes.length > maxIETFCiphertext) {
+    $.panic('chacha20poly1305: ciphertext too large')
+  }
+
+  try {
+    return [
+      appendBytes(
+        dst,
+        cipher(key, nonceBytes, bytes(additionalData)).decrypt(ciphertextBytes),
+      ),
+      null,
+    ]
+  } catch {
+    return [null, errOpen]
+  }
+}
+
+function bytes(value: $.Slice<number>): Uint8Array {
+  return $.bytesToUint8Array(value).slice()
+}
+
+function appendBytes(
+  dst: $.Slice<number>,
+  suffix: Uint8Array,
+): $.Slice<number> {
+  const prefix = $.bytesToUint8Array(dst)
+  if (prefix.length === 0) {
+    return suffix.slice()
+  }
+  const out = new Uint8Array(prefix.length + suffix.length)
+  out.set(prefix)
+  out.set(suffix, prefix.length)
+  return out
+}

package/gs/golang.org/x/crypto/scrypt/index.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, test } from 'vitest'
+import * as $ from '@goscript/builtin/index.js'
+
+import { Key } from './index.js'
+
+describe('scrypt override', () => {
+  test('matches Go scrypt vectors', async () => {
+    const vectors = [
+      {
+        password: 'password',
+        salt: 'salt',
+        N: 2,
+        r: 10,
+        p: 10,
+        output:
+          '482c858e229055e62f41e0ec819a5ee18bdb87251a534f75acd95ac5e50aa15f',
+      },
+      {
+        password: 'p',
+        salt: 's',
+        N: 2,
+        r: 1,
+        p: 1,
+        output: '48b0d2a8a3272611984c50ebd630af52',
+      },
+      {
+        password: '',
+        salt: '',
+        N: 16,
+        r: 1,
+        p: 1,
+        output:
+          '77d6576238657b203b19ca42c18a0497f16b4844e3074ae8dfdffa3fede21442fcd0069ded0948f8326a753a0fc81f17e8d3e0fb2e0d3628cf35e20c38d18906',
+      },
+    ]
+
+    for (const vector of vectors) {
+      const [key, err] = await Key(
+        $.stringToBytes(vector.password),
+        $.stringToBytes(vector.salt),
+        vector.N,
+        vector.r,
+        vector.p,
+        vector.output.length / 2,
+      )
+      expect(err).toBeNull()
+      expect(toHex(key)).toBe(vector.output)
+    }
+  })
+
+  test('validates invalid parameters like Go', async () => {
+    const invalid = [
+      [0, 1, 1, 'scrypt: N must be > 1 and a power of 2'],
+      [1, 1, 1, 'scrypt: N must be > 1 and a power of 2'],
+      [7, 8, 1, 'scrypt: N must be > 1 and a power of 2'],
+      [2, 0, 1, 'scrypt: parameters must be > 0'],
+      [2, 1, 0, 'scrypt: parameters must be > 0'],
+      [2, -1, 1, 'scrypt: parameters must be > 0'],
+      [2, 1, -1, 'scrypt: parameters must be > 0'],
+    ] as const
+
+    for (const [N, r, p, message] of invalid) {
+      const [key, err] = await Key(
+        $.stringToBytes('p'),
+        $.stringToBytes('s'),
+        N,
+        r,
+        p,
+        32,
+      )
+      expect(key).toBeNull()
+      expect(err?.Error()).toBe(message)
+    }
+  })
+})
+
+function toHex(input: Uint8Array | number[] | null): string {
+  return Array.from(input ?? [])
+    .map((value) => value.toString(16).padStart(2, '0'))
+    .join('')
+}

package/gs/golang.org/x/crypto/scrypt/index.ts

@@ -0,0 +1,54 @@
+import * as $ from '@goscript/builtin/index.js'
+import * as errors from '@goscript/errors/index.js'
+import { scryptAsync } from '@noble/hashes/scrypt.js'
+
+const maxInt = Number.MAX_SAFE_INTEGER
+
+export async function Key(
+  password: $.Bytes,
+  salt: $.Bytes,
+  N: number,
+  r: number,
+  p: number,
+  keyLen: number,
+): Promise<[$.Bytes, $.GoError]> {
+  if (N <= 1 || (N & (N - 1)) !== 0) {
+    return [null, errors.New('scrypt: N must be > 1 and a power of 2')]
+  }
+  if (r <= 0 || p <= 0) {
+    return [null, errors.New('scrypt: parameters must be > 0')]
+  }
+  if (
+    r * p >= 1 << 30 ||
+    r > maxInt / 128 / p ||
+    r > maxInt / 256 ||
+    N > maxInt / 128 / r
+  ) {
+    return [null, errors.New('scrypt: parameters are too large')]
+  }
+
+  try {
+    const derived = await scryptAsync(
+      $.bytesToUint8Array(password),
+      $.bytesToUint8Array(salt),
+      {
+        N,
+        r,
+        p,
+        dkLen: keyLen,
+        asyncTick: 8,
+        maxmem: maxInt,
+      },
+    )
+    return [new Uint8Array(derived), null]
+  } catch (err) {
+    return [null, errors.New(`scrypt: ${errorMessage(err)}`)]
+  }
+}
+
+function errorMessage(err: unknown): string {
+  if (err instanceof Error) {
+    return err.message
+  }
+  return String(err)
+}

package/gs/golang.org/x/crypto/scrypt/meta.json

@@ -0,0 +1,5 @@
+{
+  "asyncFunctions": {
+    "Key": true
+  }
+}

package/gs/hash/fnv/index.test.ts

@@ -1,14 +1,7 @@
 import { describe, expect, it } from 'vitest'
 
 import * as $ from '../../builtin/index.js'
-import {
-  New128,
-  New128a,
-  New32,
-  New32a,
-  New64,
-  New64a,
-} from './index.js'
+import { New128, New128a, New32, New32a, New64, New64a } from './index.js'
 
 describe('hash/fnv override', () => {
   it('matches Go FNV sums for hello', async () => {

package/gs/hash/fnv/index.ts

@@ -65,7 +65,10 @@ class FNV32 {
   }
 
   AppendBinary(prefix: $.Bytes | null): [$.Bytes, $.GoError] {
-    return [appendBytes($.bytesToUint8Array(prefix), this.magic, be32(this.hash)), null]
+    return [
+      appendBytes($.bytesToUint8Array(prefix), this.magic, be32(this.hash)),
+      null,
+    ]
   }
 
   MarshalBinary(): [$.Bytes, $.GoError] {
@@ -136,7 +139,10 @@ class FNV64 {
   }
 
   AppendBinary(prefix: $.Bytes | null): [$.Bytes, $.GoError] {
-    return [appendBytes($.bytesToUint8Array(prefix), this.magic, be64(this.hash)), null]
+    return [
+      appendBytes($.bytesToUint8Array(prefix), this.magic, be64(this.hash)),
+      null,
+    ]
   }
 
   MarshalBinary(): [$.Bytes, $.GoError] {
@@ -185,7 +191,11 @@ class FNV128 {
   }
 
   async Sum(prefix: $.Bytes | null): Promise<$.Bytes> {
-    return appendBytes($.bytesToUint8Array(prefix), be64(this.high()), be64(this.low()))
+    return appendBytes(
+      $.bytesToUint8Array(prefix),
+      be64(this.high()),
+      be64(this.low()),
+    )
   }
 
   Reset(): void {
@@ -202,7 +212,12 @@ class FNV128 {
 
   AppendBinary(prefix: $.Bytes | null): [$.Bytes, $.GoError] {
     return [
-      appendBytes($.bytesToUint8Array(prefix), this.magic, be64(this.high()), be64(this.low())),
+      appendBytes(
+        $.bytesToUint8Array(prefix),
+        this.magic,
+        be64(this.high()),
+        be64(this.low()),
+      ),
       null,
     ]
   }
@@ -217,7 +232,8 @@ class FNV128 {
     if (err != null) {
       return err
     }
-    this.hash = ((readBE64(state, 4) << 64n) | readBE64(state, 12)) & uint128Mask
+    this.hash =
+      ((readBE64(state, 4) << 64n) | readBE64(state, 12)) & uint128Mask
     return null
   }
 
@@ -304,11 +320,12 @@ function be64(value: bigint): Uint8Array {
 
 function readBE32(bytes: Uint8Array, offset: number): number {
   return (
-    ((bytes[offset] << 24) >>> 0) |
-    (bytes[offset + 1] << 16) |
-    (bytes[offset + 2] << 8) |
-    bytes[offset + 3]
-  ) >>> 0
+    (((bytes[offset] << 24) >>> 0) |
+      (bytes[offset + 1] << 16) |
+      (bytes[offset + 2] << 8) |
+      bytes[offset + 3]) >>>
+    0
+  )
 }
 
 function readBE64(bytes: Uint8Array, offset: number): bigint {

package/gs/io/fs/glob.ts

@@ -60,15 +60,18 @@ $.registerInterfaceType(
 // If fs implements [GlobFS], Glob calls fs.Glob.
 // Otherwise, Glob uses [ReadDir] to traverse the directory tree
 // and look for matches for the pattern.
-export function Glob(fsys: FS, pattern: string): [$.Slice<string>, $.GoError] {
-  return globWithLimit(fsys, pattern, 0)
+export async function Glob(
+  fsys: FS,
+  pattern: string,
+): Promise<[$.Slice<string>, $.GoError]> {
+  return await globWithLimit(fsys, pattern, 0)
 }
 
-export function globWithLimit(
+export async function globWithLimit(
   fsys: FS,
   pattern: string,
   depth: number,
-): [$.Slice<string>, $.GoError] {
+): Promise<[$.Slice<string>, $.GoError]> {
   let matches: $.Slice<string> = null
   {
     // This limit is added to prevent stack exhaustion issues. See
@@ -105,7 +108,7 @@ export function globWithLimit(
     dir = cleanGlobPath(dir)
 
     if (!hasMeta(dir)) {
-      return glob(fsys, dir, file, null)
+      return await glob(fsys, dir, file, null)
     }
 
     // Prevent infinite recursion. See issue 15879.
@@ -113,14 +116,14 @@ export function globWithLimit(
       return [null, path.ErrBadPattern]
     }
 
-    const [dirs, dirErr] = globWithLimit(fsys, dir, depth + 1)
+    const [dirs, dirErr] = await globWithLimit(fsys, dir, depth + 1)
     if (dirErr != null) {
       return [null, dirErr]
     }
     for (let _i = 0; _i < $.len(dirs); _i++) {
       const d = dirs![_i]
       {
-        const [nextMatches, globErr] = glob(fsys, d, file, matches)
+        const [nextMatches, globErr] = await glob(fsys, d, file, matches)
         matches = nextMatches
         if (globErr != null) {
           return [matches, globErr]
@@ -148,15 +151,15 @@ export function cleanGlobPath(path: string): string {
 // and appends them to matches, returning the updated slice.
 // If the directory cannot be opened, glob returns the existing matches.
 // New matches are added in lexicographical order.
-export function glob(
+export async function glob(
   fs: FS,
   dir: string,
   pattern: string,
   matches: $.Slice<string>,
-): [$.Slice<string>, $.GoError] {
+): Promise<[$.Slice<string>, $.GoError]> {
   let m = matches
   {
-    let [infos, err] = ReadDir(fs, dir)
+    let [infos, err] = await ReadDir(fs, dir)
 
     // ignore I/O error
     if (err != null) {

package/gs/io/fs/meta.json

@@ -1,5 +1,7 @@
 {
   "asyncFunctions": {
+    "Glob": true,
+    "ReadDir": true,
     "WalkDir": true
   }
 }

package/gs/io/fs/readdir.test.ts

@@ -4,7 +4,7 @@ import * as $ from '@goscript/builtin/index.js'
 import { File, FileInfo, ReadDir } from './index.js'
 
 describe('io/fs ReadDir override', () => {
-  it('returns a nil entry slice without sorting when directory read fails', () => {
+  it('returns a nil entry slice without sorting when directory read fails', async () => {
     const readErr = $.newError('read failed')
     const file: File & {
       ReadDir(n: number): [null, $.GoError]
@@ -23,7 +23,7 @@ describe('io/fs ReadDir override', () => {
       },
     }
 
-    const [list, err] = ReadDir(
+    const [list, err] = await ReadDir(
       {
         Open(_name: string): [File, $.GoError] {
           return [file, null]
@@ -35,4 +35,65 @@ describe('io/fs ReadDir override', () => {
     expect(list).toBeNull()
     expect(err).toBe(readErr)
   })
+
+  it('awaits async FS.Open fallback implementations', async () => {
+    const entries = [
+      {
+        Name(): string {
+          return 'b.txt'
+        },
+        IsDir(): boolean {
+          return false
+        },
+        Info(): [FileInfo, $.GoError] {
+          return [null, null]
+        },
+        Type(): number {
+          return 0
+        },
+      },
+      {
+        Name(): string {
+          return 'a.txt'
+        },
+        IsDir(): boolean {
+          return false
+        },
+        Info(): [FileInfo, $.GoError] {
+          return [null, null]
+        },
+        Type(): number {
+          return 0
+        },
+      },
+    ]
+    const file: File & {
+      ReadDir(n: number): Promise<[$.Slice<any>, $.GoError]>
+    } = {
+      Close(): $.GoError {
+        return null
+      },
+      Read(_p0: Uint8Array): [number, $.GoError] {
+        return [0, null]
+      },
+      Stat(): [FileInfo, $.GoError] {
+        return [null, null]
+      },
+      async ReadDir(_n: number): Promise<[$.Slice<any>, $.GoError]> {
+        return [$.arrayToSlice(entries), null]
+      },
+    }
+
+    const [list, err] = await ReadDir(
+      {
+        async Open(_name: string): Promise<[File, $.GoError]> {
+          return [file, null]
+        },
+      },
+      'dir',
+    )
+
+    expect(err).toBeNull()
+    expect(list?.map((entry) => entry?.Name())).toEqual(['a.txt', 'b.txt'])
+  })
 })