keybase-proofs 2.3.33 → 2.3.34

package/src/wot.iced

@@ -1,96 +0,0 @@
-{Base} = require './base'
-{constants} = require './constants'
-{make_esc} = require 'iced-error'
-pgp_utils = require('pgp-utils')
-{json_stringify_sorted,unix_time,streq_secure} = pgp_utils.util
-schema = require './schema3'
-
-#==========================================================================
-
-exports.Vouch = class Vouch extends Base
-
-  constructor : (obj) ->
-    @wot = obj.wot
-    super obj
-
-  _v_stub_paths : () -> [ "body.wot_vouch" ]
-  _type : () -> constants.sig_types.wot.vouch
-
-  _type_v2 : (revoke_flag) ->
-    if @revoke? or revoke_flag then constants.sig_types_v2.wot.vouch_with_revoke
-    else constants.sig_types_v2.wot.vouch
-
-  _v_check : ({json}, cb) ->
-    obj = json.body.wot_vouch
-    if not obj? then return cb null
-
-    proof_schema = schema.or([
-      schema.dict({
-        proof_type : schema.int(), # keybase1.ProofType
-        name : schema.string(),
-        username : schema.string()
-      }),
-      schema.dict({
-        proof_type : schema.int(),
-        protocol : schema.string(),
-        hostname : schema.string()
-      }),
-      schema.dict({
-        proof_type : schema.int(),
-        protocol : schema.string(),
-        domain : schema.string()
-      })
-    ])
-
-    schm = schema.dict({
-      user : schema.dict({
-        username : schema.string()
-        uid : schema.uid().convert()
-        eldest : schema.dict({
-          seqno : schema.int()
-          kid : schema.kid().convert()
-        })
-        seq_tail : schema.dict({
-         seqno : schema.int()
-         sig_id : schema.sig_id().convert()
-         payload_hash : schema.hash().convert()
-        })
-      })
-      confidence : schema.dict({
-        username_verified_via : schema.string_enum(["in_person", "proofs", "video", "audio", "other_chat", "familiar", "other"]).optional()
-        proofs: schema.array(proof_schema).optional()
-        other : schema.string({max_length: 90}).optional()
-      })
-      vouch_text : schema.string({max_length: 700})
-    })
-    err = schm.check(obj)
-    cb err
-
-   _v_customize_json : (ret) ->
-    ret.body.wot_vouch = t if (t = @wot?.vouch)?
-
-#==========================================================================
-
-exports.React = class React extends Base
-
-  constructor : (obj) ->
-    @wot = obj.wot
-    super obj
-
-  _v_stub_paths : () -> [ "body.wot_react" ]
-  _type : () -> constants.sig_types.wot.react
-
-  _type_v2 : (revoke_flag) -> constants.sig_types_v2.wot.react
-
-  _v_check : ({json}, cb) ->
-    obj = json.body.wot_react
-    schm = schema.dict({
-      sig_id : schema.sig_id().convert()
-      reaction : schema.string_enum(["accept", "reject"])
-    })
-    cb schm.check(obj)
-
-   _v_customize_json : (ret) ->
-    ret.body.wot_react = t if (t = @wot.react)?
-
-#==========================================================================

package/test/files/wot.iced

