keybase-proofs 2.3.34 → 2.3.35

package/test/files/generic_social.iced

@@ -1,67 +0,0 @@
-{alloc,GenericSocialBinding,constants} = require '../../'
-{EncKeyManager,KeyManager} = require('kbpgp').kb
-{make_esc} = require 'iced-error'
-{new_sig_arg} = require './util'
-
-generic_name_regexp = /^[a-z0-9_-]{2,15}$/
-
-exports.test_generic_social_proof = (T, cb) ->
-  esc = make_esc cb, "test_generic_social_proof"
-  await KeyManager.generate {}, esc defer device
-  arg = new_sig_arg { km : device }
-  arg.user.remote = "al1ce"
-  arg.remote_service = "api.crypto_pals.social"
-  arg.name_regexp = generic_name_regexp
-  obj = new GenericSocialBinding arg
-  await obj.generate esc defer out
-
-  obj2 = alloc "web_service_binding.generic_social", arg
-  err = obj2.check_inputs()
-  T.assert not(err?), "expects check_inputs not to return error, returned: #{err?.toString()}"
-  varg = { armored : out.armored, skip_ids : true, make_ids : true, inner : out.inner.str }
-  await obj2.verify varg, esc defer err
-
-  T.equal obj2.service_obj(), { name : arg.remote_service, username : arg.user.remote }
-  T.equal obj2.proof_type(), constants.proof_types.generic_social, "got right proof_type"
-  T.equal obj2.service_name(), arg.remote_service, "got right service_name"
-  T.equal obj2.single_occupancy(), false, "got right single_occupancy"
-
-  cb null
-
-exports.test_generic_social_inputs = (T, cb) ->
-  assert_err = (err, str) ->
-    err_str = err?.toString()
-    T.assert err_str?.indexOf(str) isnt -1, "Expecting error to contain '#{str}', got: #{err_str}"
-
-  esc = make_esc cb, "test_generic_social_proof"
-  await KeyManager.generate {}, esc defer device
-  arg = new_sig_arg { km : device }
-  arg.user.remote = "b0b"
-  arg.remote_service = "cryptopals"
-  arg.name_regexp = generic_name_regexp
-  obj = new GenericSocialBinding arg
-  err = obj.check_inputs()
-  assert_err err, "invalid remote_service"
-
-  arg.remote_service = "cryptopals.club"
-  arg.user.remote = "HelloBobby$$$"
-  obj = new GenericSocialBinding arg
-  err = obj.check_inputs()
-  assert_err err, "Bad remote_username given"
-
-  arg = new_sig_arg { km : device }
-  arg.user.remote = "b0b"
-  arg.remote_service = "cryptopals.club"
-  obj = new GenericSocialBinding arg
-  err = obj.check_inputs()
-  assert_err err, "No name_regexp given"
-
-  # Invalid regexp
-  arg.name_regexp = "[1-.]{1,5}"
-  obj = new GenericSocialBinding arg
-  err = obj.check_inputs()
-  assert_err err, "No name_regexp given"
-
-  cb null
-
-

package/test/files/parse3.iced

