hfs 0.26.6 → 0.26.8

package/src/pbkdf2.ts

@@ -0,0 +1,83 @@
+// @ts-nocheck
+import { webcrypto as crypto } from "node:crypto";
+export { pbkdf2, pbkdf2Verify }
+
+// FROM https://gist.github.com/chrisveness/770ee96945ec12ac84f134bf538d89fb
+
+/**
+ * Returns PBKDF2 derived key from supplied password.
+ *
+ * Stored key can subsequently be used to verify that a password matches the original password used
+ * to derive the key, using pbkdf2Verify().
+ *
+ * @param   {String} password - Password to be hashed using key derivation function.
+ * @param   {Number} [iterations=1e6] - Number of iterations of HMAC function to apply.
+ * @returns {String} Derived key as base64 string.
+ *
+ * @example
+ *   const key = await pbkdf2('pāşšŵōřđ'); // eg 'djAxBRKXWNWPyXgpKWHld8SWJA9CQFmLyMbNet7Rle5RLKJAkBCllLfM6tPFa7bAis0lSTiB'
+ */
+async function pbkdf2(password, iterations=1e6) {
+    const pwUtf8 = new TextEncoder().encode(password);                                           // encode pw as UTF-8
+    const pwKey = await crypto.subtle.importKey('raw', pwUtf8, 'PBKDF2', false, ['deriveBits']); // create pw key
+
+    const saltUint8 = crypto.getRandomValues(new Uint8Array(16));                          // get random salt
+
+    const params = { name: 'PBKDF2', hash: 'SHA-256', salt: saltUint8, iterations: iterations }; // pbkdf2 params
+    const keyBuffer = await crypto.subtle.deriveBits(params, pwKey, 256);                        // derive key
+
+    const keyArray = Array.from(new Uint8Array(keyBuffer));                                      // key as byte array
+
+    const saltArray = Array.from(new Uint8Array(saltUint8));                                     // salt as byte array
+
+    const iterHex = ('000000'+iterations.toString(16)).slice(-6);                           // iter’n count as hex
+    const iterArray = iterHex.match(/.{2}/g).map(byte => parseInt(byte, 16));       // iter’ns as byte array
+
+    const compositeArray = [].concat(saltArray, iterArray, keyArray);                            // combined array
+    const compositeStr = compositeArray.map(byte => String.fromCharCode(byte)).join('');         // combined as string
+    // encode as base64
+    return btoa('v01' + compositeStr);                                                      // return composite key
+}
+
+
+/**
+ * Verifies whether the supplied password matches the password previously used to generate the key.
+ *
+ * @param   {String}  key - Key previously generated with pbkdf2().
+ * @param   {String}  password - Password to be matched against previously derived key.
+ * @returns {boolean} Whether password matches key.
+ *
+ * @example
+ *   const match = await pbkdf2Verify(key, 'pāşšŵōřđ'); // true
+ */
+async function pbkdf2Verify(key, password) {
+    let compositeStr = null; // composite key is salt, iteration count, and derived key
+    try { compositeStr = atob(key); } catch (e) { throw new Error ('Invalid key'); }             // decode from base64
+
+    const version = compositeStr.slice(0, 3);   //  3 bytes
+    const saltStr = compositeStr.slice(3, 19);  // 16 bytes (128 bits)
+    const iterStr = compositeStr.slice(19, 22); //  3 bytes
+    const keyStr  = compositeStr.slice(22, 54); // 32 bytes (256 bits)
+
+    if (version !== 'v01') throw new Error('Invalid key');
+
+    // -- recover salt & iterations from stored (composite) key
+
+    const saltUint8 = new Uint8Array(saltStr.match(/./g).map(ch => ch.charCodeAt(0)));           // salt as Uint8Array
+    // note: cannot use TextEncoder().encode(saltStr) as it generates UTF-8
+
+    const iterHex = iterStr.match(/./g).map(ch => ch.charCodeAt(0).toString(16)).join('');       // iter’n count as hex
+    const iterations = parseInt(iterHex, 16);                                                    // iter’ns
+
+    // -- generate new key from stored salt & iterations and supplied password
+
+    const pwUtf8 = new TextEncoder().encode(password);                                           // encode pw as UTF-8
+    const pwKey = await crypto.subtle.importKey('raw', pwUtf8, 'PBKDF2', false, ['deriveBits']); // create pw key
+
+    const params = { name: 'PBKDF2', hash: 'SHA-256', salt: saltUint8, iterations: iterations }; // pbkdf params
+    const keyBuffer = await crypto.subtle.deriveBits(params, pwKey, 256);                        // derive key
+    const keyArray = Array.from(new Uint8Array(keyBuffer));                                      // key as byte array
+    const keyStrNew = keyArray.map(byte => String.fromCharCode(byte)).join('');                  // key as string
+
+    return keyStrNew === keyStr; // test if newly generated key matches stored key
+}