@@ -1,99 +0,0 @@
-{alloc,wot,constants} = require '../../'
-{EncKeyManager,KeyManager} = require('kbpgp').kb
-{make_esc} = require 'iced-error'
-{new_uid,new_km_and_sig_arg,new_sig_id,new_payload_hash} = require './util'
-pgp_utils = require('pgp-utils')
-{json_stringify_sorted} = pgp_utils.util
-{unpack} = require 'purepack'
-
-exports.wot_vouch_happy = (T,cb) ->
-  esc = make_esc cb
-  await new_km_and_sig_arg {}, esc defer me
-  await new_km_and_sig_arg {}, esc defer them
-  proof1 = { proof_type : 4, name : "reddit", username : "betaveros" }
-  proof2 = { proof_type : 9, name : "mastodon.social", username : "gammaveros" }
-  proof3 = { proof_type : 1000, protocol : "https:", hostname : "beta.veros" }
-  proof4 = { proof_type : 1001, protocol : "dns", hostname : "beta.veros" }
-  me.wot =
-    vouch :
-      user :
-        username : them.user.local.username
-        uid : them.user.local.uid
-        eldest:
-          kid : them.sig_eng.km.key.ekid().toString('hex')
-          seqno : 1
-        seq_tail :
-          seqno : 20
-          sig_id : new_sig_id()
-          payload_hash : new_payload_hash()
-      confidence :
-        username_verified_via : "audio"
-        other : "lorem ipsum"
-        proofs : [ proof1, proof2]
-      vouch_text : "darn rootin tootin"
-  obj = new wot.Vouch me
-  await obj.generate_v2 esc(defer(out)), {dohash:true}
-  hsh = out.inner.obj.body.wot_vouch
-  T.assert hsh?, "hash was there"
-  T.equal hsh.length, 64, "64-byte hex string"
-  T.assert out.expansions[hsh]?.obj?, "expansion was there"
-
-  verifier = alloc out.inner.obj.body.type, me
-  varg = { armored : out.armored, skip_ids : true, make_ids : true, inner : out.inner.str, expansions : out.expansions, require_packet_hash :true}
-  await verifier.verify_v2 varg, esc defer()
-
-  me.wot =
-    react :
-      sig_id : new_sig_id()
-      reaction : "accept"
-  obj = new wot.React me
-  await obj.generate_v2 esc(defer(out)), {dohash:true}
-  verifier = alloc out.inner.obj.body.type, me
-  varg = { armored : out.armored, skip_ids : true, make_ids : true, inner : out.inner.str, expansions : out.expansions, require_packet_hash :true}
-  await verifier.verify_v2 varg, esc defer()
-
-  # try to revoke both with and without a replacement...
-  me.revoke = { sig_ids : [ new_sig_id() ]}
-  obj = new wot.Vouch me
-  await obj.generate_v2 esc(defer(out)), {dohash:true}
-  outer = unpack out.outer
-  T.equal outer[4], constants.sig_types_v2.wot.vouch_with_revoke, "revoke picked up"
-
-  me.wot = null
-  obj = new wot.Vouch me
-  await obj.generate_v2 esc(defer(out)), {dohash:true}
-  outer = unpack out.outer
-  T.equal outer[4], constants.sig_types_v2.wot.vouch_with_revoke, "revoke picked up"
-
-  cb null
-
-exports.wot_vouch_bad = (T,cb) ->
-  esc = make_esc cb
-  await new_km_and_sig_arg {}, esc defer me
-  await new_km_and_sig_arg {}, esc defer them
-  me.wot =
-    vouch :
-      user :
-        username : them.user.local.username
-        uid : them.user.local.uid
-        eldest:
-          kid : them.sig_eng.km.key.ekid().toString('hex')
-          seqno : 1
-        seq_tail :
-          seqno : 20
-          sig_id : new_sig_id()
-          payload_hash : new_payload_hash()
-      confidence :
-        username_verified_via : "audio"
-        other : "this string is longer than 90 char this string is longer than 90 char this string is longer than 90 char this string is longer than 90 char"
-      vouch_text : "darn rootin tootin"
-  obj = new wot.Vouch me
-  await obj.generate_v2 esc(defer(out)), {dohash:true}
-
-  verifier = alloc out.inner.obj.body.type, me
-  varg = { armored : out.armored, skip_ids : true, make_ids : true, inner : out.inner.str, expansions : out.expansions, require_packet_hash :true}
-  await verifier.verify_v2 varg, defer err
-  T.assert err?, "got an error back"
-  T.assert (err.message.indexOf(".confidence.other") >= 0), "found right error message"
-
-  cb null

package/test/make_esc.iced

@@ -1,48 +0,0 @@
-C = require('iced-runtime').const
-
-exports.skip = true
-
-ipush = (e, msg) ->
-  if msg?
-    # Note: `e.istack = []` will be a noop if e is a primitive type
-    # like number or string. We have to check if `e.istack` exists
-    # before pushing so we don't crash.
-    e.istack = [] unless e.istack?
-    e.istack?.push msg
-
-copy_trace = (src, dst) ->
-  dst[C.trace] = src[C.trace]
-  dst
-
-# Error short-circuit connector with more verbose istack.
-
-# When resulting `esc` function is called, an istack entry will be constructed
-# based on iced trace object. This way istack will be populated by not only esc
-# identifiers (usually call site function names) but also filenames and line
-# numbers of call sites of individual esc() calls. If an error happens and
-# short-circuited back from deep in some test, it should be easier to identify
-# where exactly it originates from using the new istack.
-
-exports.make_esc = make_esc = (gcb, where) ->
-  # Create "global where" based on make_esc() call site.
-  where = make_esc.caller?.name unless where?
-  return (lcb) ->
-    # Create "local where" based on esc() call site. So every
-    # esc(defer(...)) will have its own istack entry, if iced
-    # trace object is available.
-    sb = [ where ]
-    if (tr = lcb[C.trace])
-      sb.push "Trace:"
-      sb.push tr[C.funcname]
-      sb.push "(#{tr[C.filename]}:#{tr[C.lineno] + 1})"
-    local_where = sb.filter((x) -> x).join(' ')
-    copy_trace lcb, (err, args...) ->
-      if not err? then lcb args...
-      else if not gcb.__esc
-        gcb.__esc = true
-        ipush err, local_where
-        gcb err
-
-exports.patch_make_esc = () ->
-  iced_error = require 'iced-error'
-  iced_error.make_esc = make_esc