@@ -1,61 +0,0 @@
-parse3 = require '../../lib/parse3'
-schema = require '../../lib/schema3'
-
-exports.hex_rejects_trailing_junk = (T, cb) ->
-  uid = "00".repeat(15) + "19"
-  hash = "00".repeat(32)
-
-  uid_upper = "AA".repeat(15) + "19"
-
-  T.assert parse3.is_hex(uid, 16), "valid uid hex is accepted"
-  T.assert parse3.is_hex(uid_upper, 16), "uppercase uid hex is accepted"
-  T.assert not parse3.is_hex(uid + "zz", 16), "uid hex plus junk is rejected"
-  T.assert not parse3.is_hex(uid + "a", 16), "odd-length uid hex is rejected"
-  T.assert not parse3.is_hex(hash + "nothex", 32), "hash hex plus junk is rejected"
-
-  T.assert not parse3.is_uid(hash), "length has to match"
-
-  err = schema.uid().convert().check uid
-  T.assert not err?, "valid uid converts"
-
-  err = schema.uid().convert().check uid_upper
-  T.assert not err?, "uppercase uid converts"
-
-  err = schema.uid().convert().check hash
-  T.assert err?, "length has to match"
-
-  err = schema.uid().convert().check uid + "zz"
-  T.assert err?, "uid with trailing junk is rejected"
-
-  err = schema.uid().convert().check uid + "a"
-  T.assert err?, "odd-length uid is rejected"
-
-  err = schema.hash().convert().check hash + "zz"
-  T.assert err?, "hash with trailing junk is rejected"
-
-  out = parse3.unhex uid
-  T.assert Buffer.isBuffer(out) and out.length is 16, "unhex accepts valid uid"
-
-  out = parse3.unhex uid_upper
-  T.assert Buffer.isBuffer(out) and out.length is 16, "unhex accepts uppercase uid"
-
-  for bad in [uid + "zz", uid + "a"]
-    err = null
-    try
-      parse3.unhex bad
-    catch e
-      err = e
-    T.assert err?, "unhex rejects #{bad}"
-    T.assert err.toString().indexOf("bad binary or hex string") >= 0, "unhex error message"
-
-  cb null
-
-exports.hex_rejects_length_like_objects = (T, cb) ->
-  uid_buf = Buffer.alloc 16
-  T.assert parse3.is_hex(uid_buf, 16), "buffer of the right length is accepted"
-  T.assert not parse3.is_hex(Buffer.alloc(15), 16), "buffer of the wrong length is rejected"
-  T.assert not parse3.is_hex({length : 16}, 16), "plain object with length is rejected"
-  T.assert not parse3.is_hex((0 for i in [0...16]), 16), "array of the right length is rejected"
-  T.assert not parse3.is_uid({length : 16}), "is_uid rejects a length-like object"
-
-  cb null

package/test/files/per_user_key.iced

@@ -1,74 +0,0 @@
-{EncKeyManager,KeyManager} = require('kbpgp').kb
-{make_esc} = require 'iced-error'
-{alloc,PerUserKey} = require '../../'
-{prng} = require 'crypto'
-{new_sig_arg} = require './util'
-pgp_utils = require('pgp-utils')
-{json_stringify_sorted} = pgp_utils.util
-
-exports.test_per_user_key = (T,cb) ->
-  esc = make_esc cb, "test_per_user_key"
-  await EncKeyManager.generate {}, esc defer ekm
-  await KeyManager.generate {}, esc defer skm
-  await KeyManager.generate {}, esc defer pkm
-  arg = new_sig_arg { km : pkm }
-  arg.kms =
-    encryption : ekm
-    signing : skm
-  arg.generation = 1
-  pf = new PerUserKey arg
-  await pf.generate_v2 esc defer out
-  pf2 = alloc out.inner.obj.body.type, arg
-  varg = { armored : out.armored, skip_ids : true, make_ids : true, inner : out.inner.str }
-  await pf2.verify_v2 varg, esc defer()
-  cb()
-
-round_trip_with_corrupted_reverse_sig = ({T, corrupt, skip_reverse_sig}, cb) ->
-  esc = make_esc cb, "round_trip_with_corrupted_reverse_sig"
-  await KeyManager.generate {}, esc defer elder
-  await KeyManager.generate {}, esc defer skm
-  await EncKeyManager.generate {}, esc defer ekm
-  arg = new_sig_arg { km : elder }
-  arg.kms =
-    encryption : ekm
-    signing : skm
-  arg.generation = 3
-  obj = new PerUserKey arg
-
-  obj._v_generate = (opts, cb) ->
-    esc = make_esc cb, "_v_generate"
-    x = { reverse_sig: null }
-    @set_new_key_section x
-    x.signing_kid = @get_new_km().get_ekid().toString('hex')
-    eng = @get_new_km().make_sig_eng()
-    await @generate_json { version : opts.version }, esc defer msg
-    msg2 = JSON.parse msg
-    msg2.foo = "bar" if corrupt
-    msg = json_stringify_sorted(msg2)
-    await eng.box msg, esc defer { armored, type }
-    x.reverse_sig = armored unless skip_reverse_sig
-    cb null
-
-  await obj.generate esc defer out
-  typ = out.inner.obj.body.type
-  obj2 = alloc typ, arg
-  varg = { armored : out.armored, skip_ids : true, make_ids : true, inner : out.inner.str }
-  await obj2.verify varg, defer err
-  if corrupt
-    T.assert err?, "got an error back"
-    T.assert (err.message.indexOf('Reverse sig json mismatch') >= 0), "found right error message"
-  else if skip_reverse_sig
-    T.assert err?, "got an error back"
-    T.assert (err.message.indexOf("Need a reverse sig, but didn't find one") >= 0), "found right error message"
-  else
-    T.no_error err, "in the success case, don't expect an error"
-  cb null
-
-exports.test_corruption_mechanism = (T,cb) ->
-  round_trip_with_corrupted_reverse_sig { T, corrupt : false }, cb
-
-exports.test_reverse_sig_failure = (T,cb) ->
-  round_trip_with_corrupted_reverse_sig { T, corrupt : true }, cb
-
-exports.test_reverse_sig_failure = (T,cb) ->
-  round_trip_with_corrupted_reverse_sig { T, skip_reverse_sig : true }, cb

