[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]
[tor-commits] [stem/master] Add Ed25519 certificate extension support
commit 3ce6631670cf3a0ffb5d44736bd426c3eaa82b5d
Author: Patrick O'Doherty <p@xxxxxxxxxxx>
Date: Sun Sep 18 17:24:02 2016 -0700
Add Ed25519 certificate extension support
Parse the identity-ed25519 certificate block and validate the extension
contents in accordance with prop #220. Validates the router-sig-ed25519
signature against the provided certified key.
Start of work to verify onion-key-crosscert blocks
---
requirements.txt | 1 +
stem/descriptor/__init__.py | 12 +-
stem/descriptor/certificate.py | 198 ++++++++++++++++++++++++++++++
stem/descriptor/server_descriptor.py | 29 +++++
stem/prereq.py | 21 ++++
test/unit/descriptor/server_descriptor.py | 12 ++
6 files changed, 272 insertions(+), 1 deletion(-)
diff --git a/requirements.txt b/requirements.txt
index 6dc054c..3cd7160 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -3,3 +3,4 @@ pyflakes
pycodestyle
tox
cryptography
+pynacl
diff --git a/stem/descriptor/__init__.py b/stem/descriptor/__init__.py
index 6e8c5a4..4e90889 100644
--- a/stem/descriptor/__init__.py
+++ b/stem/descriptor/__init__.py
@@ -636,7 +636,17 @@ class Descriptor(object):
raise ValueError("Digest is for the range ending with '%s' but that isn't in our descriptor" % end)
digest_content = raw_descriptor[start_index:end_index + len(end)]
- digest_hash = hashlib.sha1(stem.util.str_tools._to_bytes(digest_content))
+ return self._digest_for_bytes(digest_content)
+
+ def _digest_for_bytes(self, bytes_to_sign):
+ """
+ Provides a digest of the provided bytes
+
+ :param bytes bytes_to_sign: the bytes for which we should generate a digest
+
+ :returns: the digest string encoded in uppercase hex
+ """
+ digest_hash = hashlib.sha1(bytes_to_sign)
return stem.util.str_tools._to_unicode(digest_hash.hexdigest().upper())
def __getattr__(self, name):
diff --git a/stem/descriptor/certificate.py b/stem/descriptor/certificate.py
new file mode 100644
index 0000000..e26992f
--- /dev/null
+++ b/stem/descriptor/certificate.py
@@ -0,0 +1,198 @@
+# Copyright 2016, Patrick O'Doherty and The Tor Project
+# See LICENSE for licensing information
+
+"""
+Parsing for the Tor server descriptor Ed25519 Certificates, which is used to
+validate the Ed25519 key used to sign the relay descriptor.
+
+Certificates can optionally contain CertificateExtension objects depending on their type and purpose. Currently Ed25519KeyCertificate certificates will contain one SignedWithEd25519KeyCertificateExtensio
+
+
+**Module Overview:**
+
+::
+
+ Certificate - Tor Certificate
+ |- Ed25519KeyCertificate - Certificate for Ed25519 signing key
+ +- +- verify_descriptor_signature - verify a relay descriptor against a signature
+
+
+ CertificateExtension - Certificate extension
+ +- - SignedWithEd25519KeyCertificateExtension - Ed25519 signing key extension
+"""
+
+import base64
+import hashlib
+import time
+from collections import OrderedDict
+
+import stem.util.str_tools
+
+import nacl.signing
+from nacl.exceptions import BadSignatureError
+
+
+SIGNATURE_LENGTH = 64
+STANDARD_ATTRIBUTES_LENGTH = 40
+CERTIFICATE_FLAGS_LENGTH = 4
+ED25519_ROUTER_SIGNATURE_PREFIX = 'Tor router descriptor signature v1'
+
+
+def _bytes_to_long(b):
+ return long(b.encode('hex'), 16)
+
+
+def _parse_long_offset(offset, length):
+ def _parse(raw_contents):
+ return _bytes_to_long(raw_contents[offset:(offset + length)])
+
+ return _parse
+
+
+def _parse_offset(offset, length):
+ def _parse(raw_contents):
+ return raw_contents[offset:(offset + length)]
+
+ return _parse
+
+
+def _parse_certificate(raw_contents, master_key_bytes, validate = False):
+ version, cert_type = raw_contents[0:2]
+
+ if version == '\x01':
+ if cert_type == '\x04':
+ return Ed25519KeyCertificate(raw_contents, master_key_bytes, validate = validate)
+ elif cert_type == '\x05':
+ # TLS link certificated signed with ed25519 signing key
+ pass
+ elif cert_type == '\x06':
+ # Ed25519 authentication signed with ed25519 signing key
+ pass
+ else:
+ raise ValueError("Unknown Certificate type %s" % cert_type.encode('hex'))
+ else:
+ raise ValueError("Unknown Certificate version %s" % version.encode('hex'))
+
+
+def _parse_extensions(raw_contents):
+ n_extensions = _bytes_to_long(raw_contents[39:40])
+ if n_extensions == 0:
+ return []
+
+ extensions = []
+ extension_bytes = raw_contents[STANDARD_ATTRIBUTES_LENGTH:-SIGNATURE_LENGTH]
+ while len(extension_bytes) > 0:
+ ext_length = _bytes_to_long(extension_bytes[0:2])
+ ext_type, ext_flags = extension_bytes[2:CERTIFICATE_FLAGS_LENGTH]
+ try:
+ ext_data = extension_bytes[CERTIFICATE_FLAGS_LENGTH:(CERTIFICATE_FLAGS_LENGTH + ext_length)]
+ except:
+ raise ValueError('Certificate contained truncated extension')
+
+ if ext_type == SignedWithEd25519KeyCertificateExtension.TYPE:
+ extension = SignedWithEd25519KeyCertificateExtension(ext_type, ext_flags, ext_data)
+ else:
+ raise ValueError('Invalid certificate extension type: %s' % ext_type.encode('hex'))
+
+ extensions.append(extension)
+ extension_bytes = extension_bytes[CERTIFICATE_FLAGS_LENGTH + ext_length:]
+
+ if len(extensions) != n_extensions:
+ raise ValueError('n_extensions was %d but parsed %d' % (n_extensions, len(extensions)))
+
+ return extensions
+
+
+def _parse_signature(cert):
+ return cert[-SIGNATURE_LENGTH:]
+
+
+class Certificate(object):
+ """
+ See proposal #220 <https://gitweb.torproject.org/torspec.git/tree/proposals/220-ecc-id-keys.txt>
+ """
+
+ ATTRIBUTES = {
+ 'version': _parse_offset(0, 1),
+ 'cert_type': _parse_offset(1, 1),
+ 'expiration_date': _parse_long_offset(2, 4),
+ 'cert_key_type': _parse_offset(6, 1),
+ 'certified_key': _parse_offset(7, 32),
+ 'n_extensions': _parse_long_offset(39, 1),
+ 'extensions': _parse_extensions,
+ 'signature': _parse_signature
+ }
+
+ def __init__(self, raw_contents, identity_key, validate = False):
+ self.certificate_bytes = raw_contents
+ self.identity_key = identity_key
+
+ self.__set_certificate_entries(raw_contents)
+
+ def __set_certificate_entries(self, raw_contents):
+ entries = OrderedDict()
+ for key, func in Certificate.ATTRIBUTES.iteritems():
+ try:
+ entries[key] = func(raw_contents)
+ except IndexError:
+ raise ValueError('Unable to get bytes for %s from certificate' % key)
+
+ for key, value in entries.iteritems():
+ setattr(self, key, value)
+
+
+class Ed25519KeyCertificate(Certificate):
+ def __init__(self, raw_contents, identity_key, validate = False):
+ super(Ed25519KeyCertificate, self).__init__(raw_contents, identity_key, validate = False)
+
+ if validate:
+ if len(self.extensions) == 0:
+ raise ValueError('Ed25519KeyCertificate missing SignedWithEd25519KeyCertificateExtension extension')
+
+ self._verify_signature()
+
+ if (self.expiration_date * 3600) < int(time.time()):
+ raise ValueError('Expired Ed25519KeyCertificate')
+
+ def verify_descriptor_signature(self, descriptor, signature):
+ missing_padding = len(signature) % 4
+ signature_bytes = base64.b64decode(stem.util.str_tools._to_bytes(signature) + b'=' * missing_padding)
+ verify_key = nacl.signing.VerifyKey(self.certified_key)
+
+ signed_part = descriptor[:descriptor.index('router-sig-ed25519 ') + len('router-sig-ed25519 ')]
+ descriptor_with_prefix = ED25519_ROUTER_SIGNATURE_PREFIX + signed_part
+ descriptor_sha256_digest = hashlib.sha256(descriptor_with_prefix).digest()
+ verify_key.verify(descriptor_sha256_digest, signature_bytes)
+
+ def _verify_signature(self):
+ if self.identity_key:
+ verify_key = nacl.signing.VerifyKey(base64.b64decode(self.identity_key + '='))
+ else:
+ verify_key = nacl.singing.VerifyKey(self.extensions[0].ext_data)
+
+ try:
+ verify_key.verify(self.certificate_bytes[:-SIGNATURE_LENGTH], self.signature)
+ except BadSignatureError:
+ raise ValueError('Ed25519KeyCertificate signature invalid')
+
+
+class CertificateExtension(object):
+ KNOWN_TYPES = ['\x04']
+
+ def __init__(self, ext_type, ext_flags, ext_data):
+ self.ext_type = ext_type
+ self.ext_flags = ext_flags
+ self.ext_data = ext_data
+
+ def is_known_type(self):
+ return self.ext_type in CertificateExtension.KNOWN_TYPES
+
+ def affects_validation(self):
+ return self.ext_flags == '\x01'
+
+
+class SignedWithEd25519KeyCertificateExtension(CertificateExtension):
+ TYPE = '\x04'
+
+ def __init__(self, ext_type, ext_flags, ext_data):
+ super(SignedWithEd25519KeyCertificateExtension, self).__init__(ext_type, ext_flags, ext_data)
diff --git a/stem/descriptor/server_descriptor.py b/stem/descriptor/server_descriptor.py
index 3aa5fb0..c5bcaad 100644
--- a/stem/descriptor/server_descriptor.py
+++ b/stem/descriptor/server_descriptor.py
@@ -62,6 +62,8 @@ from stem.descriptor import (
_parse_key_block,
)
+from stem.descriptor.certificate import _parse_certificate
+
try:
# added in python 3.2
from functools import lru_cache
@@ -662,6 +664,14 @@ class ServerDescriptor(Descriptor):
if expected_last_keyword and expected_last_keyword != list(entries.keys())[-1]:
raise ValueError("Descriptor must end with a '%s' entry" % expected_last_keyword)
+ if 'identity-ed25519' in entries.keys():
+ if not 'router-sig-ed25519' in entries.keys():
+ raise ValueError("Descriptor must have router-sig-ed25519 entry to accompany identity-ed25519")
+
+ if 'router-sig-ed25519' != list(entries.keys())[-2]:
+ if 'router-sig-ed25519' != list(entries.keys())[-1]:
+ raise ValueError("Descriptor must end with a 'router-sig-ed25519' entry")
+
if not self.exit_policy:
raise ValueError("Descriptor must have at least one 'accept' or 'reject' entry")
@@ -750,6 +760,25 @@ class RelayDescriptor(ServerDescriptor):
if signed_digest != self.digest():
raise ValueError('Decrypted digest does not match local digest (calculated: %s, local: %s)' % (signed_digest, self.digest()))
+ if stem.prereq.is_nacl_available() and self.ed25519_certificate:
+ self.certificate = _parse_certificate(_bytes_for_block(self.ed25519_certificate),
+ self.ed25519_master_key,
+ validate)
+
+ if self.ed25519_master_key is not None:
+ if self.certificate.identity_key != self.ed25519_master_key:
+ raise ValueError("master-key-ed25519 does not match ed25519 certificate identity key")
+
+ self.certificate.verify_descriptor_signature(stem.util.str_tools._to_unicode(raw_contents),
+ self.ed25519_signature)
+
+ onion_key_bytes = _bytes_for_block(self.onion_key)
+ from Crypto.Util import asn1
+ seq = asn1.DerSequence()
+ seq.decode(onion_key_bytes)
+ self._digest_for_signature(self.onion_key, self.onion_key_crosscert)
+
+
@lru_cache()
def digest(self):
"""
diff --git a/stem/prereq.py b/stem/prereq.py
index 585b619..e8769a3 100644
--- a/stem/prereq.py
+++ b/stem/prereq.py
@@ -15,6 +15,7 @@ Checks for stem dependencies. We require python 2.6 or greater (including the
check_requirements - checks for minimum requirements for running stem
is_python_3 - checks if python 3.0 or later is available
is_crypto_available - checks if the cryptography module is available
+ is_nacl_available - checks if the pynacl module is available
"""
import inspect
@@ -27,6 +28,7 @@ except ImportError:
from stem.util.lru_cache import lru_cache
CRYPTO_UNAVAILABLE = "Unable to import the cryptography module. Because of this we'll be unable to verify descriptor signature integrity. You can get cryptography from: https://pypi.python.org/pypi/cryptography";
+NACL_UNAVAILABLE = "Unable to import the pynacl module. Because of this we'll be unable to verify descriptor ed25519 certificate integrity. You can get pynacl from https://github.com/pyca/pynacl/";
def check_requirements():
@@ -146,3 +148,22 @@ def is_mock_available():
return True
except ImportError:
return False
+
+@lru_cache()
+def is_nacl_available():
+ """
+ Checks if the pynacl functions we use are available. This is used for
+ verifying ed25519 certificates in relay descriptor signatures.
+
+ :returns: **True** if we can use pynacl and **False** otherwise
+ """
+
+ from stem.util import log
+
+ try:
+ from nacl import encoding
+ from nacl import signing
+ return True
+ except ImportError:
+ log.log_once('stem.prereq.is_nacl_available', log.INFO, NACL_UNAVAILABLE)
+ return False
diff --git a/test/unit/descriptor/server_descriptor.py b/test/unit/descriptor/server_descriptor.py
index ba8271d..c4e9b67 100644
--- a/test/unit/descriptor/server_descriptor.py
+++ b/test/unit/descriptor/server_descriptor.py
@@ -3,6 +3,7 @@ Unit tests for stem.descriptor.server_descriptor.
"""
import datetime
+import time
import io
import pickle
import tarfile
@@ -245,6 +246,7 @@ Qlx9HNCqCY877ztFRC624ja2ql6A2hBcuoYMbkHjcQ4=
self.assertTrue(isinstance(str(desc), str))
+ @patch('time.time', Mock(return_value = time.mktime(datetime.date(2010, 1, 1).timetuple())))
def test_with_ed25519(self):
"""
Parses a descriptor with a ed25519 identity key, as added by proposal 228
@@ -299,6 +301,16 @@ Qlx9HNCqCY877ztFRC624ja2ql6A2hBcuoYMbkHjcQ4=
self.assertEqual('B5E441051D139CCD84BC765D130B01E44DAC29AD', desc.digest())
self.assertEqual([], desc.get_unrecognized_lines())
+ @patch('time.time', Mock(return_value = time.mktime(datetime.date(2020, 1, 1).timetuple())))
+ def test_with_ed25519_expired_cert(self):
+ """
+ Parses a server descriptor with an expired ed25519 certificate
+ """
+ desc_text = open(get_resource('bridge_descriptor_with_ed25519'), 'rb').read()
+ desc_iter = stem.descriptor.server_descriptor._parse_file(io.BytesIO(desc_text), validate = True)
+ self.assertRaises(ValueError, list, desc_iter)
+
+
def test_bridge_with_ed25519(self):
"""
Parses a bridge descriptor with ed25519.
_______________________________________________
tor-commits mailing list
tor-commits@xxxxxxxxxxxxxxxxxxxx
https://lists.torproject.org/cgi-bin/mailman/listinfo/tor-commits