From 029f49be22082562a7889cee5f63f6fd35a13ac2 Mon Sep 17 00:00:00 2001 From: Yann Autissier Date: Sat, 1 Oct 2022 03:13:35 +0200 Subject: [PATCH] add base36 and base58 multiformat output * output cidv1 of key in base36 or base58 * fix rsa custom seed to concatenate p + q instead of adding it * renamed output file format pb2 to p2p --- keygen.py | 291 ++++++++++++++++++++++++------------------- requirements.txt | 1 + specs/keygen_spec.sh | 58 ++++++--- 3 files changed, 201 insertions(+), 149 deletions(-) diff --git a/keygen.py b/keygen.py index a7cb1b8..d5a9903 100755 --- a/keygen.py +++ b/keygen.py @@ -24,6 +24,7 @@ # along with this program. If not, see . import argparse +import base36 import base58 import base64 import configparser @@ -62,7 +63,7 @@ class keygen: self.parser.add_argument( "-f", "--format", - choices=['ewif', 'jwk', 'nacl','pb2','pem','pubsec','seed','wif'], + choices=['ewif', 'jwk', 'nacl','p2p','pem','pubsec','seed','wif'], default=None, dest="format", help="output file format, default: pem (pkcs8)", @@ -77,7 +78,7 @@ class keygen: "-i", "--input", dest="input", - help="read ed25519 key from file FILE, autodetect format: {credentials,ewif,jwk,nacl,mnemonic,pb2,pubsec,seed,wif}", + help="read ed25519 key from file FILE, autodetect format: {credentials,ewif,jwk,nacl,mnemonic,p2p,pem,pubsec,seed,wif}", metavar='FILE', ) self.parser.add_argument( @@ -121,7 +122,7 @@ class keygen: self.parser.add_argument( "-t", "--type", - choices=['b58mh','b64mh','base58','base64','duniter','ipfs','jwk'], + choices=['b36mf', 'b58mf', 'b58mh','b64mh','base58','base64','duniter','ipfs','jwk'], default="base58", dest="type", help="output text format, default: base58", @@ -160,6 +161,18 @@ class keygen: if hasattr(self.duniterpy, 'sk') and self.duniterpy.sk: clearmem(self.duniterpy.sk) log.debug("cleared: keygen.duniterpy.sk") + if hasattr(self, 'ed25519_secret_b36mf') and self.ed25519_secret_b36mf: + clearmem(self.ed25519_secret_b36mf) + log.debug("cleared: keygen.ed25519_secret_b36mf") + if hasattr(self, 'ed25519_secret_b58mf') and self.ed25519_secret_b58mf: + clearmem(self.ed25519_secret_b58mf) + log.debug("cleared: keygen.ed25519_secret_b58mf") + if hasattr(self, 'ed25519_secret_b58mh') and self.ed25519_secret_b58mh: + clearmem(self.ed25519_secret_b58mh) + log.debug("cleared: keygen.ed25519_secret_b58mh") + if hasattr(self, 'ed25519_secret_b64mh') and self.ed25519_secret_b64mh: + clearmem(self.ed25519_secret_b64mh) + log.debug("cleared: keygen.ed25519_secret_b64mh") if hasattr(self, 'ed25519_secret_base58') and self.ed25519_secret_base58: clearmem(self.ed25519_secret_base58) log.debug("cleared: keygen.ed25519_secret_base58") @@ -169,12 +182,15 @@ class keygen: if hasattr(self, 'ed25519_secret_bytes') and self.ed25519_secret_bytes: clearmem(self.ed25519_secret_bytes) log.debug("cleared: keygen.ed25519_secret_bytes") + if hasattr(self, 'ed25519_secret_cidv1') and self.ed25519_secret_cidv1: + clearmem(self.ed25519_secret_cidv1) + log.debug("cleared: keygen.ed25519_secret_cidv1") if hasattr(self, 'ed25519_secret_pem_pkcs8') and self.ed25519_secret_pem_pkcs8: clearmem(self.ed25519_secret_pem_pkcs8) log.debug("cleared: keygen.ed25515_secret_pem_pkcs8") - if hasattr(self, 'ed25519_secret_protobuf') and self.ed25519_secret_protobuf: - clearmem(self.ed25519_secret_protobuf) - log.debug("cleared: keygen.ed25515_secret_protobuf") + if hasattr(self, 'ed25519_secret_libp2p') and self.ed25519_secret_libp2p: + clearmem(self.ed25519_secret_libp2p) + log.debug("cleared: keygen.ed25515_secret_libp2p") if hasattr(self, 'ed25519_seed_bytes') and self.ed25519_seed_bytes: clearmem(self.ed25519_seed_bytes) log.debug("cleared: keygen.ed25519_seed_bytes") @@ -208,6 +224,37 @@ class keygen: clearmem(self.username) log.debug("cleared: keygen.username") + def _cli(self, argv): + args = self.parser.parse_args(argv) + vars(self).update(vars(args)) + + # display version + if args.version: + version() + sys.exit() + + # define log format + log_format='%(asctime)s %(levelname)s: %(message)s' + log_datefmt='%Y/%m/%d %H:%M:%S' + if args.debug: + log_level='DEBUG' + elif args.quiet: + log_level='ERROR' + elif args.verbose: + log_level='INFO' + else: + log_level='WARNING' + log.basicConfig(format=log_format, datefmt=log_datefmt, level=log_level) + log.debug("keygen.run(%s)" % argv) + + self._check_args(args) + self._load_config() + self.gpg = gpg.Context(armor=True, offline=True) + self.gpg.set_passphrase_cb(self.gpg_passphrase_cb) + self.ed25519_from(args) + method = getattr(self, f'do_{self.type}', self._invalid_type) + return method() + def _invalid_type(self): log.debug("keygen._invalid_type()") self.parser.error(f"type {self.type} is not valid.") @@ -272,11 +319,11 @@ class keygen: if not hasattr(self, 'duniterpy'): self.duniterpy_from_ed25519_seed_bytes() self.duniterpy.save_private_key(self.output) - elif self.format == 'pb2': - if not hasattr(self, 'ed25519_secret_protobuf'): - self.protobuf_from_ed25519() + elif self.format == 'p2p': + if not hasattr(self, 'ed25519_secret_libp2p'): + self.libp2p_from_ed25519() with open(self.output, "wb") as file: - file.write(self.ed25519_secret_protobuf) + file.write(self.ed25519_secret_libp2p) elif self.format == 'pubsec': if not hasattr(self, 'duniterpy'): self.duniterpy_from_ed25519_seed_bytes() @@ -306,56 +353,57 @@ class keygen: if self.keys or self.secret: print("%s" % ''.join([self.prefix * secret_key_prefix, secret_key])) - def _run(self, argv): - args = self.parser.parse_args(argv) - vars(self).update(vars(args)) - - # display version - if args.version: - version() - sys.exit() - - # define log format - log_format='%(asctime)s %(levelname)s: %(message)s' - log_datefmt='%Y/%m/%d %H:%M:%S' - if args.debug: - log_level='DEBUG' - elif args.quiet: - log_level='ERROR' - elif args.verbose: - log_level='INFO' - else: - log_level='WARNING' - log.basicConfig(format=log_format, datefmt=log_datefmt, level=log_level) - log.debug("keygen.run(%s)" % argv) - - self._check_args(args) - self._load_config() - self.gpg = gpg.Context(armor=True, offline=True) - self.gpg.set_passphrase_cb(self.gpg_passphrase_cb) - self.ed25519_from(args) - method = getattr(self, f'do_{self.type}', self._invalid_type) - return method() - - def b58mh_from_protobuf(self): - log.debug("keygen.b58mh_from_protobuf()") + def b36mf_from_cidv1(self): + log.debug("keygen.b36mf_from_cidv1()") + if not hasattr(self, 'ed25519_public_cidv1') or not hasattr(self, 'ed25519_secret_cidv1'): + self.cidv1_from_libp2p() try: - self.ed25519_public_b58mh = base58.b58encode(self.ed25519_public_protobuf).decode('ascii') - self.ed25519_secret_b58mh = base58.b58encode(self.ed25519_secret_protobuf).decode('ascii') + self.ed25519_public_b36mf = 'k' + base36.dumps(int.from_bytes(self.ed25519_public_cidv1, byteorder='big')) + self.ed25519_secret_b36mf = 'k' + base36.dumps(int.from_bytes(self.ed25519_secret_cidv1, byteorder='big')) except Exception as e: - log.error(f'Unable to get b58mh from protobuf: {e}') + log.error(f'Unable to get b36mf from cidv1: {e}') + self._cleanup() + exit(2) + log.debug("keygen.ed25519_public_b36mf=%s" % self.ed25519_public_b36mf) + log.debug("keygen.ed25519_secret_b36mf=%s" % self.ed25519_secret_b36mf) + + def b58mf_from_cidv1(self): + log.debug("keygen.b58mf_from_cidv1()") + if not hasattr(self, 'ed25519_public_cidv1') or not hasattr(self, 'ed25519_secret_cidv1'): + self.cidv1_from_libp2p() + try: + self.ed25519_public_b58mf = 'z' + base58.b58encode(self.ed25519_public_cidv1).decode('ascii') + self.ed25519_secret_b58mf = 'z' + base58.b58encode(self.ed25519_secret_cidv1).decode('ascii') + except Exception as e: + log.error(f'Unable to get b58mf from cidv1: {e}') + self._cleanup() + exit(2) + log.debug("keygen.ed25519_public_b58mf=%s" % self.ed25519_public_b58mf) + log.debug("keygen.ed25519_secret_b58mf=%s" % self.ed25519_secret_b58mf) + + def b58mh_from_libp2p(self): + log.debug("keygen.b58mh_from_libp2p()") + if not hasattr(self, 'ed25519_public_libp2p') or not hasattr(self, 'ed25519_secret_libp2p'): + self.libp2p_from_ed25519() + try: + self.ed25519_public_b58mh = base58.b58encode(self.ed25519_public_libp2p).decode('ascii') + self.ed25519_secret_b58mh = base58.b58encode(self.ed25519_secret_libp2p).decode('ascii') + except Exception as e: + log.error(f'Unable to get b58mh from libp2p: {e}') self._cleanup() exit(2) log.debug("keygen.ed25519_public_b58mh=%s" % self.ed25519_public_b58mh) log.debug("keygen.ed25519_secret_b58mh=%s" % self.ed25519_secret_b58mh) - def b64mh_from_protobuf(self): - log.debug("keygen.b64mh_from_protobuf()") + def b64mh_from_libp2p(self): + log.debug("keygen.b64mh_from_libp2p()") + if not hasattr(self, 'ed25519_public_libp2p') or not hasattr(self, 'ed25519_secret_libp2p'): + self.libp2p_from_ed25519() try: - self.ed25519_public_b64mh = base64.b64encode(self.ed25519_public_protobuf).decode('ascii') - self.ed25519_secret_b64mh = base64.b64encode(self.ed25519_secret_protobuf).decode('ascii') + self.ed25519_public_b64mh = base64.b64encode(self.ed25519_public_libp2p).decode('ascii') + self.ed25519_secret_b64mh = base64.b64encode(self.ed25519_secret_libp2p).decode('ascii') except Exception as e: - log.error(f'Unable to get b64mh from protobuf: {e}') + log.error(f'Unable to get b64mh from libp2p: {e}') self._cleanup() exit(2) log.debug("keygen.ed25519_public_b64mh=%s" % self.ed25519_public_b64mh) @@ -385,16 +433,46 @@ class keygen: log.debug("keygen.ed25519_public_base64=%s" % self.ed25519_public_base64) log.debug("keygen.ed25519_secret_base64=%s" % self.ed25519_secret_base64) + def cidv1_from_libp2p(self): + log.debug("keygen.cidv1_from_libp2p()") + if not hasattr(self, 'ed25519_public_libp2p') or not hasattr(self, 'ed25519_secret_libp2p'): + self.libp2p_from_ed25519() + try: + # \x01: multicodec cid prefix = CIDv1 + # \x72: multicodec content prefix = libp2p-key + self.ed25519_public_cidv1 = b'\x01\x72' + self.ed25519_public_libp2p + self.ed25519_secret_cidv1 = b'\x01\x72' + self.ed25519_secret_libp2p + except Exception as e: + log.error(f'Unable to get cidv1 from libp2p: {e}') + self._cleanup() + exit(2) + log.debug("keygen.ed25519_public_cidv1=%s" % self.ed25519_public_cidv1) + log.debug("keygen.ed25519_secret_cidv1=%s" % self.ed25519_secret_cidv1) + + def do_b36mf(self): + log.debug("keygen.do_b36mf()") + self.libp2p_from_ed25519() + self.cidv1_from_libp2p() + self.b36mf_from_cidv1() + self._output(self.ed25519_public_b36mf, self.ed25519_secret_b36mf, 'pub: ', 'sec: ') + + def do_b58mf(self): + log.debug("keygen.do_b58mf()") + self.libp2p_from_ed25519() + self.cidv1_from_libp2p() + self.b58mf_from_cidv1() + self._output(self.ed25519_public_b58mf, self.ed25519_secret_b58mf, 'pub: ', 'sec: ') + def do_b58mh(self): log.debug("keygen.do_b58mh()") - self.protobuf_from_ed25519() - self.b58mh_from_protobuf() + self.libp2p_from_ed25519() + self.b58mh_from_libp2p() self._output(self.ed25519_public_b58mh, self.ed25519_secret_b58mh, 'pub: ', 'sec: ') def do_b64mh(self): log.debug("keygen.do_b64mh()") - self.protobuf_from_ed25519() - self.b64mh_from_protobuf() + self.libp2p_from_ed25519() + self.b64mh_from_libp2p() self._output(self.ed25519_public_b64mh, self.ed25519_secret_b64mh, 'pub: ', 'sec: ') def do_base58(self): @@ -416,9 +494,9 @@ class keygen: def do_ipfs(self): log.debug("keygen.do_ipfs()") - self.protobuf_from_ed25519() - self.b58mh_from_protobuf() - self.b64mh_from_protobuf() + self.libp2p_from_ed25519() + self.b58mh_from_libp2p() + self.b64mh_from_libp2p() self._output(self.ed25519_public_b58mh, self.ed25519_secret_b64mh, 'PeerID: ', 'PrivKEY: ') def do_jwk(self): @@ -540,7 +618,7 @@ class keygen: if len(lines) > 0: line = lines[0].strip() regex_dewif = re.compile(b'^\x00\x00\x00\x01\x00\x00\x00\x01') - regex_pb2 = re.compile(b'^\x08\x01\x12@') + regex_p2p = re.compile(b'^\x08\x01\x12@') if re.search(regex_dewif, line): log.info("input file format detected: dewif") if not self.password: @@ -556,10 +634,10 @@ class keygen: self._cleanup() exit(1) self.duniterpy = duniterpy.key.SigningKey.from_dewif_file(self.input, self.password) - if re.search(regex_pb2, line): - log.info("input file format detected: pb2") - self.ed25519_secret_protobuf = line - self.ed25519_seed_bytes_from_protobuf() + if re.search(regex_p2p, line): + log.info("input file format detected: p2p") + self.ed25519_secret_libp2p = line + self.ed25519_seed_bytes_from_libp2p() self.duniterpy_from_ed25519_seed_bytes() else: raise NotImplementedError('unknown input file format.') @@ -714,25 +792,27 @@ class keygen: if self.pgpy_key_type == 'RSA': log.debug("keygen.pgpy._key.keymaterial.p=%s" % self.pgpy._key.keymaterial.p) log.debug("keygen.pgpy._key.keymaterial.q=%s" % self.pgpy._key.keymaterial.q) - # custom seed: use sha256 hash of (p + q) - self.ed25519_seed_bytes = nacl.bindings.crypto_hash_sha256(long_to_bytes(self.pgpy._key.keymaterial.p + self.pgpy._key.keymaterial.q)) + # rsa custom seed: sha256 hash of (p + q), where + is a string concatenation + rsa_int = int(str(self.pgpy._key.keymaterial.p) + str(self.pgpy._key.keymaterial.q)) + rsa_len = (rsa_int.bit_length() + 7) // 8 + self.ed25519_seed_bytes = nacl.bindings.crypto_hash_sha256((rsa_int).to_bytes(rsa_len,byteorder='big')) elif self.pgpy_key_type in ('ECDSA', 'EdDSA', 'ECDH'): log.debug("keygen.pgpy._key.keymaterial.s=%s" % self.pgpy._key.keymaterial.s) - self.ed25519_seed_bytes = long_to_bytes(self.pgpy._key.keymaterial.s) + self.ed25519_seed_bytes = self.pgpy._key.keymaterial.s.to_bytes(32, byteorder='big') else: - raise NotImplementedError(f"getting seed from {self.pgpy_key_type} key is not implemented") + raise NotImplementedError(f"getting seed from pgp key type {self.pgpy_key_type} is not implemented") except Exception as e: log.error(f'Unable to get ed25519 seed bytes from pgpy: {e}') self._cleanup() exit(2) log.debug("keygen.ed25519_seed_bytes=%s" % self.ed25519_seed_bytes) - def ed25519_seed_bytes_from_protobuf(self): - log.debug("keygen.ed25519_seed_bytes_from_protobuf()") + def ed25519_seed_bytes_from_libp2p(self): + log.debug("keygen.ed25519_seed_bytes_from_libp2p()") try: - self.ed25519_seed_bytes = self.ed25519_secret_protobuf.lstrip(b'\x08\x01\x12@')[:32] + self.ed25519_seed_bytes = self.ed25519_secret_libp2p.lstrip(b'\x08\x01\x12@')[:32] except Exception as e: - log.error(f'Unable to get ed25519 seed bytes from protobuf: {e}') + log.error(f'Unable to get ed25519 seed bytes from libp2p: {e}') self._cleanup() exit(2) log.debug("keygen.ed25519_seed_bytes=%s" % self.ed25519_seed_bytes) @@ -826,73 +906,26 @@ class keygen: self.pgpy_key_type = 'undefined' log.debug("keygen.pgpy_key_type=%s" % self.pgpy_key_type) - def protobuf_from_ed25519(self): + def libp2p_from_ed25519(self): # libp2p protobuf version 2 - log.debug("keygen.protobuf_from_ed25519()") + log.debug("keygen.libp2p_from_ed25519()") try: - self.ed25519_public_protobuf = b'\x00$\x08\x01\x12 ' + self.ed25519_public_bytes - self.ed25519_secret_protobuf = b'\x08\x01\x12@' + self.ed25519_secret_bytes + # \x00: multihash prefix = id + # \x24: multihash length = 36 bytes + self.ed25519_public_libp2p = b'\x00$\x08\x01\x12 ' + self.ed25519_public_bytes + self.ed25519_secret_libp2p = b'\x08\x01\x12@' + self.ed25519_secret_bytes + except Exception as e: - log.error(f'Unable to get protobuf from ed25519: {e}') + log.error(f'Unable to get libp2p from ed25519: {e}') self._cleanup() exit(2) - log.debug("keygen.ed25519_public_protobuf=%s" % self.ed25519_public_protobuf) - log.debug("keygen.ed25519_secret_protobuf=%s" % self.ed25519_secret_protobuf) - -## -# long_to_bytes comes from PyCrypto, which is released into Public Domain -# https://github.com/dlitz/pycrypto/blob/master/lib/Crypto/Util/number.py -def bytes_to_long(s): - """bytes_to_long(string) : long - Convert a byte string to a long integer. - This is (essentially) the inverse of long_to_bytes(). - """ - acc = 0 - unpack = struct.unpack - length = len(s) - if length % 4: - extra = (4 - length % 4) - s = b'\000' * extra + s - length = length + extra - for i in range(0, length, 4): - acc = (acc << 32) + unpack('>I', s[i:i+4])[0] - return acc - -def long_to_bytes(n, blocksize=0): - """long_to_bytes(n:long, blocksize:int) : string - Convert a long integer to a byte string. - If optional blocksize is given and greater than zero, pad the front of the - byte string with binary zeros so that the length is a multiple of - blocksize. - """ - # after much testing, this algorithm was deemed to be the fastest - s = b'' - n = int(n) - pack = struct.pack - while n > 0: - s = pack('>I', n & 0xffffffff) + s - n = n >> 32 - # strip off leading zeros - for i in range(len(s)): - if s[i] != b'\000'[0]: - break - else: - # only happens when n == 0 - s = b'\000' - i = 0 - s = s[i:] - # add back some pad bytes. this could be done more efficiently w.r.t. the - # de-padding being done above, but sigh... - if blocksize > 0 and len(s) % blocksize: - s = (blocksize - len(s) % blocksize) * b'\000' + s - return s + log.debug("keygen.ed25519_public_libp2p=%s" % self.ed25519_public_libp2p) + log.debug("keygen.ed25519_secret_libp2p=%s" % self.ed25519_secret_libp2p) def main(argv=None): if argv is None: argv = sys.argv[1:] - - cli = keygen() - return cli._run(argv) + return keygen()._cli(argv) def version(version=__version__): print("%s v%s" % (sys.argv[0],version)) diff --git a/requirements.txt b/requirements.txt index 2e4230d..08979fe 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,3 +1,4 @@ +base36==0.1.1 base58==2.1.1 cryptography==3.4.8 duniterpy==1.1.0 diff --git a/specs/keygen_spec.sh b/specs/keygen_spec.sh index d21c0f3..24d2b68 100644 --- a/specs/keygen_spec.sh +++ b/specs/keygen_spec.sh @@ -6,7 +6,7 @@ DUBP_FILE="${SHELLSPEC_TMPBASE}/mnemonic" EWIF_FILE="${SHELLSPEC_TMPBASE}/username.ewif" JWK_FILE="${SHELLSPEC_TMPBASE}/username.jwk" NACL_FILE="${SHELLSPEC_TMPBASE}/username.nacl" -PB2_FILE="${SHELLSPEC_TMPBASE}/username.pb2" +P2P_FILE="${SHELLSPEC_TMPBASE}/username.p2p" PEM_FILE="${SHELLSPEC_TMPBASE}/username.pem" PUBSEC_FILE="${SHELLSPEC_TMPBASE}/username.pubsec" SEED_FILE="${SHELLSPEC_TMPBASE}/username.seed" @@ -113,6 +113,24 @@ Describe 'keygen' The stderr should equal "" End End + Describe '-pkt b36mf username password:' + It 'prints prefixed base36 multiformat public and secret keys for user "username" and password "password"' + When run keygen -pkt b36mf username password + The output should include 'pub: k51qzi5uqu5dhhsbw068pust1xf763zdmyu2mb8rf6ewu2oz3in3a2g6pgtqy3' + The output should include 'sec: kmxn88f5mep5chc4tc002gyhtl9vgiluellgje285y2hn5a5kjdvqge7oeb0jryupt1q09w48h2nxg0ofcjco0wjwa824v3p9tvw6us9gdkb' + The status should be success + The stderr should equal "" + End + End + Describe '-pkt b58mf username password:' + It 'prints prefixed base58 multiformat public and secret keys for user "username" and password "password"' + When run keygen -pkt b58mf username password + The output should include 'pub: z5AanNVJCxnJNiidpTZyuYzkQcrHRCyhxMV7Z4KYDV1MYy2ETMrEbUn' + The output should include 'sec: z4gg7xjCuszBpvNVcDAmNYVNrZxwXfDDQGoAShWmmQBkWRzZbR8A4ZBpkk4iTj3YSLBxvGZRf1AjCyGDdczhs7tshCsbFK4e' + The status should be success + The stderr should equal "" + End + End Describe '-pkt b58mh username password:' It 'prints prefixed base58 multihash public and secret keys for user "username" and password "password"' When run keygen -pkt b58mh username password @@ -303,34 +321,34 @@ Describe 'keygen' End rm -f "${PEM_FILE}" End - Describe "-f pb2 -o ${PB2_FILE} username password:" - rm -f "${PB2_FILE}" - It 'writes protobuf2 secret key to a pb2 file for user "username" and password "password"' - decode_pb2() { - xxd -p "${PB2_FILE}" + Describe "-f p2p -o ${P2P_FILE} username password:" + rm -f "${P2P_FILE}" + It 'writes libp2p secret key to a p2p file for user "username" and password "password"' + decode_p2p() { + xxd -p "${P2P_FILE}" } not_xxd() { ! which xxd >/dev/null 2>&1 } Skip if 'You should install xxd' not_xxd - When run keygen -f pb2 -o "${PB2_FILE}" username password - The path "${PB2_FILE}" should exist - The result of function decode_pb2 should include '080112400f97a825a346a0a335ef68537400efde9b107f93fabc60c8f43f' - The result of function decode_pb2 should include '1245ef13632f349a136ef70ffa6e75f97c31ae65aa1da3a9235643d144b0' - The result of function decode_pb2 should include '2e3a80995f01a1ab' + When run keygen -f p2p -o "${P2P_FILE}" username password + The path "${P2P_FILE}" should exist + The result of function decode_p2p should include '080112400f97a825a346a0a335ef68537400efde9b107f93fabc60c8f43f' + The result of function decode_p2p should include '1245ef13632f349a136ef70ffa6e75f97c31ae65aa1da3a9235643d144b0' + The result of function decode_p2p should include '2e3a80995f01a1ab' The status should be success The stderr should equal "" End End - Describe "-pki ${PB2_FILE}:" - It 'prints prefixed base58 public and secret keys for ed25519 key read from pb2 file"' - When run keygen -pki "${PB2_FILE}" -v + Describe "-pki ${P2P_FILE}:" + It 'prints prefixed base58 public and secret keys for ed25519 key read from p2p file"' + When run keygen -pki "${P2P_FILE}" -v The output should include 'pub: 4YLU1xQ9jzb7LzC6d91VZrYTEKS9N2j93Nnvcee6wxZG' The output should include 'sec: K5heSX4xGUPtRbxcZh6zbgaKbDv8FeVc9JuSNWtUs7C1oGNKqv7kQJ3DHdouTPzoW4duKKnuLQK8LbHKfN9fkjC' The status should be success - The stderr should include 'input file format detected: pb2' + The stderr should include 'input file format detected: p2p' End - rm -f "${PB2_FILE}" + rm -f "${P2P_FILE}" End Describe "-f pubsec -o ${PUBSEC_FILE} username password:" rm -f "${PUBSEC_FILE}" @@ -454,8 +472,8 @@ Describe 'keygen' gpg --batch --import --quiet specs/usersame.asc It 'prints prefixed base58 public and secret keys for rsa gpg key matching uid "usersame"' When run keygen -pkg usersame - The output should include 'pub: 4NxSjjys6bo8mhM919MkvNkNPFu4zpFyxu1r7yJ39K87' - The output should include 'sec: 2cLFNeXiqcKKv5BF9JVTwtWmFHLvjDkJkrCyQbST9oYbsQLHsVaUAzbwrv5YfzQcPHu6e6XUzdstKy4kLhgDSGiw' + The output should include 'pub: EGdSY9fKom7MnvHALNQU7LUoEEE2sju5ntL9eRXJ5tTM' + The output should include 'sec: 4jPG9MH9LVA7HhcfFs41pXVjxDQLdgu3Mtc64Ph6U3vUMNWfJqTBdFFaviq5r6zJC8PpWUiaUhjVnYAa2E9UrFTZ' The status should be success The stderr should equal "" End @@ -465,8 +483,8 @@ Describe 'keygen' gpg --batch --import --quiet specs/usersame_protected.asc It 'prints prefixed public and secret keys for rsa gpg key matching uid "usersame@protected" and locked with password "password"' When run keygen -pkg usersame@protected password - The output should include 'pub: 5kh2uqNTuYsLN7fwSRP3JWM4Hotcpdkb7frRNZwo9BPp' - The output should include 'sec: LdWjjkP7gRzH4k4gNkQs2er26bE2Dhz7cGPE8fMNixe1Uv2ZHbo1QtyZxmDeTP77y6HVLbHNoXdMTHdo6ip9PHk' + The output should include 'pub: 6KNNPBxkMYnccYvpePBKDewZ3JiQnmWA4e7QSsvZUzLM' + The output should include 'sec: 4q4SM9qoWc2eLtfYWs7K9hb7oSCNjCLc8U6ELNrScteVGVnSBP4YMDM5V8RPsHURqCqP5ndPkqGoB74cmRxfJro7' The status should be success The stderr should equal "" End