package/test/files/schema3.iced

@@ -1,258 +0,0 @@
-schema = require '../../lib/schema3'
-{pack,unpack} = require 'purepack'
-
-# These collide with Object.prototype and with lookups like obj[k] /
-# obj.hasOwnProperty(k).
-_object_proto_names = [
-  "__proto__"
-  "constructor"
-  "hasOwnProperty"
-  "isPrototypeOf"
-  "propertyIsEnumerable"
-  "toLocaleString"
-  "toString"
-  "valueOf"
-]
-# "Weird key names" - Object prototype keys but handled by schema3 library.
-# With the exception of __proto__ - this one is banned because it requires
-# extra care to get right and has more footguns. See src/schema3.iced
-# is_reserved_key_name
-_weird_key_names = (n for n in _object_proto_names when n isnt "__proto__")
-
-exports.prototype_pollution_json = (T, cb) ->
-  # parsing "__proto__" property should not change resulting object's
-  # prototype.
-  obj = JSON.parse('{"__proto__":1}')
-  T.assert Object.getPrototypeOf(obj) is Object.prototype, "is Object.prototype"
-  T.assert Object::hasOwnProperty.call(obj, '__proto__'), "hasOwnProperty __proto__"
-
-  cb null
-
-exports.prototype_pollution_purepack = (T, cb) ->
-  # purepack does not allow __proto__ keys, although accidentially.
-
-  # Create a purepack with aaaaaaaaa property
-  aaa = Buffer.from (pack { aaaaaaaaa : 1 })
-
-  # Sanity check, 'aaaaaaaaa' is just a normal key in an unpacked object.
-  obj = unpack aaa
-  T.assert Object.getPrototypeOf(obj) is Object.prototype, "is Object.prototype"
-  T.assert Object::hasOwnProperty.call(obj, 'aaaaaaaaa'), "hasOwnProperty aaaaaaaaa"
-
-  # Str-replace aaaaaaaaa into __proto__
-  bin = Buffer.from(aaa.toString('binary').replace('aaaaaaaaa', '__proto__'), 'binary')
-  err = null
-  try
-    unpack(bin)
-  catch e
-    err = e
-  T.assert err?
-  T.equal err?.message, "duplicate key '__proto__'"
-
-  cb null
-
-exports.or_combinator = (T, cb) ->
-  schm = schema.or([
-    schema.dict({
-      name : schema.string()
-      username : schema.string()
-    })
-    schema.dict({
-      protocol : schema.string()
-      hostname : schema.string()
-    })
-  ])
-
-  err = schm.check { name : "reddit", username : "alice" }
-  T.assert not err?, "object matching first term is accepted"
-
-  err = schm.check { protocol : "https:", hostname : "example.com" }
-  T.assert not err?, "object matching second term is accepted"
-
-  err = schm.check { invalid : 1, obj : 2 }
-  T.assert err?, "object matching no term is rejected"
-  T.equal err?.message, "At <top>: no structure worked"
-
-  cb null
-
-exports.required_null_rejected = (T, cb) ->
-  for val in [null, undefined]
-    err = schema.array(schema.obj()).check [val]
-    T.assert err?, "array of obj() rejects null"
-    T.equal err?.message, "At <top>.0: value cannot be null"
-
-    err = schema.array(schema.string()).check [val]
-    T.assert err?, "array of obj() rejects null"
-    T.equal err?.message, "At <top>.0: value cannot be null"
-
-    err = schema.struct([schema.obj()]).check [val]
-    T.assert err?, "struct of obj() rejects null"
-    T.equal err?.message, "At <top>.0: value cannot be null"
-
-    err = schema.struct([schema.string()]).check [val]
-    T.assert err?, "struct of obj() rejects null"
-    T.equal err?.message, "At <top>.0: value cannot be null"
-
-    err = schema.dict({ x : schema.obj() }).check { x : val }
-    T.assert err?, "dict required obj() null is rejected"
-    T.equal err?.message, "At <top>.x: value cannot be null"
-
-    err = schema.dict({ x : schema.string() }).check { x : val }
-    T.assert err?, "dict required string null is rejected"
-    T.equal err?.message, "At <top>.x: value cannot be null"
-
-    err = schema.dict({ x : schema.string().optional() }).check { x : val }
-    T.assert not err?, "dict optional string null is accepted"
-
-  cb null
-
-exports.dict_missing_mandatory_key = (T, cb) ->
-  schm = schema.dict({
-    n : schema.string().name("name")
-    nick : schema.string().optional()
-  })
-
-  err = schm.check { n : "alice" }
-  T.assert not err?, "optional key may be omitted"
-
-  err = schm.check { nick : "a" }
-  T.assert err?, "missing mandatory key is rejected"
-  T.equal err?.message, "At <top>.n: key is missing but is mandatory"
-
-  err = schm.check {}
-  T.assert err?, "empty dict missing mandatory key is rejected"
-  T.equal err?.message, "At <top>.n: key is missing but is mandatory"
-
-  localized = schm.debug_localize { n : "alice" }
-  T.equal localized.name, "alice", "debug_localize uses schema names"
-  T.assert not localized.n?, "short key is replaced"
-
-  cb null
-
-exports.string_enum_rejects_unknown_weird_names = (T, cb) ->
-  schm = schema.string_enum ["in_person", "proofs", "video"]
-  err = schm.check "video"
-  T.assert not err?, "listed enum value is accepted"
-
-  err = schm.check "nope"
-  T.assert err?, "unknown enum value is rejected"
-
-  # Make sure that Object prototype names are not bugging out with string enum check.
-  for name in _object_proto_names
-    err = schm.check name
-    T.assert err?, "#{name} is not an enum value just because it is a prototype name"
-    T.assert (err?.message.indexOf("unknown enum value") >= 0), "#{name} error message"
-
-  cb null
-
-exports.string_enum_allows_weird_names = (T, cb) ->
-  for name in _weird_key_names
-    # Allow a string enum with weird name.
-    schm = schema.string_enum [name]
-    # And it can also be checked properly
-    err = schm.check name
-    T.assert not err?, "#{name} can be an enum value"
-    err = schm.check "nope"
-    T.assert err?, "other values still rejected next to #{name}"
-
-  # Do not allow banned __proto__ name.
-  threw = null
-  try
-    schema.string_enum ["__proto__"]
-  catch e
-    threw = e
-  T.assert threw?, "__proto__ is not a valid enum value"
-  T.equal threw?.message, "enum value is not allowed: __proto__"
-
-  cb null
-
-exports.dict_rejects_unknown_weird_keys = (T, cb) ->
-  schm = schema.dict { name : schema.string() }
-  err = schm.check { name : "ok" }
-  T.assert not err?, "valid dict is accepted"
-
-  err = schm.check { name : "ok", extra : 1 }
-  T.assert err?, "unknown key is rejected"
-  T.equal err?.message, "At <top>.extra: key is not supported"
-
-  # Allow weird key names to be checked against the schema, they are just not
-  # defined as dict fields and payloads with these fields are correctly
-  # rejected. They are not rejected / banned, and are treated as any other name
-  # (also see next test).
-  for name in _weird_key_names
-    obj = JSON.parse "{\"name\":\"ok\",\"#{name}\":1}"
-    err = null
-    threw = null
-    try
-      err = schm.check obj
-    catch e
-      threw = e
-    T.assert not threw?, "#{name} should not throw"
-    T.assert err?, "#{name} extra key is not a schema field"
-    T.equal err?.message, "At <top>.#{name}: key is not supported"
-
-  obj = JSON.parse '{"name":"ok","__proto__":1}'
-  err = schm.check obj
-  T.assert err?, "__proto__ extra key is rejected"
-  T.equal err?.message, "At <top>.__proto__: key name is not allowed"
-
-  schm = schema.dict({ name : schema.string() }).allow_extra_keys()
-  obj = JSON.parse '{"name":"ok","constructor":1}'
-  err = schm.check obj
-  T.assert not err?, "constructor extra key is allowed when extra keys are allowed"
-
-  obj = JSON.parse '{"name":"ok","__proto__":1}'
-  err = schm.check obj
-  T.assert err?, "__proto__ is rejected even with allow_extra_keys"
-  T.equal err?.message, "At <top>.__proto__: key name is not allowed"
-
-  cb null
-
-exports.dict_weird_schema_keys = (T, cb) ->
-  # Weird keys can be used in the schema as well, and objects with these
-  # keys can be checked against the schemas.
-  for name in _weird_key_names
-    keys = {}
-    keys[name] = schema.string()
-    schm = schema.dict keys
-
-    own = JSON.parse "{\"#{name}\":\"ok\"}"
-    err = schm.check own
-    T.assert not err?, "own #{name} key is accepted"
-
-    err = schm.check {}
-    T.assert err?, "inherited #{name} does not satisfy a required schema key"
-    T.equal err?.message, "At <top>.#{name}: key is missing but is mandatory"
-
-    localized = schm.debug_localize {}
-    T.assert not Object::hasOwnProperty.call(localized, name), "debug_localize ignores inherited #{name}"
-    localized = schm.debug_localize own
-    T.equal localized[name], "ok", "own #{name} key is localized"
-
-    schm = schema.dict { name : schema.string() }
-    schm.set_key name, schema.string()
-    obj = JSON.parse "{\"name\":\"ok\",\"#{name}\":\"ok\"}"
-    err = schm.check obj
-    T.assert not err?, "set_key can install #{name}"
-
-  # With the exception of __proto__ which is rejected in the schema construction stage.
-  keys = {}
-  Object.defineProperty keys, "__proto__", { value : schema.string(), enumerable : true }
-  threw = null
-  try
-    schema.dict keys
-  catch e
-    threw = e
-  T.assert threw?, "__proto__ is not a valid schema key"
-  T.equal threw?.message, "schema key name is not allowed: __proto__"
-
-  schm = schema.dict { name : schema.string() }
-  threw = null
-  try
-    schm.set_key "__proto__", schema.string()
-  catch e
-    threw = e
-  T.assert threw?, "set_key rejects __proto__"
-  T.equal threw?.message, "schema key name is not allowed: __proto__"
-
-  cb null

