aya
/
dpgpid
1
0
Fork 1
Code Issues 1 Pull Requests 1 Projects Releases Wiki Activity

update default behaviour to show only public key 

* bump version v0.0.2
This commit is contained in:
Yann Autissier 2022-09-12 14:19:05 +02:00
parent 4aea1275e8
commit 7b539afbdd
2 changed files with 183 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

155
keygen
View File

@ -45,17 +45,26 @@ import sys
import time import time
import warnings import warnings
__version__='0.0.1' __version__='0.0.2'
class keygen: class keygen:
def __init__(self): def __init__(self):
self.parser = argparse.ArgumentParser() # desc: generate ed25519 keys suitable for duniter or ipfs
self.parser = argparse.ArgumentParser(description="""
Generate ed25519 keys. It converts your Duniter username and password or
a GPG key to an IPFS PeerID.""")
self.parser.add_argument( self.parser.add_argument(
"-d", "-d",
"--debug", "--debug",
action="store_true", action="store_true",
help="show debug informations (WARNING: including SECRET KEY value)", help="show debug informations (WARNING: including SECRET KEY value)",
) )
self.parser.add_argument(
"-g",
"--gpg",
action="store_true",
help="use gpg key from user id matched by username option as input",
)
self.parser.add_argument( self.parser.add_argument(
"-i", "-i",
"--input", "--input",
@ -64,10 +73,10 @@ class keygen:
help="read public and secret keys in pubsec format from file INPUT", help="read public and secret keys in pubsec format from file INPUT",
) )
self.parser.add_argument( self.parser.add_argument(
"-g", "-k",
"--gpg", "--keys",
action="store_true", action="store_true",
help="use gpg key from user id matched by username option as input", help="show public and secret keys",
) )
self.parser.add_argument( self.parser.add_argument(
"-o", "-o",
@ -78,9 +87,9 @@ class keygen:
) )
self.parser.add_argument( self.parser.add_argument(
"-p", "-p",
"--public", "--prefix",
action="store_true", action="store_true",
help="show only public key", help="prefix key with key type",
) )
self.parser.add_argument( self.parser.add_argument(
"-q", "-q",
@ -92,7 +101,7 @@ class keygen:
"-s", "-s",
"--secret", "--secret",
action="store_true", action="store_true",
help="show only secret key", help="show secret key",
) )
self.parser.add_argument( self.parser.add_argument(
"-t", "-t",
@ -130,33 +139,44 @@ class keygen:
def _cleanup(self): def _cleanup(self):
log.debug("keygen._cleanup()") log.debug("keygen._cleanup()")
if hasattr(self, 'armored_pgp_secret_key'): if hasattr(self, 'armored_pgp_secret_key') and self.armored_pgp_secret_key:
clearmem(self.armored_pgp_secret_key) clearmem(self.armored_pgp_secret_key)
if hasattr(self, 'base58_secret_key'): log.debug("cleared: keygen.armored_pgp_secret_key")
if hasattr(self, 'base58_secret_key') and self.base58_secret_key:
clearmem(self.base58_secret_key) clearmem(self.base58_secret_key)
log.debug("cleared: keygen.base58_secret_key")
if hasattr(self, 'duniter'): if hasattr(self, 'duniter'):
if hasattr(self.duniter, 'sk'): if hasattr(self.duniter, 'sk') and self.duniterpy.sk:
clearmem(self.duniterpy.sk) clearmem(self.duniterpy.sk)
if hasattr(self, 'ed25519_secret_bytes'): log.debug("cleared: keygen.duniterpy.sk")
if hasattr(self, 'ed25519_secret_bytes') and self.ed25519_secret_bytes:
clearmem(self.ed25519_secret_bytes) clearmem(self.ed25519_secret_bytes)
if hasattr(self, 'ed25519_secret_pem_pkcs8'): log.debug("cleared: keygen.ed25519_secret_bytes")
if hasattr(self, 'ed25519_secret_pem_pkcs8') and self.ed25519_secret_pem_pkcs8:
clearmem(self.ed25519_secret_pem_pkcs8) clearmem(self.ed25519_secret_pem_pkcs8)
if hasattr(self, 'ipfs_privkey'): log.debug("cleared: keygen.ed25515_secret_pem_pkcs8")
if hasattr(self, 'ipfs_privkey') and self.ipfs_privkey:
clearmem(self.ipfs_privkey) clearmem(self.ipfs_privkey)
if hasattr(self, 'password'): log.debug("cleared: keygen.ipfs_privkey")
if self.password: if hasattr(self, 'password') and self.password:
clearmem(self.password) clearmem(self.password)
log.debug("cleared: keygen.password")
if hasattr(self, 'pgpy'): if hasattr(self, 'pgpy'):
if hasattr(self.pgpy._key.keymaterial, 'p') and not isinstance(self.pgpy._key.keymaterial.p, object): if hasattr(self.pgpy._key.keymaterial, 'p') and self.pgpy._key.keymaterial.p and not isinstance(self.pgpy._key.keymaterial.p, pgpy.packet.fields.ECPoint):
clearmem(self.pgpy._key.keymaterial.p) clearmem(self.pgpy._key.keymaterial.p)
if hasattr(self.pgpy._key.keymaterial, 'q'): log.debug("cleared: keygen.pgpy._key.material.p")
if hasattr(self.pgpy._key.keymaterial, 'q') and self.pgpy._key.keymaterial.q:
clearmem(self.pgpy._key.keymaterial.q) clearmem(self.pgpy._key.keymaterial.q)
if hasattr(self.pgpy._key.keymaterial, 's'): log.debug("cleared: keygen.pgpy._key.material.q")
if hasattr(self.pgpy._key.keymaterial, 's') and self.pgpy._key.keymaterial.s:
clearmem(self.pgpy._key.keymaterial.s) clearmem(self.pgpy._key.keymaterial.s)
if hasattr(self, 'pgpy_key_seed'): log.debug("cleared: keygen.pgpy._key.material.s")
clearmem(self.pgpy_key_seed) if hasattr(self, 'pgp_key_seed') and self.pgp_key_seed:
if hasattr(self, 'pgpy_key_value'): clearmem(self.pgp_key_seed)
clearmem(self.pgpy_key_value) log.debug("cleared: keygen.pgp_key_seed")
if hasattr(self, 'pgp_key_value') and self.pgp_key_value:
clearmem(self.pgp_key_value)
log.debug("cleared: keygen.pgp_key_value")
def _invalid_type(self): def _invalid_type(self):
log.debug("keygen._invalid_type()") log.debug("keygen._invalid_type()")
@ -219,14 +239,10 @@ class keygen:
log.debug("keygen.do_duniter()") log.debug("keygen.do_duniter()")
self.base58_from_ed25519() self.base58_from_ed25519()
if self.output is None: if self.output is None:
if not self.public and not self.secret: if self.keys or not self.secret:
print("pub: %s" % self.base58_public_key) print("%s" % ''.join([self.prefix * 'pub: ', self.base58_public_key]))
print("sec: %s" % self.base58_secret_key) if self.keys or self.secret:
else: print("%s" % ''.join([self.prefix * 'sec: ', self.base58_secret_key]))
if self.public:
print(self.base58_public_key)
if self.secret:
print(self.base58_secret_key)
else: else:
with open(self.output, "w") as fh: with open(self.output, "w") as fh:
fh.write(f"""Type: PubSec fh.write(f"""Type: PubSec
@ -245,14 +261,10 @@ sec: {self.base58_secret_key}
log.debug("keygen.do_ipfs()") log.debug("keygen.do_ipfs()")
self.ipfs_from_ed25519() self.ipfs_from_ed25519()
if self.output is None: if self.output is None:
if not self.public and not self.secret: if self.keys or not self.secret:
print("PeerID: %s" % self.ipfs_peerid) print("%s" % ''.join(['PeerID: ' * self.prefix, self.ipfs_peerid]))
print("PrivKEY: %s" % self.ipfs_privkey) if self.keys or self.secret:
else: print("%s" % ''.join(['PrivKEY: ' * self.prefix, self.ipfs_privkey]))
if self.public:
print(self.ipfs_peerid)
if self.secret:
print(self.ipfs_privkey)
else: else:
# with open(self.output, "wb") as fh: # with open(self.output, "wb") as fh:
# fh.write(self.ipfs_libp2p_protobuf_key) # fh.write(self.ipfs_libp2p_protobuf_key)
@ -277,6 +289,7 @@ sec: {self.base58_secret_key}
self.password = p.get_pin() self.password = p.get_pin()
except pynentry.PinEntryCancelled: except pynentry.PinEntryCancelled:
log.warning('Cancelled! Goodbye.') log.warning('Cancelled! Goodbye.')
self._cleanup()
exit(2) exit(2)
self.duniterpy = duniterpy.key.SigningKey.from_credentials( self.duniterpy = duniterpy.key.SigningKey.from_credentials(
self.username, self.username,
@ -315,12 +328,17 @@ sec: {self.base58_secret_key}
log.debug("keygen.gpg_seckeys=%s" % self.gpg_seckeys) log.debug("keygen.gpg_seckeys=%s" % self.gpg_seckeys)
if not self.gpg_seckeys: if not self.gpg_seckeys:
log.error(f"""Unable to find any key matching username "{self.username}".""") log.error(f"""Unable to find any key matching username "{self.username}".""")
self._cleanup()
exit(1) exit(1)
else: else:
self.gpg_seckey = self.gpg_seckeys[0] self.gpg_seckey = self.gpg_seckeys[0]
log.info(f"""Found key id "{self.gpg_seckey.fpr}" matching username "{self.username}".""") log.info(f"""Found key id "{self.gpg_seckey.fpr}" matching username "{self.username}".""")
log.debug("keygen.gpg_seckey.__repr__=%s" % self.gpg_seckey.__repr__) log.debug("keygen.gpg_seckey.expired=%s" % self.gpg_seckey.expired)
log.debug("keygen.gpg_seckey.fpr=%s" % self.gpg_seckey.fpr) log.debug("keygen.gpg_seckey.fpr=%s" % self.gpg_seckey.fpr)
log.debug("keygen.gpg_seckey.revoked=%s" % self.gpg_seckey.revoked)
log.debug("keygen.gpg_seckey.uids=%s" % self.gpg_seckey.uids)
log.debug("keygen.gpg_seckey.owner_trust=%s" % self.gpg_seckey.owner_trust)
log.debug("keygen.gpg_seckey.last_update=%s" % self.gpg_seckey.last_update)
self.armored_pgp_public_key = self.gpg.key_export(self.gpg_seckey.fpr) self.armored_pgp_public_key = self.gpg.key_export(self.gpg_seckey.fpr)
log.debug("keygen.armored_pgp_public_key=%s" % self.armored_pgp_public_key) log.debug("keygen.armored_pgp_public_key=%s" % self.armored_pgp_public_key)
if self.password: if self.password:
@ -328,7 +346,8 @@ sec: {self.base58_secret_key}
self.armored_pgp_secret_key = self.gpg.key_export_secret(self.gpg_seckey.fpr) self.armored_pgp_secret_key = self.gpg.key_export_secret(self.gpg_seckey.fpr)
log.debug("keygen.armored_pgp_secret_key=%s" % self.armored_pgp_secret_key) log.debug("keygen.armored_pgp_secret_key=%s" % self.armored_pgp_secret_key)
if not self.armored_pgp_secret_key: if not self.armored_pgp_secret_key:
log.error(f"""Unable to export secret key id "{self.gpg_seckey.fpr}" of user "{self.username}". Please check your password!""") log.error(f"""Unable to export gpg secret key id "{self.gpg_seckey.fpr}" of user "{self.username}". Please check your password!""")
self._cleanup()
exit(2) exit(2)
with warnings.catch_warnings(): with warnings.catch_warnings():
# remove CryptographyDeprecationWarning about deprecated # remove CryptographyDeprecationWarning about deprecated
@ -344,7 +363,7 @@ sec: {self.base58_secret_key}
if self.pgpy.is_protected: if self.pgpy.is_protected:
if not self.password: if not self.password:
with pynentry.PynEntry() as p: with pynentry.PynEntry() as p:
p.description = f"""The exported key id "{self.pgpy.fingerprint.keyid}" of user "{self.username}" is password protected. p.description = f"""The exported pgp key id "{self.pgpy.fingerprint.keyid}" of user "{self.username}" is password protected.
Please enter the passphrase again to unlock it. Please enter the passphrase again to unlock it.
""" """
p.prompt = 'Passphrase:' p.prompt = 'Passphrase:'
@ -352,6 +371,7 @@ sec: {self.base58_secret_key}
self.password = p.get_pin() self.password = p.get_pin()
except pynentry.PinEntryCancelled: except pynentry.PinEntryCancelled:
log.warning('Cancelled! Goodbye.') log.warning('Cancelled! Goodbye.')
self._cleanup()
exit(2) exit(2)
try: try:
with warnings.catch_warnings(): with warnings.catch_warnings():
@ -361,13 +381,14 @@ sec: {self.base58_secret_key}
with self.pgpy.unlock(self.password): with self.pgpy.unlock(self.password):
assert self.pgpy.is_unlocked assert self.pgpy.is_unlocked
log.debug("keygen.pgpy.is_unlocked=%s" % self.pgpy.is_unlocked) log.debug("keygen.pgpy.is_unlocked=%s" % self.pgpy.is_unlocked)
self.pgpy_key_seed_from_pgpy() self.pgp_key_seed_from_pgpy()
except Exception as e: except Exception as e:
log.error(f"""Unable to unlock secret key id "{self.gpg_seckey.fpr}" of user "{self.username}". Please check your password!""") log.error(f"""Unable to unlock pgp secret key id "{self.pgpy.fingerprint.keyid}" of user "{self.username}". Please check your password!""")
self._cleanup()
exit(2) exit(2)
else: else:
self.pgpy_key_seed_from_pgpy() self.pgp_key_seed_from_pgpy()
self.ed25519_public_bytes, self.ed25519_secret_bytes = nacl.bindings.crypto_sign_seed_keypair(self.pgpy_key_seed) self.ed25519_public_bytes, self.ed25519_secret_bytes = nacl.bindings.crypto_sign_seed_keypair(self.pgp_key_seed)
log.debug("keygen.ed25519_public_bytes=%s" % self.ed25519_public_bytes) log.debug("keygen.ed25519_public_bytes=%s" % self.ed25519_public_bytes)
log.debug("keygen.ed25519_secret_bytes=%s" % self.ed25519_secret_bytes) log.debug("keygen.ed25519_secret_bytes=%s" % self.ed25519_secret_bytes)
@ -402,41 +423,29 @@ sec: {self.base58_secret_key}
self.ed25519_secret_pem_pkcs8 = ed25519.Ed25519PrivateKey.from_private_bytes(self.ed25519_secret_bytes[:32]).private_bytes(encoding=serialization.Encoding.PEM, format=serialization.PrivateFormat.PKCS8, encryption_algorithm=serialization.NoEncryption()).decode('ascii') self.ed25519_secret_pem_pkcs8 = ed25519.Ed25519PrivateKey.from_private_bytes(self.ed25519_secret_bytes[:32]).private_bytes(encoding=serialization.Encoding.PEM, format=serialization.PrivateFormat.PKCS8, encryption_algorithm=serialization.NoEncryption()).decode('ascii')
log.debug("keygen.ed25519_secret_pem_pkcs8=%s" % self.ed25519_secret_pem_pkcs8) log.debug("keygen.ed25519_secret_pem_pkcs8=%s" % self.ed25519_secret_pem_pkcs8)
def pgpy_key_flags(self): def pgp_key_seed_from_pgpy(self):
log.debug("keygen.pgpy_key_flags()") log.debug("keygen.pgp_key_seed_from_pgpy()")
flags = []
strs = {pgpy.constants.KeyFlags.Certify : 'C',
pgpy.constants.KeyFlags.Sign : 'S',
pgpy.constants.KeyFlags.EncryptCommunications : 'E',
pgpy.constants.KeyFlags.Authentication : 'A'}
for sig in self.pgpy.self_signatures:
if not sig.is_expired:
flags += sig.key_flags
self.pgpy_key_flags = "".join(strs.get(flag, '') for flag in flags)
def pgpy_key_seed_from_pgpy(self):
log.debug("keygen.pgpy_key_seed_from_pgpy()")
self.pgpy_key_type() self.pgpy_key_type()
if self.pgpy_key_type == 'RSA': 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.p=%s" % self.pgpy._key.keymaterial.p)
log.debug("keygen.pgpy._key.keymaterial.q=%s" % self.pgpy._key.keymaterial.q) log.debug("keygen.pgpy._key.keymaterial.q=%s" % self.pgpy._key.keymaterial.q)
# custom seed: use sha256 hash of (p + q) # custom seed: use sha256 hash of (p + q)
self.pgpy_key_seed = nacl.bindings.crypto_hash_sha256(long_to_bytes(self.pgpy._key.keymaterial.p + self.pgpy._key.keymaterial.q)) self.pgp_key_seed = nacl.bindings.crypto_hash_sha256(long_to_bytes(self.pgpy._key.keymaterial.p + self.pgpy._key.keymaterial.q))
p = long_to_bytes(self.pgpy._key.keymaterial.p) p = long_to_bytes(self.pgpy._key.keymaterial.p)
q = long_to_bytes(self.pgpy._key.keymaterial.q) q = long_to_bytes(self.pgpy._key.keymaterial.q)
self.pgpy_key_value = "".join([f"{c:02x}" for c in p]) + "".join([f"{c:02x}" for c in q]) self.pgp_key_value = "".join([f"{c:02x}" for c in p]) + "".join([f"{c:02x}" for c in q])
self.pgpy_key_size = (len(p) + len(q)) * 8 self.pgp_key_size = (len(p) + len(q)) * 8
log.debug("keygen.pgpy_key_seed=%s" % self.pgpy_key_seed) log.debug("keygen.pgp_key_seed=%s" % self.pgp_key_seed)
log.debug("keygen.pgpy_key_value=%s" % self.pgpy_key_value) log.debug("keygen.pgp_key_value=%s" % self.pgp_key_value)
log.debug("keygen.pgpy_key_size=%s" % self.pgpy_key_size) log.debug("keygen.pgp_key_size=%s" % self.pgp_key_size)
elif self.pgpy_key_type in ('ECDSA', 'EdDSA', 'ECDH'): elif self.pgpy_key_type in ('ECDSA', 'EdDSA', 'ECDH'):
log.debug("keygen.pgpy._key.keymaterial.s=%s" % self.pgpy._key.keymaterial.s) log.debug("keygen.pgpy._key.keymaterial.s=%s" % self.pgpy._key.keymaterial.s)
self.pgpy_key_seed = long_to_bytes(self.pgpy._key.keymaterial.s) self.pgp_key_seed = long_to_bytes(self.pgpy._key.keymaterial.s)
self.pgpy_key_value = "".join([f"{c:02x}" for c in self.pgpy_key_seed]) self.pgp_key_value = "".join([f"{c:02x}" for c in self.pgp_key_seed])
self.pgpy_key_size = len(self.pgpy_key_seed)*8 self.pgp_key_size = len(self.pgp_key_seed)*8
log.debug("keygen.pgpy_key_seed=%s" % self.pgpy_key_seed) log.debug("keygen.pgp_key_seed=%s" % self.pgp_key_seed)
log.debug("keygen.pgpy_key_value=%s" % self.pgpy_key_value) log.debug("keygen.pgp_key_value=%s" % self.pgp_key_value)
log.debug("keygen.pgpy_key_size=%s" % self.pgpy_key_size) log.debug("keygen.pgp_key_size=%s" % self.pgp_key_size)
else: else:
raise NotImplementedError(f"Getting seed from {self.pgpy_key_type} key is not implemented") raise NotImplementedError(f"Getting seed from {self.pgpy_key_type} key is not implemented")

127
specs/keygen_spec.sh
View File

@ -50,14 +50,64 @@ Describe 'keygen'
Describe '--version:' Describe '--version:'
It 'prints version' It 'prints version'
When run keygen --version When run keygen --version
The output should include 'v0.0.1' The output should include 'v0.0.2'
The status should be success The status should be success
The stderr should equal "" The stderr should equal ""
End End
End End
Describe '-t duniter username password:' Describe 'username password:'
It 'prints duniter keys for user username' It 'prints base58 public key for user "username" with password "password"'
When run keygen -t duniter username password When run keygen username password
The output should include '4YLU1xQ9jzb7LzC6d91VZrYTEKS9N2j93Nnvcee6wxZG'
The status should be success
The stderr should equal ""
End
End
Describe '-p username password:'
It 'prints prefixed base58 public key for user "username" with password "password"'
When run keygen -p username password
The output should include 'pub: 4YLU1xQ9jzb7LzC6d91VZrYTEKS9N2j93Nnvcee6wxZG'
The status should be success
The stderr should equal ""
End
End
Describe '-s username password:'
It 'prints base58 secret key for user "username" with password "password"'
When run keygen -s username password
The output should include 'K5heSX4xGUPtRbxcZh6zbgaKbDv8FeVc9JuSNWtUs7C1oGNKqv7kQJ3DHdouTPzoW4duKKnuLQK8LbHKfN9fkjC'
The status should be success
The stderr should equal ""
End
End
Describe '-ps username password:'
It 'prints prefixed base58 secret key for user "username" with password "password"'
When run keygen -ps username password
The output should include 'sec: K5heSX4xGUPtRbxcZh6zbgaKbDv8FeVc9JuSNWtUs7C1oGNKqv7kQJ3DHdouTPzoW4duKKnuLQK8LbHKfN9fkjC'
The status should be success
The stderr should equal ""
End
End
Describe '-k username password:'
It 'prints base58 public and secret keys for user "username" with password "password"'
When run keygen -k username password
The output should include '4YLU1xQ9jzb7LzC6d91VZrYTEKS9N2j93Nnvcee6wxZG'
The output should include 'K5heSX4xGUPtRbxcZh6zbgaKbDv8FeVc9JuSNWtUs7C1oGNKqv7kQJ3DHdouTPzoW4duKKnuLQK8LbHKfN9fkjC'
The status should be success
The stderr should equal ""
End
End
Describe '-pk username password:'
It 'prints prefixed base58 public and secret keys for user "username" with password "password"'
When run keygen -pk username password
The output should include 'pub: 4YLU1xQ9jzb7LzC6d91VZrYTEKS9N2j93Nnvcee6wxZG'
The output should include 'sec: K5heSX4xGUPtRbxcZh6zbgaKbDv8FeVc9JuSNWtUs7C1oGNKqv7kQJ3DHdouTPzoW4duKKnuLQK8LbHKfN9fkjC'
The status should be success
The stderr should equal ""
End
End
Describe '-t duniter -pk username password:'
It 'prints prefixed duniter public key for user "username" with password "password"'
When run keygen -t duniter -pk username password
The output should include 'pub: 4YLU1xQ9jzb7LzC6d91VZrYTEKS9N2j93Nnvcee6wxZG' The output should include 'pub: 4YLU1xQ9jzb7LzC6d91VZrYTEKS9N2j93Nnvcee6wxZG'
The output should include 'sec: K5heSX4xGUPtRbxcZh6zbgaKbDv8FeVc9JuSNWtUs7C1oGNKqv7kQJ3DHdouTPzoW4duKKnuLQK8LbHKfN9fkjC' The output should include 'sec: K5heSX4xGUPtRbxcZh6zbgaKbDv8FeVc9JuSNWtUs7C1oGNKqv7kQJ3DHdouTPzoW4duKKnuLQK8LbHKfN9fkjC'
The status should be success The status should be success
@ -66,7 +116,7 @@ Describe 'keygen'
End End
Describe "-o ${DUNITER_PUBSEC_FILE} -t duniter username password:" Describe "-o ${DUNITER_PUBSEC_FILE} -t duniter username password:"
rm -f "${DUNITER_PUBSEC_FILE}" rm -f "${DUNITER_PUBSEC_FILE}"
It 'writes duniter keys to file for user username' It 'writes duniter keys to file for user "username" with password "password"'
When run keygen -o "${DUNITER_PUBSEC_FILE}" -t duniter username password When run keygen -o "${DUNITER_PUBSEC_FILE}" -t duniter username password
The path "${DUNITER_PUBSEC_FILE}" should exist The path "${DUNITER_PUBSEC_FILE}" should exist
The contents of file "${DUNITER_PUBSEC_FILE}" should include 'pub: 4YLU1xQ9jzb7LzC6d91VZrYTEKS9N2j93Nnvcee6wxZG' The contents of file "${DUNITER_PUBSEC_FILE}" should include 'pub: 4YLU1xQ9jzb7LzC6d91VZrYTEKS9N2j93Nnvcee6wxZG'
@ -75,9 +125,9 @@ Describe 'keygen'
The stderr should equal "" The stderr should equal ""
End End
End End
Describe "-i ${DUNITER_PUBSEC_FILE} -t ipfs:" Describe "-i ${DUNITER_PUBSEC_FILE} -t ipfs -pk:"
It 'prints ipfs keys for duniter keys read in pubsec file' It 'prints prefixed ipfs keys for duniter keys read in pubsec file'
When run keygen -i "${DUNITER_PUBSEC_FILE}" -t ipfs When run keygen -i "${DUNITER_PUBSEC_FILE}" -t ipfs -pk
The output should include 'PeerID: 12D3KooWDMhdm5yrvtrbkshXFjkqLedHieUnPioczy9wzdnzquHC' The output should include 'PeerID: 12D3KooWDMhdm5yrvtrbkshXFjkqLedHieUnPioczy9wzdnzquHC'
The output should include 'PrivKEY: CAESQA+XqCWjRqCjNe9oU3QA796bEH+T+rxgyPQ/EkXvE2MvNJoTbvcP+m51+XwxrmWqHaOpI1ZD0USwLjqAmV8Boas=' The output should include 'PrivKEY: CAESQA+XqCWjRqCjNe9oU3QA796bEH+T+rxgyPQ/EkXvE2MvNJoTbvcP+m51+XwxrmWqHaOpI1ZD0USwLjqAmV8Boas='
The status should be success The status should be success
@ -97,8 +147,33 @@ Describe 'keygen'
rm -f "${DUNITER_PUBSEC_FILE}" "${IPFS_PEM_FILE}" rm -f "${DUNITER_PUBSEC_FILE}" "${IPFS_PEM_FILE}"
End End
Describe '-t ipfs username password:' Describe '-t ipfs username password:'
It 'prints ipfs keys for user username' It 'prints ipfs public key for user "username" with password "password"'
When run keygen -t ipfs username password When run keygen -t ipfs username password
The output should include '12D3KooWDMhdm5yrvtrbkshXFjkqLedHieUnPioczy9wzdnzquHC'
The status should be success
The stderr should equal ""
End
End
Describe '-t ipfs -s username password:'
It 'prints ipfs secret key for user "username" with password "password"'
When run keygen -t ipfs -s username password
The output should include 'CAESQA+XqCWjRqCjNe9oU3QA796bEH+T+rxgyPQ/EkXvE2MvNJoTbvcP+m51+XwxrmWqHaOpI1ZD0USwLjqAmV8Boas='
The status should be success
The stderr should equal ""
End
End
Describe '-t ipfs -k username password:'
It 'prints ipfs keys for user "username" with password "password"'
When run keygen -t ipfs -k username password
The output should include '12D3KooWDMhdm5yrvtrbkshXFjkqLedHieUnPioczy9wzdnzquHC'
The output should include 'CAESQA+XqCWjRqCjNe9oU3QA796bEH+T+rxgyPQ/EkXvE2MvNJoTbvcP+m51+XwxrmWqHaOpI1ZD0USwLjqAmV8Boas='
The status should be success
The stderr should equal ""
End
End
Describe '-t ipfs -pk username password:'
It 'prints prefixed ipfs keys for user "username" with password "password"'
When run keygen -t ipfs -pk username password
The output should include 'PeerID: 12D3KooWDMhdm5yrvtrbkshXFjkqLedHieUnPioczy9wzdnzquHC' The output should include 'PeerID: 12D3KooWDMhdm5yrvtrbkshXFjkqLedHieUnPioczy9wzdnzquHC'
The output should include 'PrivKEY: CAESQA+XqCWjRqCjNe9oU3QA796bEH+T+rxgyPQ/EkXvE2MvNJoTbvcP+m51+XwxrmWqHaOpI1ZD0USwLjqAmV8Boas=' The output should include 'PrivKEY: CAESQA+XqCWjRqCjNe9oU3QA796bEH+T+rxgyPQ/EkXvE2MvNJoTbvcP+m51+XwxrmWqHaOpI1ZD0USwLjqAmV8Boas='
The status should be success The status should be success
@ -106,7 +181,7 @@ Describe 'keygen'
End End
End End
Describe "-o ${IPFS_PEM_FILE} -t ipfs username password:" Describe "-o ${IPFS_PEM_FILE} -t ipfs username password:"
It 'writes ipfs keys to file for user username' It 'writes ipfs keys to file for user "username" with password "password"'
When run keygen username password -o "${IPFS_PEM_FILE}" -t ipfs When run keygen username password -o "${IPFS_PEM_FILE}" -t ipfs
The path "${IPFS_PEM_FILE}" should exist The path "${IPFS_PEM_FILE}" should exist
The contents of file "${IPFS_PEM_FILE}" should include '-----BEGIN PRIVATE KEY-----' The contents of file "${IPFS_PEM_FILE}" should include '-----BEGIN PRIVATE KEY-----'
@ -126,36 +201,36 @@ Describe 'keygen'
The status should be success The status should be success
End End
End End
Describe '-g -t duniter username:' Describe '-g -t duniter -pk username:'
It 'prints duniter keys for gpg key matching username' It 'prints prefixed duniter keys for gpg key matching "username"'
When run keygen -g -t duniter username When run keygen -g -t duniter -pk username
The output should include 'pub: 2g5UL2zhkn5i7oNYDpWo3fBuWvRYVU1AbMtdVmnGzPNv' The output should include 'pub: 2g5UL2zhkn5i7oNYDpWo3fBuWvRYVU1AbMtdVmnGzPNv'
The output should include 'sec: 5WtYFfA26nTfG496gAKhkrLYUMMnwXexmE1E8Q7PvtQEyscHfirsdMzW34zDp7WEkt3exNEVwoG4ajZYrm62wpi2' The output should include 'sec: 5WtYFfA26nTfG496gAKhkrLYUMMnwXexmE1E8Q7PvtQEyscHfirsdMzW34zDp7WEkt3exNEVwoG4ajZYrm62wpi2'
The status should be success The status should be success
The stderr should equal "" The stderr should equal ""
End End
End End
Describe '-g -t duniter username@protected password:' Describe '-g -t duniter -pk username@protected password:'
It 'prints duniter keys for gpg key matching username@protected locked with password' It 'prints prefixed duniter keys for gpg key matching "username@protected" locked with "password"'
When run keygen -g -t duniter username@protected password When run keygen -g -t duniter -pk username@protected password
The output should include 'pub: C1cRu7yb5rZhsmRHQkeZxusAhtYYJypcnXpY3HycEKsU' The output should include 'pub: C1cRu7yb5rZhsmRHQkeZxusAhtYYJypcnXpY3HycEKsU'
The output should include 'sec: VWaEdDroSCoagJDsBnDNUtXJtKAJYdqL6XKNiomz8DtiyF44FvpiMmhidXt2j8HhDBKPZ67xBGcZPnj4Myk6cB8' The output should include 'sec: VWaEdDroSCoagJDsBnDNUtXJtKAJYdqL6XKNiomz8DtiyF44FvpiMmhidXt2j8HhDBKPZ67xBGcZPnj4Myk6cB8'
The status should be success The status should be success
The stderr should equal "" The stderr should equal ""
End End
End End
Describe '-g -t ipfs username:' Describe '-g -t ipfs -pk username:'
It 'prints ipfs keys for gpg key matching username' It 'prints prefixed ipfs keys for gpg key matching "username"'
When run keygen -g -t ipfs username When run keygen -g -t ipfs -pk username
The output should include 'PeerID: 12D3KooWBVSe5AaQwgMCXgsxrRG8pTGk1FUBXA5eYxFeskwAtL6r' The output should include 'PeerID: 12D3KooWBVSe5AaQwgMCXgsxrRG8pTGk1FUBXA5eYxFeskwAtL6r'
The output should include 'PrivKEY: CAESQOHXwPgzoiDca1ZnvhU/W3zdogZXulkoErnUsqt+ut82GN5k4MIbVvz2m6Vq0ij9fQFPNUz+ZZdv2D31K6mzBQc=' The output should include 'PrivKEY: CAESQOHXwPgzoiDca1ZnvhU/W3zdogZXulkoErnUsqt+ut82GN5k4MIbVvz2m6Vq0ij9fQFPNUz+ZZdv2D31K6mzBQc='
The status should be success The status should be success
The stderr should equal "" The stderr should equal ""
End End
End End
Describe '-g -t ipfs username@protected password:' Describe '-g -t ipfs -pk username@protected password:'
It 'prints ipfs keys for gpg key matching username@protected locked with password' It 'prints prefixed ipfs keys for gpg key matching "username@protected" locked with "password"'
When run keygen -g -t ipfs username@protected password When run keygen -g -t ipfs -pk username@protected password
The output should include 'PeerID: 12D3KooWLpybeFZJGkqCHevi3MPujhx1CDbBLfu6k8BZRH8W8GbQ' The output should include 'PeerID: 12D3KooWLpybeFZJGkqCHevi3MPujhx1CDbBLfu6k8BZRH8W8GbQ'
The output should include 'PrivKEY: CAESQBiV+XnBNnryoeBs6SNj9e7Cd9Xj6INn24wyxxacylYqo5idwBHJto4Vbbp6NQzuUF+e7aCmrCf6y+BSyL42/i8=' The output should include 'PrivKEY: CAESQBiV+XnBNnryoeBs6SNj9e7Cd9Xj6INn24wyxxacylYqo5idwBHJto4Vbbp6NQzuUF+e7aCmrCf6y+BSyL42/i8='
The status should be success The status should be success
@ -163,7 +238,7 @@ Describe 'keygen'
End End
End End
Describe "-g -o ${DUNITER_PUBSEC_FILE} -t duniter username:" Describe "-g -o ${DUNITER_PUBSEC_FILE} -t duniter username:"
It 'writes duniter keys to file for gpg key matching username' It 'writes duniter keys to file for gpg key matching "username"'
When run keygen -g -o "${DUNITER_PUBSEC_FILE}" -t duniter username When run keygen -g -o "${DUNITER_PUBSEC_FILE}" -t duniter username
The path "${DUNITER_PUBSEC_FILE}" should exist The path "${DUNITER_PUBSEC_FILE}" should exist
The contents of file "${DUNITER_PUBSEC_FILE}" should include 'pub: 2g5UL2zhkn5i7oNYDpWo3fBuWvRYVU1AbMtdVmnGzPNv' The contents of file "${DUNITER_PUBSEC_FILE}" should include 'pub: 2g5UL2zhkn5i7oNYDpWo3fBuWvRYVU1AbMtdVmnGzPNv'
@ -174,7 +249,7 @@ Describe 'keygen'
rm -f "${DUNITER_PUBSEC_FILE}" rm -f "${DUNITER_PUBSEC_FILE}"
End End
Describe "-g -o ${DUNITER_PUBSEC_FILE} -t duniter username@protected password:" Describe "-g -o ${DUNITER_PUBSEC_FILE} -t duniter username@protected password:"
It 'writes duniter keys to file for gpg key matching username@protected locked with password' It 'writes duniter keys to file for gpg key matching "username@protected" locked with "password"'
When run keygen -g -o "${DUNITER_PUBSEC_FILE}" -t duniter username@protected password When run keygen -g -o "${DUNITER_PUBSEC_FILE}" -t duniter username@protected password
The path "${DUNITER_PUBSEC_FILE}" should exist The path "${DUNITER_PUBSEC_FILE}" should exist
The contents of file "${DUNITER_PUBSEC_FILE}" should include 'pub: C1cRu7yb5rZhsmRHQkeZxusAhtYYJypcnXpY3HycEKsU' The contents of file "${DUNITER_PUBSEC_FILE}" should include 'pub: C1cRu7yb5rZhsmRHQkeZxusAhtYYJypcnXpY3HycEKsU'
@ -185,7 +260,7 @@ Describe 'keygen'
rm -f "${DUNITER_PUBSEC_FILE}" rm -f "${DUNITER_PUBSEC_FILE}"
End End
Describe "-g -o ${IPFS_PEM_FILE} -t ipfs username:" Describe "-g -o ${IPFS_PEM_FILE} -t ipfs username:"
It 'writes ipfs keys to file for gpg key matching username' It 'writes ipfs keys to file for gpg key matching "username"'
When run keygen -g -o "${IPFS_PEM_FILE}" -t ipfs username When run keygen -g -o "${IPFS_PEM_FILE}" -t ipfs username
The path "${IPFS_PEM_FILE}" should exist The path "${IPFS_PEM_FILE}" should exist
The contents of file "${IPFS_PEM_FILE}" should include '-----BEGIN PRIVATE KEY-----' The contents of file "${IPFS_PEM_FILE}" should include '-----BEGIN PRIVATE KEY-----'
@ -197,7 +272,7 @@ Describe 'keygen'
rm -f "${IPFS_PEM_FILE}" rm -f "${IPFS_PEM_FILE}"
End End
Describe "-g -o ${IPFS_PEM_FILE} -t ipfs username@protected password:" Describe "-g -o ${IPFS_PEM_FILE} -t ipfs username@protected password:"
It 'writes ipfs keys to file for gpg key matching username@protected locked with password' It 'writes ipfs keys to file for gpg key matching "username@protected" locked with "password"'
When run keygen -g -o "${IPFS_PEM_FILE}" -t ipfs username@protected password When run keygen -g -o "${IPFS_PEM_FILE}" -t ipfs username@protected password
The path "${IPFS_PEM_FILE}" should exist The path "${IPFS_PEM_FILE}" should exist
The contents of file "${IPFS_PEM_FILE}" should include '-----BEGIN PRIVATE KEY-----' The contents of file "${IPFS_PEM_FILE}" should include '-----BEGIN PRIVATE KEY-----'