def test_pubkey_export_import(self):
pub = self.pke.pubkey()
copy = CHKPKE(pubkey=pub)
self.assertEqual(pub, copy.pubkey())
with self.assertRaises(ValueError):
cpriv = copy.privkey()
self.assertIsNotNone(self.pke.privkey())
def test_encrypt_decrypt(self):
pubpke = CHKPKE(pubkey=self.pke.pubkey())
self.assertIsNotNone(self.pke.privkey(12,12))
with self.assertRaises(ValueError):
cpriv = pubpke.privkey(12,12)
e = Element(self.pke).random()
m = pubpke.encrypt(e, 12);
f = self.pke.decrypt(m, 12);
self.assertEqual(e.to_bytes(), f.to_bytes())
for i in range(0,4096):
if i != 12:
g = self.pke.decrypt(m, i);
self.assertNotEqual(e.to_bytes(), g.to_bytes())
with self.assertRaises(ValueError):
h = pubpke.decrypt(m, 12)
default=0,
help='interval value to encrypt for')
parser.add_argument('-f',
'--file',
default=None,
help='read message plaintext from file instead of stdin')
clargs = parser.parse_args()
if clargs.key is None:
sys.exit('Error: -k / --key option for public key file is mandatory.')
with open(clargs.key, 'r') as keyfile:
PEMkey = keyfile.read()
DERkey = base64.b64decode(PEMkey.split('-----')[2].encode())
try:
pubkey = CHKPKE(pubkey=DERkey)
except ValueError:
sys.exit('Error: Unable to import public key, aborting.')
if pubkey is None:
sys.exit('Error: Unable to import public key, aborting.')
if clargs.file is None:
message = sys.stdin.read()
else:
with open(clargs.file, 'r') as msgfile:
message = msgfile.read()
if (message is None) or (len(message) == 0):
sys.exit('Error: Plaintext length 0, aborting.')
parser = ArgumentParser(description=desc)
parser.add_argument('-s', '--start', type=int, default=0, help='starting interval value to derive new key, default=0')
parser.add_argument('-e', '--end', type=int, default=-1, help='ending interval value to derive new key, default=<last>')
parser.add_argument('-f', '--file', default=None, help='read private key from file instead of stdin')
clargs = parser.parse_args()
if clargs.file is None:
PEMkey = sys.stdin.read()
else:
with open(clargs.file, 'r') as keyfile:
PEMkey=keyfile.read()
DERkey = base64.b64decode(PEMkey.split('-----')[2].encode())
try:
privkey = CHKPKE(privkey=DERkey)
except ValueError:
sys.exit('Error: Unable to import private key, aborting.')
if privkey is None:
sys.exit('Error: Unable to import private key, aborting.')
if clargs.end < 0:
DERkey = privkey.privkey(clargs.start)
else:
DERkey = privkey.privkey(clargs.start, clargs.end)
print('-----BEGIN CHK PRIVATE KEY-----')
print(base64.b64encode(DERkey).decode())
print('-----END CHK PRIVATE KEY-----')
def setUp(self):
self.pke = CHKPKE(128,100,4,8)
def test_privkey_export_import(self):
priv = self.pke.privkey()
copy = CHKPKE(privkey=priv)
self.assertEqual(priv, copy.privkey())
subkey = self.pke.privkey(3,4092)
copy = CHKPKE(privkey=subkey)
self.assertEqual(subkey, copy.privkey(3,4092))
with self.assertRaises(ValueError):
b = copy.privkey()
b = copy.privkey(3)
b = copy.privkey(0,4092)
b = copy.privkey(2,4093)
subkey = copy.privkey(5,4090)
copy = CHKPKE(privkey=subkey)
self.assertEqual(subkey, copy.privkey(5,4090))
with self.assertRaises(ValueError):
b = copy.privkey(4,4091)
class TestCHKPKE(unittest.TestCase):
def setUp(self):
self.pke = CHKPKE(128,100,4,8)
def test_pubkey_export(self):
self.assertIsNotNone(self.pke.pubkey())
def test_privkey_export(self):
self.assertIsNotNone(self.pke.privkey())
self.assertIsNotNone(self.pke.privkey(0))
self.assertEqual(self.pke.privkey(0),self.pke.privkey(0))
self.assertIsNotNone(self.pke.privkey(7))
self.assertNotEqual(self.pke.privkey(0),self.pke.privkey(1))
with self.assertRaises(ValueError):
b = self.pke.privkey(-1)
b = self.pke.privkey(4096)
b = self.pke.privkey(1,4096)
b = self.pke.privkey(11,10)
def test_pubkey_export_import(self):
pub = self.pke.pubkey()
copy = CHKPKE(pubkey=pub)
self.assertEqual(pub, copy.pubkey())
with self.assertRaises(ValueError):
cpriv = copy.privkey()
self.assertIsNotNone(self.pke.privkey())
def test_privkey_export_import(self):
priv = self.pke.privkey()
copy = CHKPKE(privkey=priv)
self.assertEqual(priv, copy.privkey())
subkey = self.pke.privkey(3,4092)
copy = CHKPKE(privkey=subkey)
self.assertEqual(subkey, copy.privkey(3,4092))
with self.assertRaises(ValueError):
b = copy.privkey()
b = copy.privkey(3)
b = copy.privkey(0,4092)
b = copy.privkey(2,4093)
subkey = copy.privkey(5,4090)
copy = CHKPKE(privkey=subkey)
self.assertEqual(subkey, copy.privkey(5,4090))
with self.assertRaises(ValueError):
b = copy.privkey(4,4091)
desc = ('chk-pubkey reads a CHK private key and exports the corresponding '
'public key.')
parser = ArgumentParser(description=desc)
parser.add_argument('-f',
'--file',
default=None,
help='read private key from file instead of stdin')
clargs = parser.parse_args()
if clargs.file is None:
PEMkey = sys.stdin.read()
else:
with open(clargs.file, 'r') as keyfile:
PEMkey = keyfile.read()
DERkey = base64.b64decode(PEMkey.split('-----')[2].encode())
try:
privkey = CHKPKE(privkey=DERkey)
except ValueError:
sys.exit('Error: Unable to import private key, aborting.')
if privkey is None:
sys.exit('Error: Unable to import private key, aborting.')
DERkey = privkey.pubkey()
print('-----BEGIN CHK PUBLIC KEY-----')
print(base64.b64encode(DERkey).decode())
print('-----END CHK PUBLIC KEY-----')
default=None,
help='file path for file containing private key')
parser.add_argument('-f',
'--file',
default=None,
help='read ciphertext from file instead of stdin')
clargs = parser.parse_args()
if clargs.key is None:
sys.exit('Error: -k / --key option for public key file is mandatory.')
with open(clargs.key, 'r') as keyfile:
PEMkey = keyfile.read()
DERkey = base64.b64decode(PEMkey.split('-----')[2].encode())
try:
privkey = CHKPKE(privkey=DERkey)
except ValueError:
sys.exit('Error: Unable to import private key, aborting.')
if privkey is None:
sys.exit('Error: Unable to import private key, aborting.')
if clargs.file is None:
PEMtxt = sys.stdin.read()
else:
with open(clargs.file, 'r') as msgfile:
PEMtxt = msgfile.read()
DERtxt = base64.b64decode(PEMtxt.split('-----')[2].encode())
decoder = asn1.Decoder()