package/test/files/sibkey.iced

@@ -1,60 +0,0 @@
-{alloc,Sibkey} = require '../../'
-{EncKeyManager,KeyManager} = require('kbpgp').kb
-{make_esc} = require 'iced-error'
-{new_sig_arg} = require './util'
-pgp_utils = require('pgp-utils')
-{json_stringify_sorted} = pgp_utils.util
-
-exports.test_sibkey_happy_path = (T,cb) ->
-  esc = make_esc cb, "test_sibkey_happy_path"
-  await KeyManager.generate {}, esc defer elder
-  await KeyManager.generate {}, esc defer sib
-  arg = new_sig_arg { km : elder }
-  arg.sibkm = sib
-  obj = new Sibkey arg
-  await obj.generate esc defer out
-  typ = out.inner.obj.body.type
-  obj2 = alloc typ, arg
-  varg = { armored : out.armored, skip_ids : true, make_ids : true, inner : out.inner.str }
-  await obj2.verify varg, esc defer()
-  cb null
-
-round_trip_with_corrupted_reverse_sig = ({T, corrupt}, cb) ->
-  esc = make_esc cb, "round_trip_with_corrupted_reverse_sig"
-  await KeyManager.generate {}, esc defer elder
-  await KeyManager.generate {}, esc defer sib
-  arg = new_sig_arg { km : elder }
-  arg.sibkm = sib
-  obj = new Sibkey arg
-
-  obj._v_generate = (opts, cb) ->
-    esc = make_esc cb, "_v_generate"
-    x = { reverse_sig: null }
-    @set_new_key_section x
-    x.kid = @get_new_km().get_ekid().toString('hex')
-    eng = @get_new_km().make_sig_eng()
-    await @generate_json { version : opts.version }, esc defer msg
-    msg2 = JSON.parse msg
-    msg2.foo = "bar" if corrupt
-    msg = json_stringify_sorted(msg2)
-    await eng.box msg, esc defer { armored, type }
-    x.reverse_sig = armored
-    cb null
-
-  await obj.generate esc defer out
-  typ = out.inner.obj.body.type
-  obj2 = alloc typ, arg
-  varg = { armored : out.armored, skip_ids : true, make_ids : true, inner : out.inner.str }
-  await obj2.verify varg, defer err
-  if corrupt
-    T.assert err?, "got an error back"
-    T.assert (err.message.indexOf('Reverse sig json mismatch') >= 0), "found right error message"
-  else
-    T.no_error err, "in the success case, don't expect an error"
-  cb null
-
-exports.test_corruption_mechanism = (T,cb) ->
-  round_trip_with_corrupted_reverse_sig { T, corrupt : false }, cb
-
-exports.test_reverse_sig_failure = (T,cb) ->
-  round_trip_with_corrupted_reverse_sig { T, corrupt : true }, cb

