testing_speed_of_pynacl.py

''' test speed of pynacl.

to get deps:

   pip install pynacl notebook matplotlib
'''


import nacl.utils
import time
import random
from nacl.public import PrivateKey, Box
from nacl.public import SealedBox
from nacl.secret import SecretBox

import matplotlib.pylab as plt

class MySecretBox:
    """SecretBox implemented using SealedBox, which is 30% faster."""
    def __init__(self, key=None):
        """Initialize using nacl.public.PrivateKey."""
        if key is None:
            self._key = PrivateKey.generate()
        else:
            self._key = key

    def encrypt(self, data):
        return SealedBox(self._key.public_key).encrypt(data)
    
    def decrypt(self, data):
        return SealedBox(self._key).decrypt(data)            
    
skbob = PrivateKey.generate()
pkbob = skbob.public_key
skalice = PrivateKey.generate()
pkalice = skalice.public_key

bob_box = Box(skbob, pkalice)
alice_box = Box(skalice, pkbob)
secretbox_key = nacl.utils.random(nacl.secret.SecretBox.KEY_SIZE)

sealed_box = SealedBox(pkbob)
unseal_box = SealedBox(skbob)
secret_box = SecretBox(secretbox_key)
mysecret_box = MySecretBox(skbob)

# encryption
time_box_enc = {}
speed_box_enc = {}

time_sealed_box_enc = {}
speed_sealed_box_enc = {}

time_secret_box_enc = {}
speed_secret_box_enc = {}

time_mysecret_box_enc = {}
speed_mysecret_box_enc = {}

# decryption
time_box_dec = {}
speed_box_dec = {}

time_sealed_box_dec = {}
speed_sealed_box_dec = {}

time_secret_box_dec = {}
speed_secret_box_dec = {}

time_mysecret_box_dec = {}
speed_mysecret_box_dec = {}

for i in range(100):
    delka = random.randint(10, 40*1024*1024) # 10*1024*1024)
    message = b'b' * delka
    delka = delka/1024
    # public enc
    ts = time.time()
    encrypted = bob_box.encrypt(message)
    te = time.time()    
    time_box_enc[delka] = te - ts
    speed_box_enc[delka] = delka/(te-ts)

    # public dec
    ts = time.time()
    plain = alice_box.decrypt(encrypted)
    te = time.time()    
    time_box_dec[delka] = te - ts
    speed_box_dec[delka] = delka/(te-ts)
    
 
    # sealed enc
    ts = time.time()
    encrypted = sealed_box.encrypt(message)
    te = time.time()    
    time_sealed_box_enc[delka] = te - ts
    speed_sealed_box_enc[delka] = delka/(te-ts)

    # sealed dec
    ts = time.time()
    plain = unseal_box.decrypt(encrypted)
    te = time.time()    
    time_sealed_box_dec[delka] = te - ts
    speed_sealed_box_dec[delka] = delka/(te-ts)
    
    # secret box (symmetric) enc
    ts = time.time()
    encrypted = secret_box.encrypt(message)
    te = time.time()    
    time_secret_box_enc[delka] = te - ts
    speed_secret_box_enc[delka] = delka/(te-ts)

    # secret box (symmetric) dec
    ts = time.time()
    plain = secret_box.decrypt(encrypted)
    te = time.time()    
    time_secret_box_dec[delka] = te - ts
    speed_secret_box_dec[delka] = delka/(te-ts)
    
    # secret box (symmetric) enc
    ts = time.time()
    encrypted = mysecret_box.encrypt(message)
    te = time.time()    
    time_mysecret_box_enc[delka] = te - ts
    speed_mysecret_box_enc[delka] = delka/(te-ts)

    # secret box (symmetric) dec
    ts = time.time()
    plain = mysecret_box.decrypt(encrypted)
    te = time.time()    
    time_mysecret_box_dec[delka] = te - ts
    speed_mysecret_box_dec[delka] = delka/(te-ts)
    
#####


plt.figure(figsize=(15,10))
plt.plot(*zip(*sorted(time_box_enc.items())), label='box_enc') #, basex=10)
plt.plot(*zip(*sorted(time_sealed_box_enc.items())), label='sealed_box_enc') # , basex=10)
plt.plot(*zip(*sorted(time_secret_box_enc.items())), label='secret_box_enc') # , basex=10)
plt.plot(*zip(*sorted(time_mysecret_box_enc.items())), label='mysecret_box_enc') # , basex=10)

plt.grid(True)
plt.xlabel('size [kB]')
plt.ylabel('time [s]')
plt.title('Encryption time')
plt.legend()
plt.show()

plt.figure(figsize=(15,10))
plt.plot(*zip(*sorted(time_box_dec.items())), label='box_dec') #, basex=10)
plt.plot(*zip(*sorted(time_sealed_box_dec.items())), label='sealed_box_dec') #, basex=10)
plt.plot(*zip(*sorted(time_secret_box_dec.items())), label='secret_box_dec') #, basex=10)
plt.plot(*zip(*sorted(time_mysecret_box_dec.items())), label='mysecret_box_dec') #, basex=10)

plt.grid(True)
plt.xlabel('size [kB]')
plt.ylabel('time [s]')
plt.title('Decryption time')
plt.legend()
plt.show()


plt.figure(figsize=(15,10))
plt.title('Encryption speed')
plt.xlabel('size [kB]')
plt.ylabel('speed [kB/s]')

plt.plot(*zip(*sorted(speed_box_enc.items())), label='Box enc') #,basex=10)
plt.plot(*zip(*sorted(speed_sealed_box_enc.items())), label='SealedBox enc') #, basex=10)
plt.plot(*zip(*sorted(speed_secret_box_enc.items())), label='SecretBox enc') #, basex=10)
plt.plot(*zip(*sorted(speed_mysecret_box_enc.items())), label='MySecretBox enc') #, basex=10)
plt.grid(True)
plt.legend()
plt.show()

plt.figure(figsize=(15,10))
plt.title('Decryption speed')
plt.xlabel('size [kB]')
plt.ylabel('speed [kB/s]')


plt.plot(*zip(*sorted(speed_box_dec.items())), label='Box dec') #,basex=10)
plt.plot(*zip(*sorted(speed_sealed_box_dec.items())), label='SealedBox dec') #, basex=10)
plt.plot(*zip(*sorted(speed_secret_box_dec.items())), label='SecretBox dec') #, basex=10)
plt.plot(*zip(*sorted(speed_mysecret_box_dec.items())), label='MySecretBox dec') #, basex=10)
plt.grid(True)
plt.legend()
plt.show()