package/src/perm.ts

@@ -0,0 +1,194 @@
+// This file is part of HFS - Copyright 2021-2022, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+
+import _ from 'lodash'
+import { hashPassword } from './crypt'
+import { objRenameKey, setHidden, wantArray } from './misc'
+import Koa from 'koa'
+import { defineConfig, saveConfigAsap } from './config'
+import { createVerifierAndSalt, SRPParameters, SRPRoutines } from 'tssrp6a'
+import events from './events'
+
+export interface Account {
+    username: string, // we'll have username in it, so we don't need to pass it separately
+    password?: string
+    hashed_password?: string
+    srp?: string
+    belongs?: string[]
+    ignore_limits?: boolean
+    admin?: boolean
+    redirect?: string
+}
+interface Accounts { [username:string]: Account }
+
+let accounts: Accounts = {}
+
+export function getAccounts() {
+    return accounts as Readonly<typeof accounts>
+}
+
+export function getCurrentUsername(ctx: Koa.Context): string {
+    return ctx.state.account?.username || ctx.session?.username || ''
+}
+
+// provides the username and all other usernames it inherits based on the 'belongs' attribute. Useful to check permissions
+export function getCurrentUsernameExpanded(ctx: Koa.Context) {
+    const who = getCurrentUsername(ctx)
+    if (!who)
+        return []
+    const ret = [who]
+    for (const u of ret) {
+        const a = getAccount(u)
+        if (a?.belongs)
+            ret.push(...a.belongs)
+    }
+    return ret
+}
+
+export function getAccount(username:string) : Account | undefined {
+    return username ? accounts[username] : undefined
+}
+
+export function saveSrpInfo(account:Account, salt:string | bigint, verifier: string | bigint) {
+    account.srp = String(salt) + '|' + String(verifier)
+}
+
+export const allowClearTextLogin = defineConfig('allow_clear_text_login')
+
+const srp6aNimbusRoutines = new SRPRoutines(new SRPParameters())
+
+type Changer = (account:Account)=> void | Promise<void>
+export async function updateAccount(account: Account, changer?:Changer) {
+    const was = JSON.stringify(account)
+    await changer?.(account)
+    const { username } = account
+    if (account.password) {
+        console.debug('hashing password for', username)
+        if (allowClearTextLogin.get())
+            account.hashed_password = await hashPassword(account.password)
+        const res = await createVerifierAndSalt(srp6aNimbusRoutines, username, account.password)
+        saveSrpInfo(account, res.s, res.v)
+        delete account.password
+    }
+    else if (!account.srp && account.hashed_password) {
+        console.log('please reset password for account', username)
+        process.exit(1)
+    }
+    if (account.belongs)
+        account.belongs = wantArray(account.belongs).filter(b =>
+            b in accounts // at this stage the group record may still be null if specified later in the file
+            || console.error(`account ${username} belongs to non-existing ${b}`) )
+    if (was !== JSON.stringify(account))
+        saveAccountsAsap()
+}
+
+const saveAccountsAsap = saveConfigAsap
+
+const accountsConfig = defineConfig<Accounts>('accounts', {})
+accountsConfig.sub(async v => {
+    // we should validate content here
+    accounts = v // keep local reference
+    await Promise.all(_.map(accounts, async (rec,k) => {
+        const norm = normalizeUsername(k)
+        if (!rec) // an empty object in yaml is stored as null
+            rec = accounts[norm] = { username: norm }
+        else
+            objRenameKey(accounts, k, norm)
+        setHidden(rec, { username: norm })
+        await updateAccount(rec)
+    }))
+})
+
+function normalizeUsername(username: string) {
+    return username.toLocaleLowerCase()
+}
+
+export function renameAccount(from: string, to: string) {
+    from = normalizeUsername(from)
+    to = normalizeUsername(to)
+    if (!to || !accounts[from] || accounts[to])
+        return false
+    if (to === from)
+        return true
+    objRenameKey(accounts, from, to)
+    updateReferences()
+    saveAccountsAsap()
+    return true
+
+    function updateReferences() {
+        setHidden(accounts[to], { username: to })
+        for (const a of Object.values(accounts)) {
+            const idx = a.belongs?.indexOf(from)
+            if (idx !== undefined && idx >= 0)
+                a.belongs![idx] = to
+        }
+        events.emit('accountRenamed', from, to) // everybody, take care of your stuff
+    }
+}
+
+// we consider all the following fields, when falsy, as equivalent to be missing. If this changes in the future, please adjust addAccount and setAccount
+const assignableProps: (keyof Account)[] = ['redirect','ignore_limits','belongs','admin']
+
+export function addAccount(username: string, props: Partial<Account>) {
+    if (!username || accounts[username])
+        return
+    const copy: Account = setHidden(_.pickBy(_.pick(props, assignableProps), Boolean),
+        { username }) // have the field in the object but hidden so that stringification won't include it
+    accountsConfig.set(accounts =>
+        Object.assign(accounts, { [username]: copy }))
+    saveAccountsAsap().then()
+    return copy
+}
+
+export function setAccount(username: string, changes: Partial<Account>) {
+    const acc = getAccount(username)
+    if (!acc)
+        return false
+    const rest = _.pick(changes, assignableProps)
+    for (const [k,v] of Object.entries(rest))
+        if (!v)
+            rest[k as keyof Account] = undefined
+    Object.assign(acc, rest)
+    if (changes.username)
+        renameAccount(username, changes.username)
+    saveAccountsAsap().then()
+    return true
+}
+
+export function delAccount(username: string) {
+    if (!getAccount(username))
+        return false
+    accountsConfig.set(accounts =>
+        Object.assign(accounts, { [username]: undefined }))
+    saveAccountsAsap().then()
+    return true
+}
+
+// get some property from account, searching in its groups if necessary. Search is breadth-first, and this determines priority of inheritance.
+export function getFromAccount<T=any>(account: Account | string, getter:(a:Account) => T) {
+    const search = [account]
+    for (const accountOrUsername of search) {
+        const a = typeof accountOrUsername === 'string' ? getAccount(accountOrUsername) : accountOrUsername
+        if (!a) continue
+        const res = getter(a)
+        if (res !== undefined)
+            return res
+        if (a.belongs)
+            search.push(...a.belongs)
+    }
+}
+
+export function accountHasPassword(account: Account) {
+    return Boolean(account.password || account.hashed_password || account.srp)
+}
+
+export function accountCanLogin(account: Account) {
+    return accountHasPassword(account)
+}
+
+export function accountCanLoginAdmin(account: Account) {
+    return accountCanLogin(account) && getFromAccount(account, a => a.admin)
+}
+
+export function anyAccountCanLoginAdmin() {
+    return Object.values(accounts).find(accountCanLoginAdmin)
+}

