@mblaney/holster 0.1.0

package/src/user.js

@@ -0,0 +1,330 @@
+import * as utils from "./utils.js"
+import Wire from "./wire.js"
+import SEA from "./sea.js"
+
+const User = (opt, wire) => {
+  if (!wire) wire = Wire(opt)
+  let pubs = []
+  let creating = false
+  let authing = false
+  let retries = 0
+
+  const auth = (username, password, newPassword, ack) => {
+    const retry = username => {
+      retries++
+      auth(username, password, newPassword, ack)
+    }
+    const done = err => {
+      pubs = []
+      retries = 0
+      authing = false
+      ack(err)
+    }
+    const next = () => {
+      if (pubs.length === 0) {
+        done("Wrong username or password")
+        return
+      }
+
+      const pub = pubs.shift()
+      wire.get({"#": pub}, async msg => {
+        if (msg.err) {
+          done(`error getting ${pub}: ${msg.err}`)
+          return
+        }
+
+        const data = msg.put && msg.put[pub]
+        if (!data || !data.auth) return next()
+
+        const auth = JSON.parse(data.auth)
+        const work = await SEA.work(password, auth.salt)
+        const dec = await SEA.decrypt(auth.enc, work)
+        if (!dec) return next()
+
+        user.is = {
+          username: username,
+          pub: data.pub,
+          epub: data.epub,
+          priv: dec.priv,
+          epriv: dec.epriv,
+        }
+        // Holster API uses ctx to set the root node for user data.
+        user.ctx = "~" + data.pub
+
+        if (newPassword !== "") {
+          // Encrypt private key using new password and a new salt.
+          const salt = utils.text.random(64)
+          const work = await SEA.work(newPassword, salt)
+          const enc = await SEA.encrypt(dec, work)
+          const auth = {auth: JSON.stringify({enc: enc, salt: salt})}
+          const signed = await SEA.sign(auth, user.is)
+          const graph = utils.graph(pub, signed.m, signed.s, data.pub)
+          wire.put(graph, err => {
+            if (err) {
+              done(`error putting ${auth} on ${pub}: ${err}`)
+            } else {
+              done(null)
+            }
+          })
+          return
+        }
+
+        return done(null)
+      })
+    }
+
+    if (retries > 9) {
+      done("Wrong username or password")
+      return
+    }
+
+    const soul = "~@" + username
+    wire.get({"#": soul}, async msg => {
+      if (msg.err) {
+        done(`error getting ${soul}: ${msg.err}`)
+        return
+      }
+
+      const data = msg.put && msg.put[soul]
+      if (!data) return retry(username)
+
+      delete msg.put[soul]._
+      // Usernames aren't guaranteed to be unique, so store the list and then
+      // try each of them until one is successful with the given password.
+      pubs = Object.keys(data)
+      next()
+    })
+  }
+
+  const user = {
+    create: (username, password, cb) => {
+      const ack = err => {
+        if (cb) cb(err)
+        else console.log(err)
+      }
+
+      if (creating) {
+        ack("User is already being created")
+        return
+      }
+
+      if (username === "") {
+        ack("Please provide a username")
+        return
+      }
+
+      if (password === "") {
+        ack("Please provide a password")
+        return
+      }
+
+      creating = true
+
+      const soul = "~@" + username
+      wire.get({"#": soul}, async msg => {
+        if (msg.err) {
+          creating = false
+          ack(`error getting ${soul}: ${msg.err}`)
+          return
+        }
+
+        if (msg.put && msg.put[soul]) {
+          creating = false
+          ack("Username already exists")
+          return
+        }
+
+        const salt = utils.text.random(64)
+        const work = await SEA.work(password, salt)
+        const pair = await SEA.pair()
+        const priv = {priv: pair.priv, epriv: pair.epriv}
+        const enc = await SEA.encrypt(priv, work)
+        const data = {
+          username: username,
+          pub: pair.pub,
+          epub: pair.epub,
+          auth: JSON.stringify({enc: enc, salt: salt}),
+        }
+
+        const pub = "~" + pair.pub
+        const signed = await SEA.sign(data, pair)
+        const graph = utils.graph(pub, signed.m, signed.s, pair.pub)
+        wire.put(graph, err => {
+          creating = false
+          if (err) {
+            ack(`error putting ${data} on ${pub}: ${err}`)
+            return
+          }
+
+          const rel = {[pub]: {"#": pub}}
+          wire.put(utils.graph(soul, rel), err => {
+            if (err) {
+              ack(`error putting ${rel} on ${soul}: ${err}`)
+              return
+            }
+
+            // Return null on success.
+            if (cb) cb(null)
+          })
+        })
+      })
+    },
+    auth: (username, password, cb) => {
+      const ack = err => {
+        if (cb) cb(err)
+        else if (err) console.log(err)
+      }
+
+      if (authing) {
+        ack("User is already authenticating")
+        return
+      }
+
+      user.is = null
+
+      if (username === "") {
+        ack("Please provide a username")
+        return
+      }
+
+      if (password === "") {
+        ack("Please provide a password")
+        return
+      }
+
+      authing = true
+      auth(username, password, "", ack)
+    },
+    change: (username, password, newPassword, cb) => {
+      const ack = err => {
+        if (cb) cb(err)
+        else if (err) console.log(err)
+      }
+
+      if (authing) {
+        ack("User is already authenticating")
+        return
+      }
+
+      user.is = null
+
+      if (username === "") {
+        ack("Please provide a username")
+        return
+      }
+
+      if (password === "") {
+        ack("Please provide a password")
+        return
+      }
+
+      if (newPassword === "") {
+        ack("Please provide a new password")
+        return
+      }
+
+      authing = true
+      auth(username, password, newPassword, ack)
+    },
+    store: localStorage => {
+      if (!user.is) {
+        console.log("Please authenticate before calling store")
+        return
+      }
+
+      if (localStorage) {
+        if (typeof globalThis.localStorage !== "undefined") {
+          globalThis.localStorage.setItem("user.is", JSON.stringify(user.is))
+        }
+        return
+      }
+
+      if (typeof globalThis.sessionStorage !== "undefined") {
+        globalThis.sessionStorage.setItem("user.is", JSON.stringify(user.is))
+      }
+    },
+    recall: localStorage => {
+      if (localStorage) {
+        if (typeof globalThis.localStorage !== "undefined") {
+          const is = globalThis.localStorage.getItem("user.is")
+          if (is) {
+            user.is = JSON.parse(is)
+            user.ctx = "~" + user.is.pub
+          } else {
+            console.log("User credentials not stored in local storage")
+          }
+        }
+        return
+      }
+
+      if (typeof globalThis.sessionStorage !== "undefined") {
+        const is = globalThis.sessionStorage.getItem("user.is")
+        if (is) {
+          user.is = JSON.parse(is)
+          user.ctx = "~" + user.is.pub
+        } else {
+          console.log("User credentials not stored in session storage")
+        }
+      }
+    },
+    leave: () => {
+      user.is = null
+      user.ctx = null
+      if (typeof globalThis.localStorage !== "undefined") {
+        globalThis.localStorage.removeItem("user.is")
+      }
+      if (typeof globalThis.sessionStorage !== "undefined") {
+        globalThis.sessionStorage.removeItem("user.is")
+      }
+    },
+    delete: (username, password, cb) => {
+      const ack = err => {
+        if (cb) cb(err)
+        else console.log(err)
+      }
+
+      if (authing) {
+        ack("User is already authenticating")
+        return
+      }
+
+      if (username === "") {
+        ack("Please provide a username")
+        return
+      }
+
+      if (password === "") {
+        ack("Please provide a password")
+        return
+      }
+
+      authing = true
+      auth(username, password, "", async err => {
+        if (err) {
+          ack(err)
+          return
+        }
+
+        const data = {username: null, pub: null, epub: null, auth: null}
+        const signed = await SEA.sign(data, user.is)
+        const pub = "~" + user.is.pub
+        const graph = utils.graph(pub, signed.m, signed.s, user.is.pub)
+        wire.put(graph, err => {
+          if (err) {
+            ack(`error putting null on ${pub}: ${err}`)
+            return
+          }
+
+          user.is = null
+          user.ctx = null
+          // Return null on success. Note currently not updating ~@username,
+          // not sure if allowing username re-user is a good idea anyway?
+          if (cb) cb(null)
+        })
+      })
+    },
+  }
+  return user
+}
+
+export default User

