def test_crypto_kx_seed_keypair(self):
seed = libnacl.randombytes_buf(32)
seed2 = libnacl.randombytes_buf(32)
pk, sk = libnacl.crypto_kx_seed_keypair(seed)
pk2, sk2 = libnacl.crypto_kx_seed_keypair(seed)
pk3, sk3 = libnacl.crypto_kx_seed_keypair(seed2)
self.assertEqual(pk, pk2)
self.assertNotEqual(pk, pk3)
self.assertEqual(sk, sk2)
self.assertNotEqual(sk, sk3)
def test_crypto_kx_seed_keypair(self):
seed = libnacl.randombytes_buf(32)
seed2 = libnacl.randombytes_buf(32)
pk, sk = libnacl.crypto_kx_seed_keypair(seed)
pk2, sk2 = libnacl.crypto_kx_seed_keypair(seed)
pk3, sk3 = libnacl.crypto_kx_seed_keypair(seed2)
self.assertEqual(pk, pk2)
self.assertNotEqual(pk, pk3)
self.assertEqual(sk, sk2)
self.assertNotEqual(sk, sk3)
def test_randombytes_buf_deterministic(self):
seed = libnacl.randombytes_buf(32)
seed2 = libnacl.randombytes_buf(32)
data = libnacl.randombytes_buf_deterministic(32, seed)
data2 = libnacl.randombytes_buf_deterministic(32, seed)
data3 = libnacl.randombytes_buf_deterministic(32, seed2)
self.assertEqual(32, len(data))
self.assertEqual(32, len(data))
self.assertEqual(32, len(data))
self.assertEqual(data, data2)
self.assertNotEqual(data, data3)
def test_randombytes_buf_deterministic(self):
seed = libnacl.randombytes_buf(32)
seed2 = libnacl.randombytes_buf(32)
data = libnacl.randombytes_buf_deterministic(32, seed)
data2 = libnacl.randombytes_buf_deterministic(32, seed)
data3 = libnacl.randombytes_buf_deterministic(32, seed2)
self.assertEqual(32, len(data))
self.assertEqual(32, len(data))
self.assertEqual(32, len(data))
self.assertEqual(data, data2)
self.assertNotEqual(data, data3)
def generateLocalKey(self):
sharedKey = self.generateSharedKey()
buffer = libnacl.randombytes_buf(16)
authenticator = self.makeAuthenticator(sharedKey, buffer)
return authenticator
def test_verify32(self):
v32 = libnacl.randombytes_buf(32)
v32x = v32[:]
self.assertTrue(libnacl.crypto_verify_32(v32, v32x))
v32x = bytearray(v32x)
v32x[libnacl.randombytes_random() & 31] += 1
self.assertFalse(libnacl.crypto_verify_32(v32, bytes(v32x)))
self.assertEqual(libnacl.crypto_verify_32_BYTES, 32)
def test_verify64(self):
v64 = libnacl.randombytes_buf(64)
v64x = v64[:]
self.assertTrue(libnacl.crypto_verify_64(v64, v64x))
v64x = bytearray(v64x)
v64x[libnacl.randombytes_random() & 63] += 1
self.assertFalse(libnacl.crypto_verify_64(v64, bytes(v64x)))
self.assertEqual(libnacl.crypto_verify_64_BYTES, 64)
def test_verify16(self):
v16 = libnacl.randombytes_buf(16)
v16x = v16[:]
self.assertTrue(libnacl.crypto_verify_16(v16, v16x))
v16x = bytearray(v16x)
v16x[libnacl.randombytes_random() & 15] += 1
self.assertFalse(libnacl.crypto_verify_16(v16, bytes(v16x)))
self.assertEqual(libnacl.crypto_verify_16_BYTES, 16)
def createClientFirst(self, text):
buf = libnacl.randombytes_buf(32)
if buf is None or len(buf) != 32:
raise Exception('Could not generate random bytes')
N = str(base64.b64encode(buf), 'utf-8')
self.scram = 'n,,n=' + text + ',r=' + N
return self.scram
def createNonce(self):
cl = MessageWriter()
cl.writeBlob(self.__Yt)
cl.writeUint32(self.messageCounter)
self.messageCounter += 1
cl.writeUint32(0)
if self.messageCounter > 4294967296:
raise Exception('MessageCounter exceeds valid range')
cl.writeBlob(libnacl.randombytes_buf(8))
return cl.toUint8Array()
def test_verify32(self):
v32 = libnacl.randombytes_buf(32)
v32x = v32[:]
self.assertTrue(libnacl.crypto_verify_32(v32, v32x))
self.assertTrue(libnacl.bytes_eq(v32, v32x))
v32x = bytearray(v32x)
i = libnacl.randombytes_random() & 31
v32x[i] = (v32x[i] + 1) % 256
v32x = bytes(v32x)
self.assertFalse(libnacl.crypto_verify_32(v32, v32x))
self.assertFalse(libnacl.bytes_eq(v32, v32x))
self.assertEqual(libnacl.crypto_verify_32_BYTES, 32)
def test_verify64(self):
v64 = libnacl.randombytes_buf(64)
v64x = v64[:]
self.assertTrue(libnacl.crypto_verify_64(v64, v64x))
self.assertTrue(libnacl.bytes_eq(v64, v64x))
v64x = bytearray(v64x)
i = libnacl.randombytes_random() & 63
v64x[i] = (v64x[i] + 1) % 256
v64x = bytes(v64x)
self.assertFalse(libnacl.crypto_verify_64(v64, v64x))
self.assertFalse(libnacl.bytes_eq(v64, v64x))
self.assertEqual(libnacl.crypto_verify_64_BYTES, 64)
def test_verify16(self):
v16 = libnacl.randombytes_buf(16)
v16x = v16[:]
self.assertTrue(libnacl.crypto_verify_16(v16, v16x))
self.assertTrue(libnacl.bytes_eq(v16, v16x))
v16x = bytearray(v16x)
i = libnacl.randombytes_random() & 15
v16x[i] = (v16x[i] + 1) % 256
v16x = bytes(v16x)
self.assertFalse(libnacl.crypto_verify_16(v16, v16x))
self.assertFalse(libnacl.bytes_eq(v16, v16x))
self.assertEqual(libnacl.crypto_verify_16_BYTES, 16)
def encryptPayload(self, data):
if len(data) > 10485760:
raise Exception('encryptPayload: message is too large: ',
len(data))
cq = 0
if not self.__Yv:
cq = cq | 2
nonce = self.createNonce()
if nonce is None:
raise Exception('MessageCounter exceeds valid range')
cn = len(nonce) + General.FH_CRYPTO_MAC_LENGTH + len(data)
ct = bytearray(libnacl.randombytes_buf(libnacl.crypto_box_NONCEBYTES))
cm = bytearray()
cm += ct
cm += data
cr = libnacl.crypto_box_easy_afternm(bytes(cm), bytes(nonce),
self.cryptoIntermediateData)
if cr is None or len(cr) == 0:
raise Exception('Failed to encrypt message')
if len(cr) != cn:
raise Exception(
'Internal error: Unexpected size of encrypted data array')
self.__Yp.append(ct) # append random nonce bytes to list
co = MessageWriter()
co.writeUint8(FAHMessage.MSG_ID_CRYPTED_CONTAINER_TO_SERVER)
co.writeUint8(cq)
co.writeString(self.__Ys)
co.writeBlob(nonce)
co.writeUint32(cn)
co.writeBlob(cr)
return co.toUint8Array()
def test_equal(self):
a = libnacl.randombytes_buf(122)
b = a[:]
self.assertTrue(libnacl.bytes_eq(a, b))
def test_different(self):
a = libnacl.randombytes_buf(122)
b = bytearray(a)
b[87] += 1
b = bytes(b)
self.assertFalse(libnacl.bytes_eq(a, b))
def RandomBytes(length=32):
return libnacl.randombytes_buf(length)
def RandomBytes(length=32):
return libnacl.randombytes_buf(length)
def test_different_length(self):
a = libnacl.randombytes_buf(122)
b = a[:-1]
self.assertFalse(libnacl.bytes_eq(a, b))
def test_invalid_type(self):
a = libnacl.randombytes_buf(122)
b = bytearray(a)
with self.assertRaises(TypeError):
libnacl.bytes_eq(a, b)