package/src/plugins.ts

@@ -0,0 +1,342 @@
+// This file is part of HFS - Copyright 2021-2022, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+
+import glob from 'fast-glob'
+import { watchLoad } from './watchLoad'
+import _ from 'lodash'
+import pathLib from 'path'
+import { API_VERSION, APP_PATH, COMPATIBLE_API_VERSION, PLUGINS_PUB_URI } from './const'
+import * as Const from './const'
+import Koa from 'koa'
+import {
+    adjustStaticPathForGlob,
+    Callback,
+    debounceAsync,
+    Dict,
+    getOrSet,
+    onProcessExit,
+    same,
+    tryJson,
+    wantArray,
+    watchDir
+} from './misc'
+import { defineConfig, getConfig } from './config'
+import { DirEntry } from './api.file_list'
+import { VfsNode } from './vfs'
+import { serveFile } from './serveFile'
+import events from './events'
+import { readFile } from 'fs/promises'
+import { existsSync, mkdirSync } from 'fs'
+import { getConnections } from './connections'
+
+export const PATH = 'plugins'
+export const DISABLING_POSTFIX = '-disabled'
+
+const plugins: Record<string, Plugin> = {}
+
+export function isPluginRunning(id: string) {
+    return plugins[id]?.started
+}
+
+export function enablePlugin(id: string, state=true) {
+    enablePlugins.set( arr =>
+        arr.includes(id) === state ? arr
+            : state ? [...arr, id]
+                : arr.filter((x: string) => x !== id)
+    )
+}
+
+// nullish values are equivalent to defaultValues
+export function setPluginConfig(id: string, changes: Dict) {
+    pluginsConfig.set(allConfigs => {
+        const fields = getPluginConfigFields(id)
+        const oldConfig = allConfigs[id]
+        const newConfig = _.pickBy({ ...oldConfig, ...changes },
+            (v, k) => v != null && !same(v, fields?.[k]?.defaultValue))
+        return { ...allConfigs, [id]: _.isEmpty(newConfig) ? undefined : newConfig }
+    })
+}
+
+export function getPluginInfo(id: string) {
+    const running = plugins[id]?.getData()
+    return running && Object.assign(running, {id}) || availablePlugins[id]
+}
+
+export function mapPlugins<T>(cb:(plugin:Readonly<Plugin>, pluginName:string)=> T) {
+    return _.map(plugins, (pl,plName) => {
+        try { return cb(pl,plName) }
+        catch(e) {
+            console.log('plugin error', plName, String(e))
+        }
+    }).filter(x => x !== undefined) as Exclude<T,undefined>[]
+}
+
+export function getPluginConfigFields(id: string) {
+    return plugins[id]?.getData().config
+}
+
+export function pluginsMiddleware(): Koa.Middleware {
+    return async (ctx, next) => {
+        const after = []
+        // run middleware plugins
+        for (const id in plugins)
+            try {
+                const pl = plugins[id]
+                const res = await pl.middleware?.(ctx)
+                if (res === true)
+                    ctx.pluginStopped = true
+                if (typeof res === 'function')
+                    after.push(res)
+            }
+            catch(e){
+                console.log('error middleware plugin', id, String(e))
+                console.debug(e)
+            }
+        // expose public plugins' files
+        const { path } = ctx
+        if (!ctx.pluginStopped) {
+            if (path.startsWith(PLUGINS_PUB_URI)) {
+                const a = path.substring(PLUGINS_PUB_URI.length).split('/')
+                if (plugins.hasOwnProperty(a[0])) { // do it only if the plugin is loaded
+                    a.splice(1, 0, 'public')
+                    await serveFile(PATH + '/' + a.join('/'), 'auto')(ctx, next)
+                }
+            }
+            await next()
+        }
+        for (const f of after)
+            await f()
+    }
+}
+
+// return false to ask to exclude this entry from results
+interface OnDirEntryParams { entry:DirEntry, ctx:Koa.Context, node:VfsNode }
+type OnDirEntry = (params:OnDirEntryParams) => void | false
+
+export class Plugin {
+    started = new Date()
+
+    constructor(readonly id:string, private readonly data:any, private unwatch:()=>void){
+        if (!data) throw 'invalid data'
+        if (plugins[id])
+            throw "unload first: " + id
+        plugins[id] = this
+
+        this.data = data = { ...data } // clone to make object modifiable. Objects coming from import are not.
+        // some validation
+        for (const k of ['frontend_css', 'frontend_js']) {
+            const v = data[k]
+            if (typeof v === 'string')
+                data[k] = [v]
+            else if (v && !Array.isArray(v)) {
+                delete data[k]
+                console.warn('invalid', k)
+            }
+        }
+    }
+    get middleware(): undefined | PluginMiddleware {
+        return this.data?.middleware
+    }
+    get frontend_css(): undefined | string[] {
+        return this.data?.frontend_css
+    }
+    get frontend_js(): undefined | string[] {
+        return this.data?.frontend_js
+    }
+    get onDirEntry(): undefined | OnDirEntry {
+        return this.data?.onDirEntry
+    }
+
+    getData(): any {
+        return { ...this.data }
+    }
+
+    async unload(reloading=false) {
+        const { id } = this
+        try {
+            await this.data?.unload?.()
+            console.log('unloaded plugin', id)
+        }
+        catch(e) {
+            console.log('error unloading plugin', id, String(e))
+        }
+        delete plugins[id]
+        if (reloading) return
+        this.unwatch()
+        if (availablePlugins[id])
+            events.emit('pluginStopped', availablePlugins[id])
+        else
+            events.emit('pluginUninstalled', id)
+    }
+}
+
+type PluginMiddleware = (ctx:Koa.Context) => void | Stop | CallMeAfter
+type Stop = true
+type CallMeAfter = ()=>void
+
+export interface AvailablePlugin {
+    id: string
+    description?: string
+    version?: number
+    apiRequired?: number | [number,number]
+    repo?: string
+    branch?: string
+    badApi?: string
+}
+
+let availablePlugins: Record<string, AvailablePlugin> = {}
+
+export function getAvailablePlugins() {
+    return Object.values(availablePlugins)
+}
+
+const rescanAsap = debounceAsync(rescan, 1000)
+if (!existsSync(PATH))
+    try { mkdirSync(PATH) }
+    catch {}
+export const pluginsWatcher = watchDir(PATH, rescanAsap)
+
+export const enablePlugins = defineConfig('enable_plugins', ['antibrute'])
+enablePlugins.sub(rescanAsap)
+
+export const pluginsConfig = defineConfig('plugins_config', {} as Record<string,any>)
+
+export async function rescan() {
+    console.debug('scanning plugins')
+    const found = []
+    const foundDisabled: typeof availablePlugins = {}
+    const MASK = PATH + '/*/plugin.js' // be sure to not use path.join as fast-glob doesn't work with \
+    for (const f of await glob([adjustStaticPathForGlob(APP_PATH) + '/' + MASK, MASK])) {
+        const id = f.split('/').slice(-2)[0]
+        if (id.endsWith(DISABLING_POSTFIX)) continue
+        if (!enablePlugins.get().includes(id)) {
+            try {
+                const source = await readFile(f, 'utf8')
+                foundDisabled[id] = parsePluginSource(id, source)
+            }
+            catch {}
+            continue
+        }
+        found.push(id)
+        if (plugins[id]) // already loaded
+            continue
+        const module = pathLib.resolve(f)
+        const { unwatch } = watchLoad(f, async () => {
+            try {
+                const alreadyRunning = plugins[id]
+                console.log(alreadyRunning ? "reloading plugin" : "loading plugin", id)
+                const { init, ...data } = await import(module)
+                delete data.default
+                deleteModule(require.resolve(module)) // avoid caching at next import
+                calculateBadApi(data)
+                if (data.badApi)
+                    console.log("plugin", id, data.badApi)
+
+                await alreadyRunning?.unload(true)
+                console.debug("starting plugin", id)
+                const res = await init?.call(null, {
+                    srcDir: __dirname,
+                    const: Const,
+                    require,
+                    getConnections,
+                    events,
+                    log(...args: any[]) {
+                        console.log('plugin', id, ':', ...args)
+                    },
+                    getConfig: (cfgKey: string) =>
+                        pluginsConfig.get()?.[id]?.[cfgKey] ?? data.config?.[cfgKey]?.defaultValue,
+                    setConfig: (cfgKey: string, value: any) =>
+                        setPluginConfig(id, { [cfgKey]: value }),
+                    subscribeConfig(cfgKey: string, cb: Callback<any>) {
+                        let last = this.getConfig(cfgKey)
+                        cb(last)
+                        return pluginsConfig.sub(() => {
+                            const now = this.getConfig(cfgKey)
+                            if (same(now, last)) return
+                            try { cb(last = now) }
+                            catch(e){
+                                console.log('plugin', id, String(e))
+                            }
+                        })
+                    },
+                    getHfsConfig: getConfig,
+                })
+                Object.assign(data, res)
+                const plugin = new Plugin(id, data, unwatch)
+                if (alreadyRunning)
+                    events.emit('pluginUpdated', Object.assign(_.pick(plugin, 'started'), getPluginInfo(id)))
+                else {
+                    const wasInstalled = availablePlugins[id]
+                    if (wasInstalled)
+                        delete availablePlugins[id]
+                    events.emit(wasInstalled ? 'pluginStarted' : 'pluginInstalled', plugin)
+                }
+
+            } catch (e) {
+                console.log("plugin error:", e)
+            }
+        })
+    }
+    for (const id in foundDisabled) {
+        const p = foundDisabled[id]
+        const a = availablePlugins[id]
+        if (same(a, p)) continue
+        availablePlugins[id] = p
+        if (a)
+            events.emit('pluginUpdated', p)
+        else if (!plugins[id])
+            events.emit('pluginInstalled', p)
+    }
+    for (const id in availablePlugins)
+        if (!foundDisabled[id] && !found.includes(id) && !plugins[id]) {
+            delete availablePlugins[id]
+            events.emit('pluginUninstalled', id)
+        }
+    for (const id in plugins)
+        if (!found.includes(id))
+            await plugins[id].unload()
+}
+
+function deleteModule(id: string) {
+    const { cache } = require
+    // build reversed map of dependencies
+    const requiredBy: Record<string,string[]> = { '.':['.'] } // don't touch main entry
+    for (const k in cache)
+        if (k !== id)
+            for (const child of wantArray(cache[k]?.children))
+                getOrSet(requiredBy, child.id, ()=> [] as string[]).push(k)
+    const deleted: string[] = []
+    recur(id)
+
+    function recur(id: string) {
+        let mod = cache[id]
+        if (!mod) return
+        delete cache[id]
+        deleted.push(id)
+        for (const child of mod.children)
+            if (! _.difference(requiredBy[child.id], deleted).length)
+                recur(child.id)
+    }
+}
+
+onProcessExit(() =>
+    Promise.allSettled(mapPlugins(pl => pl.unload())))
+
+export function parsePluginSource(id: string, source: string) {
+    const pl: AvailablePlugin = { id }
+    pl.description = tryJson(/exports.description *= *(".*")/.exec(source)?.[1])
+    pl.repo = /exports.repo *= *"(.*)"/.exec(source)?.[1]
+    pl.version = Number(/exports.version *= *(\d*\.?\d+)/.exec(source)?.[1]) ?? undefined
+    pl.apiRequired = tryJson(/exports.apiRequired *= *([ \d.,[\]]+)/.exec(source)?.[1]) ?? undefined
+    if (Array.isArray(pl.apiRequired) && (pl.apiRequired.length !== 2 || !pl.apiRequired.every(_.isFinite))) // validate [from,to] form
+        pl.apiRequired = undefined
+    calculateBadApi(pl)
+    return pl
+}
+
+function calculateBadApi(data: AvailablePlugin) {
+    const r = data.apiRequired
+    const [min, max] = Array.isArray(r) ? r : [r, r] // normalize data type
+    data.badApi = min! > API_VERSION ? "may not work correctly as it is designed for a newer version of HFS - check for updates"
+        : max! < COMPATIBLE_API_VERSION ? "may not work correctly as it is designed for an older version of HFS - check for updates"
+            : undefined
+}