def testNodesConnectedUsingConvertedKeys(nodeSet, up):
for node in nodeSet:
secretKey = ed25519SkToCurve25519(node.nodestack.local.signer.keyraw)
publicKey = ed25519PkToCurve25519(node.nodestack.local.signer.verraw)
assert node.nodestack.local.priver.keyraw == secretKey
assert node.nodestack.local.priver.pubraw == publicKey
secretKey = ed25519SkToCurve25519(node.clientstack.local.signer.keyraw)
publicKey = ed25519PkToCurve25519(node.clientstack.local.signer.verraw)
assert node.clientstack.local.priver.keyraw == secretKey
assert node.clientstack.local.priver.pubraw == publicKey
def keysAndNames():
alphaSigner = Signer()
betaSigner = Signer()
alphaPrikey = ed25519SkToCurve25519(alphaSigner.keyraw)
betaPrikey = ed25519SkToCurve25519(betaSigner.keyraw)
alphaPubkey = ed25519PkToCurve25519(alphaSigner.verraw)
betaPubkey = ed25519PkToCurve25519(betaSigner.verraw)
alphaName = 'alpha'
betaName = 'beta'
return alphaSigner.keyhex, alphaPrikey, alphaSigner.verhex, alphaPubkey, \
alphaName, betaSigner.keyhex, betaPrikey, betaSigner.verhex, \
betaPubkey, betaName
def keysAndNames():
alphaSigner = Signer()
betaSigner = Signer()
alphaPrikey = ed25519SkToCurve25519(alphaSigner.keyraw)
betaPrikey = ed25519SkToCurve25519(betaSigner.keyraw)
alphaPubkey = ed25519PkToCurve25519(alphaSigner.verraw)
betaPubkey = ed25519PkToCurve25519(betaSigner.verraw)
alphaName = 'alpha'
betaName = 'beta'
return alphaSigner.keyhex, alphaPrikey, alphaSigner.verhex, alphaPubkey, \
alphaName, betaSigner.keyhex, betaPrikey, betaSigner.verhex, \
betaPubkey, betaName
def testKeyConversionFromEd25519ToCurve25519():
signer = Signer()
sk = signer.keyraw
vk = signer.verraw
# Check when keys are passed as raw bytes
secretKey = ed25519SkToCurve25519(sk)
publicKey = ed25519PkToCurve25519(vk)
assert PrivateKey(secretKey).public_key.__bytes__() == publicKey
assert ed25519PkToCurve25519(vk, toHex=True) == \
hexlify(PrivateKey(secretKey).public_key.__bytes__())
# Check when keys are passed as hex
secretKey = ed25519SkToCurve25519(hexlify(sk))
publicKey = ed25519PkToCurve25519(hexlify(vk))
assert PrivateKey(secretKey).public_key.__bytes__() == publicKey
def testKeyConversionFromEd25519ToCurve25519():
signer = Signer()
sk = signer.keyraw
vk = signer.verraw
# Check when keys are passed as raw bytes
secretKey = ed25519SkToCurve25519(sk)
publicKey = ed25519PkToCurve25519(vk)
assert PrivateKey(secretKey).public_key.__bytes__() == publicKey
assert ed25519PkToCurve25519(vk, toHex=True) == \
hexlify(PrivateKey(secretKey).public_key.__bytes__())
# Check when keys are passed as hex
secretKey = ed25519SkToCurve25519(hexlify(sk))
publicKey = ed25519PkToCurve25519(hexlify(vk))
assert PrivateKey(secretKey).public_key.__bytes__() == publicKey
def initLocalKeep(name, baseDir, sigseed, override=False):
"""
Initialize RAET local keep. Write local role data to file.
:param name: name of the node
:param baseDir: base directory
:param pkseed: seed to generate public and private key pair
:param sigseed: seed to generate signing and verification key pair
:param override: overwrite the local role.json file if already exists
:return: tuple(public key, verification key)
"""
rolePath = os.path.join(baseDir, name, "role", "local", "role.json")
if os.path.isfile(rolePath):
if not override:
raise FileExistsError("Keys exists for local role {}".format(name))
if sigseed and not isinstance(sigseed, bytes):
sigseed = sigseed.encode()
signer = Signer(sigseed)
keep = RoadKeep(stackname=name, baseroledirpath=baseDir)
sigkey, verkey = signer.keyhex, signer.verhex
prikey, pubkey = ed25519SkToCurve25519(sigkey, toHex=True), \
ed25519PkToCurve25519(verkey, toHex=True)
data = OrderedDict([("role", name), ("prihex", prikey),
("sighex", sigkey)])
keep.dumpLocalRoleData(data)
return pubkey.decode(), verkey.decode()
def initRemoteKeep(name, remoteName, baseDir, verkey, override=False):
"""
Initialize RAET remote keep
:param name: name of the node
:param remoteName: name of the remote to store keys for
:param baseDir: base directory
:param pubkey: public key of the remote
:param verkey: private key of the remote
:param override: overwrite the role.remoteName.json file if it already
exists.
"""
rolePath = os.path.join(baseDir, name, "role", "remote", "role.{}.json".
format(remoteName))
if os.path.isfile(rolePath):
if not override:
raise FileExistsError("Keys exists for remote role {}".
format(remoteName))
keep = RoadKeep(stackname=name, baseroledirpath=baseDir)
data = OrderedDict([
('role', remoteName),
('acceptance', 1),
('pubhex', ed25519PkToCurve25519(verkey, toHex=True)),
('verhex', verkey)
])
keep.dumpRemoteRoleData(data, role=remoteName)
def initRemoteKeep(name, remoteName, baseDir, verkey, override=False):
"""
Initialize RAET remote keep
:param name: name of the node
:param remoteName: name of the remote to store keys for
:param baseDir: base directory
:param pubkey: public key of the remote
:param verkey: private key of the remote
:param override: overwrite the role.remoteName.json file if it already
exists.
"""
rolePath = os.path.join(baseDir, name, "role", "remote", "role.{}.json".
format(remoteName))
if os.path.isfile(rolePath):
if not override:
raise FileExistsError("Keys exists for remote role {}".
format(remoteName))
keep = RoadKeep(stackname=name, baseroledirpath=baseDir)
data = OrderedDict([
('role', remoteName),
('acceptance', 1),
('pubhex', ed25519PkToCurve25519(verkey, toHex=True)),
('verhex', verkey)
])
keep.dumpRemoteRoleData(data, role=remoteName)
def initLocalKeep(name, baseDir, sigseed, override=False):
"""
Initialize RAET local keep. Write local role data to file.
:param name: name of the node
:param baseDir: base directory
:param pkseed: seed to generate public and private key pair
:param sigseed: seed to generate signing and verification key pair
:param override: overwrite the local role.json file if already exists
:return: tuple(public key, verification key)
"""
rolePath = os.path.join(baseDir, name, "role", "local", "role.json")
if os.path.isfile(rolePath):
if not override:
raise FileExistsError("Keys exists for local role {}".format(name))
if sigseed and not isinstance(sigseed, bytes):
sigseed = sigseed.encode()
signer = Signer(sigseed)
keep = RoadKeep(stackname=name, baseroledirpath=baseDir)
sigkey, verkey = signer.keyhex, signer.verhex
prikey, pubkey = ed25519SkToCurve25519(sigkey, toHex=True), \
ed25519PkToCurve25519(verkey, toHex=True)
data = OrderedDict([
("role", name),
("prihex", prikey),
("sighex", sigkey)
])
keep.dumpLocalRoleData(data)
return pubkey.decode(), verkey.decode()
def testClientConnectedUsingConvertedKeys(nodeSet, up, client1, replied1):
secretKey = ed25519SkToCurve25519(client1.nodestack.local.signer.keyraw)
publicKey = ed25519PkToCurve25519(client1.nodestack.local.signer.verraw)
assert client1.nodestack.local.priver.keyraw == secretKey
assert client1.nodestack.local.priver.pubraw == publicKey
