93 lines
3.8 KiB
Python
93 lines
3.8 KiB
Python
import argparse
|
|
import importlib.util
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import stat
|
|
import sys
|
|
import tempfile
|
|
import unittest
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
sys.path.insert(0, str(ROOT / 'tools'))
|
|
import routeros
|
|
from npk import NovaPackage, NpkPartID, NpkNameInfo, NpkPartItem
|
|
from cryptography.exceptions import InvalidSignature
|
|
|
|
|
|
class SigningTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.temp = tempfile.TemporaryDirectory()
|
|
self.addCleanup(self.temp.cleanup)
|
|
self.root = Path(self.temp.name)
|
|
self.path = self.root / 'keys.json'
|
|
routeros.keygen(argparse.Namespace(output=self.path))
|
|
self.keys = routeros.load_keys(self.path)
|
|
|
|
def package(self):
|
|
package = NovaPackage()
|
|
package._parts = [NpkPartItem(NpkPartID.NAME_INFO, NpkNameInfo('olsr', '7.25.1')),
|
|
NpkPartItem(NpkPartID.ARCHITECTURE, b'arm'),
|
|
NpkPartItem(NpkPartID.DESCRIPTION, b'OLSR test'),
|
|
NpkPartItem(NpkPartID.SIGNATURE, b'\0' * 132)]
|
|
return package
|
|
|
|
def test_private_key_permissions_and_no_overwrite(self):
|
|
self.assertEqual(stat.S_IMODE(self.path.stat().st_mode), 0o600)
|
|
original = self.path.read_bytes()
|
|
with self.assertRaises(FileExistsError):
|
|
routeros.keygen(argparse.Namespace(output=self.path))
|
|
self.assertEqual(original, self.path.read_bytes())
|
|
|
|
def test_public_export_contains_no_private_key(self):
|
|
target = self.root / 'public.json'
|
|
routeros.public(argparse.Namespace(keys=self.path, output=target))
|
|
data = routeros.load_keys(target)
|
|
self.assertFalse(any(k.endswith('_private') for k in data))
|
|
self.assertEqual(data['eddsa_public'], self.keys['eddsa_public'])
|
|
|
|
def test_sign_verify_wrong_key_and_tampering(self):
|
|
target = self.root / 'olsr.npk'
|
|
routeros.sign_save(self.package(), self.keys, target)
|
|
package = NovaPackage.load(target)
|
|
routeros.verify_ed(package, bytes.fromhex(self.keys['eddsa_public']))
|
|
other = self.root / 'other.json'
|
|
routeros.keygen(argparse.Namespace(output=other))
|
|
with self.assertRaises(InvalidSignature):
|
|
routeros.verify_ed(package, bytes.fromhex(routeros.load_keys(other)['eddsa_public']))
|
|
package[NpkPartID.DESCRIPTION].data = b'Tampered payload'
|
|
with self.assertRaises(ValueError):
|
|
routeros.verify_ed(package, bytes.fromhex(self.keys['eddsa_public']))
|
|
|
|
def test_mismatched_keypair_is_rejected(self):
|
|
data = dict(self.keys)
|
|
data['eddsa_public'] = '00' * 32
|
|
self.path.write_text(json.dumps(data))
|
|
with self.assertRaisesRegex(ValueError, 'mismatch'):
|
|
routeros.load_keys(self.path)
|
|
|
|
def test_netinstall_rejects_in_place_output(self):
|
|
target = self.root / 'installer'
|
|
target.write_bytes(b'original')
|
|
with self.assertRaises(ValueError):
|
|
routeros.netinstall(argparse.Namespace(keys=self.path, input=target,
|
|
output=target, source_key=routeros.OFFICIAL_NPK_KEY))
|
|
self.assertEqual(target.read_bytes(), b'original')
|
|
|
|
def test_unsupported_elf_is_rejected(self):
|
|
source = self.root / 'elf64'
|
|
source.write_bytes(b'\x7fELF\x02\x01' + b'\0' * 100)
|
|
output = self.root / 'patched'
|
|
with self.assertRaisesRegex(ValueError, 'ELF32'):
|
|
routeros.netinstall(argparse.Namespace(keys=self.path, input=source,
|
|
output=output, source_key=routeros.OFFICIAL_NPK_KEY))
|
|
self.assertFalse(output.exists())
|
|
|
|
def test_text_policy(self):
|
|
import check_text
|
|
self.assertFalse(check_text.check('OLSR configuration'))
|
|
self.assertTrue(check_text.check(chr(0x4E2D)))
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|