package/test/files/team.iced

@@ -1,118 +0,0 @@
-{alloc,team} = require '../../'
-{EncKeyManager,KeyManager} = require('kbpgp').kb
-{make_esc} = require 'iced-error'
-{new_sig_arg} = require './util'
-pgp_utils = require('pgp-utils')
-{json_stringify_sorted} = pgp_utils.util
-
-test_klass = ({T,arg, klass, keys}, cb) ->
-  esc = make_esc cb, "test_klass"
-  delete arg.kms
-  delete arg.team.per_team_key
-  if keys
-    arg.kms = {}
-    await EncKeyManager.generate {}, esc defer arg.kms.encryption
-    await KeyManager.generate {}, esc defer arg.kms.signing
-    arg.kms.generation = 10
-  obj = new klass arg
-  await obj.generate_v2 esc(defer(out)), {dohash:true}
-  typ = out.inner.obj.body.type
-  obj2 = alloc typ, arg
-  varg = { armored : out.armored, skip_ids : true, make_ids : true, inner : out.inner.str, require_packet_hash : true }
-  await obj2.verify_v2 varg, esc defer()
-  T.waypoint "checked #{typ} #{if keys then 'with' else 'without'} keys"
-  cb null
-
-exports.test_all_classes = (T,cb) ->
-  esc = make_esc cb, "test_all_classes"
-  klasses = [team.Index, team.Root, team.ChangeMembership, team.RotateKey,
-    team.NewSubteam, team.Leave, team.SubteamHead, team.RenameSubteam,
-    team.Invite, team.RenameUpPointer, team.DeleteSubteam, team.DeleteRoot,
-    team.DeleteUpPointer, team.KBFS, team.Settings, team.BotSettings]
-  await KeyManager.generate {}, esc defer km
-  arg = new_sig_arg { km }
-  arg.team = { members : { admin : ["a"] } }
-  for klass in klasses
-    await test_klass { T, arg, klass, keys : true }, esc defer()
-    await test_klass { T, arg, klass, keys : false }, esc defer()
-  cb()
-
-exports.test_key_section_bad_and_good = (T,cb) ->
-  esc = make_esc cb, "test_bad_key_section"
-  await KeyManager.generate {}, esc defer km
-  arg = new_sig_arg { km }
-  arg.team = { members : { admin : ["a"] } }
-  arg.kms = {}
-  await EncKeyManager.generate {}, esc defer arg.kms.encryption
-  await KeyManager.generate {}, esc defer arg.kms.signing
-
-  verify_from_arg = ({arg}, cb) ->
-    obj = new team.RotateKey arg
-    await obj.generate_v2 esc(defer(out)), {dohash:true}
-    typ = out.inner.obj.body.type
-    obj2 = alloc typ, arg
-    varg = { armored : out.armored, skip_ids : true, make_ids : true, inner : out.inner.str, require_packet_hash : true }
-    await obj2.verify_v2 varg, defer err
-    cb err
-  await verify_from_arg { arg }, defer err
-  T.assert err?, "we got an error back"
-  T.equal err.message, "Need per_team_key.generation to be an integer > 0 (got undefined)", "right message"
-
-  arg.kms.generation = 10
-  arg.kms.appkey_derivation_version = "foo"
-  await verify_from_arg { arg }, defer err
-  T.assert err?, "we got an error back"
-  T.equal err.message, "Need per_team_key.appkey_derivation_version to be an integer >= 1 (got foo)", "right message"
-
-  arg.kms.appkey_derivation_version = 0
-  await verify_from_arg { arg }, defer err
-  T.assert err?, "we got an error back"
-  T.equal err.message, "Need per_team_key.appkey_derivation_version to be an integer >= 1 (got 0)", "right message"
-
-  arg.kms.appkey_derivation_version = 2
-  await verify_from_arg { arg }, defer err
-  T.no_error err, "should work"
-
-  cb null
-
-round_trip_with_corrupted_reverse_sig = ({T, corrupt}, cb) ->
-  esc = make_esc cb, "test_bad_key_section"
-  await KeyManager.generate {}, esc defer km
-  arg = new_sig_arg { km }
-  arg.team = { members : { admin : ["a"] } }
-  arg.kms = {}
-  await EncKeyManager.generate {}, esc defer arg.kms.encryption
-  await KeyManager.generate {}, esc defer arg.kms.signing
-  arg.kms.generation = 10
-  obj = new team.RotateKey arg
-
-  obj._v_generate = (opts, cb) ->
-    esc = make_esc cb, "_v_generate"
-    x = { reverse_sig: null }
-    @set_new_key_section x
-    eng = @get_new_km().make_sig_eng()
-    await @generate_json { version : opts.version }, esc defer msg
-    msg2 = JSON.parse msg
-    msg2.foo = "bar" if corrupt
-    msg = json_stringify_sorted(msg2)
-    await eng.box msg, esc defer { armored, type }
-    x.reverse_sig = armored
-    cb null
-
-  await obj.generate_v2 esc(defer(out)), {dohash:true}
-  typ = out.inner.obj.body.type
-  obj2 = alloc typ, arg
-  varg = { armored : out.armored, skip_ids : true, make_ids : true, inner : out.inner.str, require_packet_hash : true }
-  await obj2.verify_v2 varg, defer err
-  if corrupt
-    T.assert err?, "got an error back"
-    T.assert (err.message.indexOf('Reverse sig json mismatch') >= 0), "found right error message"
-  else
-    T.no_error err, "in the success case, don't expect an error"
-  cb null
-
-exports.test_corruption_mechanism = (T,cb) ->
-  round_trip_with_corrupted_reverse_sig { T, corrupt : false }, cb
-
-exports.test_reverse_sig_failure = (T,cb) ->
-  round_trip_with_corrupted_reverse_sig { T, corrupt : true }, cb