package/src/utils.js

@@ -0,0 +1,124 @@
+export const num = {
+  is: n =>
+    !(n instanceof Array) &&
+    (n - parseFloat(n) + 1 >= 0 || Infinity === n || -Infinity === n),
+}
+
+export const obj = {
+  is: o => {
+    if (!o) return false
+
+    return (
+      (o instanceof Object && o.constructor === Object) ||
+      Object.prototype.toString.call(o).match(/^\[object (\w+)\]$/)[1] ===
+        "Object"
+    )
+  },
+  map: (list, cb, o) => {
+    var keys = Object.keys(list)
+    for (let i = 0; i < keys.length; i++) {
+      let result = cb(list[keys[i]], keys[i], o)
+      if (typeof result !== "undefined") return result
+    }
+  },
+  put: (o, key, value) => {
+    if (!o) o = {}
+    o[key] = value
+    return o
+  },
+  del: (o, key) => {
+    if (!o) return
+
+    o[key] = null
+    delete o[key]
+    return o
+  },
+}
+
+const map_soul = (soul, key, o) => {
+  // If id is already defined AND we're still looping through the object,
+  // then it is considered invalid.
+  if (o.id) {
+    o.id = false
+    return
+  }
+
+  if (key === "#" && typeof soul === "string") {
+    o.id = soul
+    return
+  }
+
+  // If there exists anything else on the object that isn't the soul,
+  // then it is considered invalid.
+  o.id = false
+}
+
+// Check if an object is a soul relation, ie {'#': 'UUID'}
+export const rel = {
+  is: value => {
+    if (value && value["#"] && !value._ && obj.is(value)) {
+      let o = {}
+      obj.map(value, map_soul, o)
+      if (o.id) return o.id
+    }
+
+    return false
+  },
+  // Convert a soul into a relation and return it.
+  ify: soul => obj.put({}, "#", soul),
+}
+
+export const userPublicKey = "_holster_user_public_key"
+
+// graph converts objects to graph format with updated states,
+// with optional meta data to verify signed data.
+export const graph = (soul, data, sig, pub) => {
+  const g = {[soul]: {_: {"#": soul, ">": {}, s: sig, p: pub}}}
+  for (const [key, value] of Object.entries(data)) {
+    g[soul][key] = value
+    g[soul]._[">"][key] = Date.now()
+  }
+  // If a public key is provided it also needs to be stored on the node to
+  // ensure that future updates are only possible with the same public key.
+  if (pub) {
+    g[soul][userPublicKey] = pub
+    g[soul]._[">"][userPublicKey] = Date.now()
+  }
+  return g
+}
+
+export const match = (lex, key) => {
+  // Null is used to match listeners on souls, which don't provide a key.
+  if (typeof key === "undefined") return lex === null
+
+  if (typeof lex === "undefined") return true
+
+  if (typeof lex === "string") return lex === key
+
+  if (!obj.is(lex) || !key) return false
+
+  const prefix = lex["*"]
+  if (prefix) return key.slice(0, prefix.length) === prefix
+
+  const gt = lex[">"]
+  const lt = lex["<"]
+  if (gt && lt) return key >= gt && key <= lt
+
+  if (gt) return key >= gt
+
+  if (lt) return key <= lt
+
+  return false
+}
+
+export const text = {
+  random: length => {
+    var s = ""
+    const c = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXZabcdefghijklmnopqrstuvwxyz"
+    if (!length) length = 24
+    for (let i = 0; i < length; i++) {
+      s += c.charAt(Math.floor(Math.random() * c.length))
+    }
+    return s
+  },
+}