[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]
[tor-commits] [stem/master] stem.descriptor.networkstatus_descriptor => stem.descriptor.networkstatus
commit 4e29ae8dfc69cb68a25c9cf159e56db4e943565b
Author: Ravi Chandra Padmala <neenaoffline@xxxxxxxxx>
Date: Tue Aug 7 12:09:25 2012 +0530
stem.descriptor.networkstatus_descriptor => stem.descriptor.networkstatus
---
run_tests.py | 4 +-
stem/descriptor/__init__.py | 2 +-
stem/descriptor/networkstatus.py | 614 +++++++++++++++++++++
stem/descriptor/networkstatus_descriptor.py | 614 ---------------------
test/integ/descriptor/networkstatus.py | 228 ++++++++
test/integ/descriptor/networkstatus_descriptor.py | 228 --------
6 files changed, 845 insertions(+), 845 deletions(-)
diff --git a/run_tests.py b/run_tests.py
index 10aa24c..8d115f1 100755
--- a/run_tests.py
+++ b/run_tests.py
@@ -46,7 +46,7 @@ import test.integ.socket.control_socket
import test.integ.descriptor.reader
import test.integ.descriptor.server_descriptor
import test.integ.descriptor.extrainfo_descriptor
-import test.integ.descriptor.networkstatus_descriptor
+import test.integ.descriptor.networkstatus
import test.integ.response.protocolinfo
import test.integ.util.conf
import test.integ.util.proc
@@ -135,7 +135,7 @@ INTEG_TESTS = (
test.integ.descriptor.reader.TestDescriptorReader,
test.integ.descriptor.server_descriptor.TestServerDescriptor,
test.integ.descriptor.extrainfo_descriptor.TestExtraInfoDescriptor,
- test.integ.descriptor.networkstatus_descriptor.TestNetworkStatusDocument,
+ test.integ.descriptor.networkstatus.TestNetworkStatusDocument,
test.integ.version.TestVersion,
test.integ.response.protocolinfo.TestProtocolInfo,
test.integ.process.TestProcess,
diff --git a/stem/descriptor/__init__.py b/stem/descriptor/__init__.py
index 5afe214..903a877 100644
--- a/stem/descriptor/__init__.py
+++ b/stem/descriptor/__init__.py
@@ -17,7 +17,7 @@ __all__ = [
"reader",
"extrainfo_descriptor",
"server_descriptor",
- "networkstatus_descriptor",
+ "networkstatus",
"parse_file",
"Descriptor",
]
diff --git a/stem/descriptor/networkstatus.py b/stem/descriptor/networkstatus.py
new file mode 100644
index 0000000..8daf6f7
--- /dev/null
+++ b/stem/descriptor/networkstatus.py
@@ -0,0 +1,614 @@
+"""
+Parsing for Tor network status documents. Currently supports parsing v3 network
+status documents (both votes and consensus').
+
+The network status documents also contain a list of router descriptors,
+directory authorities, signatures etc.
+
+The votes and consensus' can be obtained from any of the following sources...
+
+* the 'cached-consensus' file in tor's data directory
+* tor metrics, at https://metrics.torproject.org/data.html
+* directory authorities and mirrors via their DirPort
+
+**Module Overview:**
+
+::
+
+ parse_file - parses a network status file and provides a NetworkStatusDocument
+ NetworkStatusDocument - Tor v3 network status document
+ +- MicrodescriptorConsensus - Tor microdescriptor consensus document
+ RouterDescriptor - Router descriptor; contains information about a Tor relay
+ +- RouterMicrodescriptor - Router microdescriptor; contains information that doesn't change often
+ DirectorySignature
+ DirectoryAuthority
+"""
+
+import re
+import base64
+import hashlib
+import datetime
+
+import stem.prereq
+import stem.descriptor
+import stem.descriptor.extrainfo_descriptor
+import stem.version
+import stem.exit_policy
+import stem.util.log as log
+import stem.util.connection
+import stem.util.tor_tools
+
+_bandwidth_weights_regex = re.compile(" ".join(["W%s=\d+" % weight for weight in ["bd",
+ "be", "bg", "bm", "db", "eb", "ed", "ee", "eg", "em", "gb", "gd", "gg", "gm", "mb", "md", "me", "mg", "mm"]]))
+
+def parse_file(document_file, validate = True):
+ """
+ Iterates over the router descriptors in a network status document.
+
+ :param file document_file: file with network status document content
+ :param bool validate: checks the validity of the document's contents if True, skips these checks otherwise
+
+ :returns: iterator for :class:`stem.descriptor.networkstatus_descriptor.RouterDescriptor` instances in the file
+
+ :raises:
+ * ValueError if the contents is malformed and validate is True
+ * IOError if the file can't be read
+ """
+
+ document = NetworkStatusDocument(document_file.read(), validate)
+ return document.router_descriptors
+
+def _strptime(string, validate = True, optional = False):
+ try:
+ return datetime.datetime.strptime(string, "%Y-%m-%d %H:%M:%S")
+ except ValueError, exc:
+ if validate or not optional: raise exc
+
+class NetworkStatusDocument(stem.descriptor.Descriptor):
+ """
+ A v3 network status document.
+
+ This could be a v3 consensus or vote document.
+
+ :var bool validated: **\*** whether the document is validated
+ :var str network_status_version: **\*** a document format version. For v3 documents this is "3"
+ :var str vote_status: **\*** status of the vote (is either "vote" or "consensus")
+ :var list consensus_methods: A list of supported consensus generation methods (integers)
+ :var datetime published: time when the document was published
+ :var int consensus_method: consensus method used to generate a consensus
+ :var datetime valid_after: **\*** time when the consensus becomes valid
+ :var datetime fresh_until: **\*** time until when the consensus is considered to be fresh
+ :var datetime valid_until: **\*** time until when the consensus is valid
+ :var int vote_delay: **\*** number of seconds allowed for collecting votes from all authorities
+ :var int dist_delay: number of seconds allowed for collecting signatures from all authorities
+ :var list client_versions: list of recommended Tor client versions
+ :var list server_versions: list of recommended Tor server versions
+ :var list known_flags: **\*** list of known router flags
+ :var list params: dict of parameter(str) => value(int) mappings
+ :var list router_descriptors: **\*** list of RouterDescriptor objects defined in the document
+ :var list directory_authorities: **\*** list of DirectoryAuthority objects that have generated this document
+ :var dict bandwidth_weights: dict of weight(str) => value(int) mappings
+ :var list directory_signatures: **\*** list of signatures this document has
+
+ **\*** attribute is either required when we're parsed with validation or has a default value, others are left as None if undefined
+ """
+
+ def __init__(self, raw_content, validate = True):
+ """
+ Parse a v3 network status document and provide a new NetworkStatusDocument object.
+
+ :param str raw_content: raw network status document data
+ :param bool validate: True if the document is to be validated, False otherwise
+
+ :raises: ValueError if the document is invalid
+ """
+
+ super(NetworkStatusDocument, self).__init__(raw_content)
+
+ self.router_descriptors = []
+ self.directory_authorities = []
+ self.directory_signatures = []
+ self.validated = validate
+
+ self.network_status_version = None
+ self.vote_status = None
+ self.consensus_methods = []
+ self.published = None
+ self.consensus_method = None
+ self.valid_after = None
+ self.fresh_until = None
+ self.valid_until = None
+ self.vote_delay = None
+ self.dist_delay = None
+ self.client_versions = []
+ self.server_versions = []
+ self.known_flags = []
+ self.params = {}
+ self.bandwidth_weights = {}
+
+ self._parse(raw_content)
+
+ def _generate_router(self, raw_content, vote, validate):
+ return RouterDescriptor(raw_content, vote, validate)
+
+ def _validate_network_status_version(self):
+ return self.network_status_version == "3"
+
+ def get_unrecognized_lines(self):
+ """
+ Returns any unrecognized trailing lines.
+
+ :returns: a list of unrecognized trailing lines
+ """
+
+ return self._unrecognized_lines
+
+ def _parse(self, raw_content):
+ # preamble
+ validate = self.validated
+ doc_parser = stem.descriptor.DescriptorParser(raw_content, validate)
+
+ read_keyword_line = lambda keyword, optional = False: setattr(self, keyword.replace("-", "_"), doc_parser.read_keyword_line(keyword, optional))
+
+ map(read_keyword_line, ["network-status-version", "vote-status"])
+ if validate and not self._validate_network_status_version():
+ raise ValueError("Invalid network-status-version: %s" % self.network_status_version)
+
+ if self.vote_status == "vote": vote = True
+ elif self.vote_status == "consensus": vote = False
+ elif validate: raise ValueError("Unrecognized document type specified in vote-status")
+
+ if vote:
+ read_keyword_line("consensus-methods", True)
+ self.consensus_methods = [int(method) for method in self.consensus_methods.split(" ")]
+ self.published = _strptime(doc_parser.read_keyword_line("published", True), validate, True)
+ else:
+ self.consensus_method = int(doc_parser.read_keyword_line("consensus-method", True))
+
+ map(read_keyword_line, ["valid-after", "fresh-until", "valid-until"])
+ self.valid_after = _strptime(self.valid_after, validate)
+ self.fresh_until = _strptime(self.fresh_until, validate)
+ self.valid_until = _strptime(self.valid_until, validate)
+ voting_delay = doc_parser.read_keyword_line("voting-delay")
+ self.vote_delay, self.dist_delay = [int(delay) for delay in voting_delay.split(" ")]
+
+ client_versions = doc_parser.read_keyword_line("client-versions", True)
+ if client_versions:
+ self.client_versions = [stem.version.Version(version_string) for version_string in client_versions.split(",")]
+ server_versions = doc_parser.read_keyword_line("server-versions", True)
+ if server_versions:
+ self.server_versions = [stem.version.Version(version_string) for version_string in server_versions.split(",")]
+ self.known_flags = doc_parser.read_keyword_line("known-flags").split(" ")
+ read_keyword_line("params", True)
+ if self.params:
+ self.params = dict([(param.split("=")[0], int(param.split("=")[1])) for param in self.params.split(" ")])
+
+ # authority section
+ while doc_parser.line.startswith("dir-source "):
+ dirauth_data = doc_parser.read_until(["dir-source", "r"])
+ self.directory_authorities.append(DirectoryAuthority(dirauth_data, vote, validate))
+
+ def _router_desc_generator(raw_content, vote, validate):
+ parser = stem.descriptor.DescriptorParser(raw_content, validate)
+ while parser.line != None:
+ descriptor = parser.read_until("r")
+ yield self._generate_router(descriptor, vote, validate)
+
+ # router descriptors
+ if doc_parser.peek_keyword() == "r":
+ router_descriptors_data = doc_parser.read_until(["bandwidth-weights", "directory-footer", "directory-signature"])
+ self.router_descriptors = _router_desc_generator(router_descriptors_data, vote, validate)
+ elif validate:
+ raise ValueError("No router descriptors found")
+
+ # footer section
+ if self.consensus_method > 9 or vote and filter(lambda x: x >= 9, self.consensus_methods):
+ if doc_parser.line == "directory-footer":
+ doc_parser.read_line()
+ elif validate:
+ raise ValueError("Network status document missing directory-footer")
+
+ if not vote:
+ read_keyword_line("bandwidth-weights", True)
+ if _bandwidth_weights_regex.match(self.bandwidth_weights):
+ self.bandwidth_weights = dict([(weight.split("=")[0], int(weight.split("=")[1])) for weight in self.bandwidth_weights.split(" ")])
+ elif validate:
+ raise ValueError("Invalid bandwidth-weights line")
+
+ while doc_parser.line.startswith("directory-signature "):
+ signature_data = doc_parser.read_until(["directory-signature"])
+ self.directory_signatures.append(DirectorySignature(signature_data))
+
+ self._unrecognized_lines = doc_parser.remaining()
+ if validate and self._unrecognized_lines: raise ValueError("Unrecognized trailing data")
+
+class DirectoryAuthority(stem.descriptor.Descriptor):
+ """
+ Contains directory authority information obtained from v3 network status
+ documents.
+
+ :var str nickname: directory authority's nickname
+ :var str identity: uppercase hex fingerprint of the authority's identity key
+ :var str address: hostname
+ :var str ip: current IP address
+ :var int dirport: current directory port
+ :var int orport: current orport
+ :var str contact: directory authority's contact information
+ :var str legacy_dir_key: fingerprint of and obsolete identity key
+ :var :class:`stem.descriptor.networkstatus_descriptor.KeyCertificate` key_certificate: directory authority's current key certificate
+ :var str vote_digest: digest of the authority that contributed to the consensus
+ """
+
+ def __init__(self, raw_content, vote = True, validate = True):
+ """
+ Parse a directory authority entry in a v3 network status document and
+ provide a DirectoryAuthority object.
+
+ :param str raw_content: raw directory authority entry information
+ :param bool validate: True if the document is to be validated, False otherwise
+
+ :raises: ValueError if the raw data is invalid
+ """
+
+ super(DirectoryAuthority, self).__init__(raw_content)
+ self.nickname, self.identity, self.address, self.ip = None, None, None, None
+ self.dirport, self.orport, self.legacy_dir_key = None, None, None
+ self.key_certificate, self.contact, self.vote_digest = None, None, None
+ parser = stem.descriptor.DescriptorParser(raw_content, validate)
+
+ dir_source = parser.read_keyword_line("dir-source")
+ self.nickname, self.identity, self.address, self.ip, self.dirport, self.orport = dir_source.split(" ")
+ self.dirport = int(self.dirport)
+ self.orport = int(self.orport)
+
+ self.contact = parser.read_keyword_line("contact")
+ if vote:
+ self.legacy_dir_key = parser.read_keyword_line("legacy-dir-key", True)
+ self.key_certificate = KeyCertificate("\n".join(parser.remaining()), validate)
+ else:
+ self.vote_digest = parser.read_keyword_line("vote-digest", True)
+ rmng = parser.remaining()
+ if rmng and validate:
+ raise ValueError("Unrecognized trailing data in directory authority information")
+
+class KeyCertificate(stem.descriptor.Descriptor):
+ """
+ Directory key certificate.
+
+ :var str key_certificate_version: **\*** version of the key certificate (Should be "3")
+ :var str ip: IP address on which the directory authority is listening
+ :var int port: port on which the directory authority is listening
+ :var str fingerprint: **\*** hex encoded fingerprint of the authority's identity key
+ :var str identity_key: **\*** long term authority identity key
+ :var datetime published: **\*** time (in GMT) when this document & the key were last generated
+ :var str expires: **\*** time (in GMT) after which this key becomes invalid
+ :var str signing_key: **\*** directory server's public signing key
+ :var str crosscert: signature made using certificate's signing key
+ :var str certification: **\*** signature of this key certificate signed with the identity key
+
+ **\*** attribute is either required when we're parsed with validation or has a default value, others are left as None if undefined
+ """
+
+ def __init__(self, raw_content, validate = True):
+ """
+ Parse a key certificate entry and provide a KeyCertificate object.
+
+ :param str raw_content: raw key certificate information
+ :param bool validate: True if the document is to be validated, False otherwise
+
+ :raises: ValueError if the raw data is invalid
+ """
+
+ super(KeyCertificate, self).__init__(raw_content)
+ self.key_certificate_version, self.ip, self.port = None, None, None
+ self.fingerprint, self.identity_key, self.published = None, None, None
+ self.expires, self.signing_key, self.crosscert = None, None, None
+ self.certification = None
+ parser = stem.descriptor.DescriptorParser(raw_content, validate)
+ peek_check_kw = lambda keyword: keyword == parser.peek_keyword()
+ seen_keywords = set()
+
+ self.key_certificate_version = parser.read_keyword_line("dir-key-certificate-version")
+ if validate and self.key_certificate_version != "3": raise ValueError("Unrecognized dir-key-certificate-version")
+
+ def _read_keyword_line(keyword):
+ if validate and keyword in seen_keywords:
+ raise ValueError("Invalid key certificate: '%s' appears twice" % keyword)
+ seen_keywords.add(keyword)
+ return parser.read_keyword_line(keyword)
+
+ while parser.line:
+ if peek_check_kw("dir-address"):
+ line = _read_keyword_line("dir-address")
+ try:
+ self.ip, self.port = line.rsplit(":", 1)
+ self.port = int(self.port)
+ except Exception:
+ if validate: raise ValueError("Invalid dir-address line: %s" % line)
+
+ elif peek_check_kw("fingerprint"):
+ self.fingerprint = _read_keyword_line("fingerprint")
+
+ elif peek_check_kw("dir-identity-key"):
+ _read_keyword_line("dir-identity-key")
+ self.identity_key = parser.read_block("RSA PUBLIC KEY")
+
+ elif peek_check_kw("dir-key-published"):
+ self.published = _strptime(_read_keyword_line("dir-key-published"))
+
+ elif peek_check_kw("dir-key-expires"):
+ self.expires = _strptime(_read_keyword_line("dir-key-expires"))
+
+ elif peek_check_kw("dir-signing-key"):
+ _read_keyword_line("dir-signing-key")
+ self.signing_key = parser.read_block("RSA PUBLIC KEY")
+
+ elif peek_check_kw("dir-key-crosscert"):
+ _read_keyword_line("dir-key-crosscert")
+ self.crosscert = parser.read_block("ID SIGNATURE")
+
+ elif peek_check_kw("dir-key-certification"):
+ _read_keyword_line("dir-key-certification")
+ self.certification = parser.read_block("SIGNATURE")
+ break
+
+ elif validate:
+ raise ValueError("Key certificate contains unrecognized lines: %s" % parser.line)
+
+ else:
+ # ignore unrecognized lines if we aren't validating
+ self._unrecognized_lines.append(parser.read_line())
+
+ self._unrecognized_lines = parser.remaining()
+ if self._unrecognized_lines and validate:
+ raise ValueError("Unrecognized trailing data in key certificate")
+
+ def get_unrecognized_lines(self):
+ """
+ Returns any unrecognized lines.
+
+ :returns: a list of unrecognized lines
+ """
+
+ return self._unrecognized_lines
+
+class DirectorySignature(stem.descriptor.Descriptor):
+ """
+ Contains directory signature information described in a v3 network status
+ document.
+
+ :var str identity: signature identity
+ :var str key_digest: signature key digest
+ :var str method: method used to generate the signature
+ :var str signature: the signature data
+ """
+
+ def __init__(self, raw_content, validate = True):
+ """
+ Parse a directory signature entry in a v3 network status document and
+ provide a DirectorySignature object.
+
+ :param str raw_content: raw directory signature entry information
+ :param bool validate: True if the document is to be validated, False otherwise
+
+ :raises: ValueError if the raw data is invalid
+ """
+
+ super(DirectorySignature, self).__init__(raw_content)
+ self.identity, self.key_digest, self.method, self.signature = None, None, None, None
+ parser = stem.descriptor.DescriptorParser(raw_content, validate)
+
+ signature_line = parser.read_keyword_line("directory-signature").split(" ")
+
+ if len(signature_line) == 2:
+ self.identity, self.key_digest = signature_line
+ if len(signature_line) == 3: # for microdescriptor consensuses
+ self.method, self.identity, self.key_digest = signature_line
+
+ self.signature = parser.read_block("SIGNATURE")
+ self._unrecognized_lines = parser.remaining()
+ if self._unrecognized_lines and validate:
+ raise ValueError("Unrecognized trailing data in directory signature")
+
+class RouterDescriptor(stem.descriptor.Descriptor):
+ """
+ Router descriptor object. Parses and stores router information in a router
+ entry read from a v3 network status document.
+
+ :var str nickname: **\*** router's nickname
+ :var str identity: **\*** router's identity
+ :var str digest: **\*** router's digest
+ :var datetime publication: **\*** router's publication
+ :var str ip: **\*** router's IP address
+ :var int orport: **\*** router's ORPort
+ :var int dirport: **\*** router's DirPort
+
+ :var bool is_valid: **\*** router is valid
+ :var bool is_guard: **\*** router is suitable for use as an entry guard
+ :var bool is_named: **\*** router is named
+ :var bool is_unnamed: **\*** router is unnamed
+ :var bool is_running: **\*** router is running and currently usable
+ :var bool is_stable: **\*** router is stable, i.e., it's suitable for for long-lived circuits
+ :var bool is_exit: **\*** router is an exit router
+ :var bool is_fast: **\*** router is Fast, i.e., it's usable for high-bandwidth circuits
+ :var bool is_authority: **\*** router is a directory authority
+ :var bool supports_v2dir: **\*** router supports v2dir
+ :var bool supports_v3dir: **\*** router supports v3dir
+ :var bool is_hsdir: **\*** router is a hidden status
+ :var bool is_badexit: **\*** router is marked a bad exit
+ :var bool is_baddirectory: **\*** router is a bad directory
+
+ :var :class:`stem.version.Version`,str version: Version of the Tor protocol this router is running
+
+ :var int bandwidth: router's claimed bandwidth
+ :var int measured_bandwidth: router's measured bandwidth
+
+ :var :class:`stem.exit_policy.MicrodescriptorExitPolicy` exitpolicy: router's exitpolicy
+
+ :var str microdescriptor_hashes: a list of two-tuples with a list of consensus methods(int) that may produce the digest and a dict with algorithm(str) => digest(str) mappings. algorithm is the hashing algorithm (usually "sha256") that is used to produce digest (the base64 encoding of the hash of the router's microdescriptor with trailing =s omitted).
+
+ **\*** attribute is either required when we're parsed with validation or has a default value, others are left as None if undefined
+ """
+
+ def __init__(self, raw_contents, vote = True, validate = True):
+ """
+ Parse a router descriptor in a v3 network status document and provide a new
+ RouterDescriptor object.
+
+ :param str raw_content: router descriptor content to be parsed
+ :param bool validate: whether the router descriptor should be validated
+ """
+
+ super(RouterDescriptor, self).__init__(raw_contents)
+
+ self.nickname = None
+ self.identity = None
+ self.digest = None
+ self.publication = None
+ self.ip = None
+ self.orport = None
+ self.dirport = None
+
+ self.is_valid = False
+ self.is_guard = False
+ self.is_named = False
+ self.is_unnamed = False
+ self.is_running = False
+ self.is_stable = False
+ self.is_exit = False
+ self.is_fast = False
+ self.is_authority = False
+ self.supports_v2dir = False
+ self.supports_v3dir = False
+ self.is_hsdir = False
+ self.is_badexit = False
+ self.is_baddirectory = False
+
+ self.version = None
+
+ self.bandwidth = None
+ self.measured_bandwidth = None
+
+ self.exit_policy = None
+
+ self.microdescriptor_hashes = []
+
+ self._parse(raw_contents, vote, validate)
+
+ def _parse(self, raw_content, vote, validate):
+ """
+ :param dict raw_content: iptor contents to be applied
+ :param bool validate: checks the validity of descriptor content if True
+
+ :raises: ValueError if an error occures in validation
+ """
+
+ parser = stem.descriptor.DescriptorParser(raw_content, validate)
+ seen_keywords = set()
+ peek_check_kw = lambda keyword: keyword == parser.peek_keyword()
+
+ r = parser.read_keyword_line("r")
+ # r mauer BD7xbfsCFku3+tgybEZsg8Yjhvw itcuKQ6PuPLJ7m/Oi928WjO2j8g 2012-06-22 13:19:32 80.101.105.103 9001 0
+ # "r" SP nickname SP identity SP digest SP publication SP IP SP ORPort SP DirPort NL
+ seen_keywords.add("r")
+ if r:
+ values = r.split(" ")
+ self.nickname, self.identity, self.digest = values[0], values[1], values[2]
+ self.publication = _strptime(" ".join((values[3], values[4])), validate)
+ self.ip, self.orport, self.dirport = values[5], int(values[6]), int(values[7])
+ if self.dirport == 0: self.dirport = None
+ elif validate: raise ValueError("Invalid router descriptor: empty 'r' line" )
+
+ while parser.line:
+ if peek_check_kw("s"):
+ if "s" in seen_keywords: raise ValueError("Invalid router descriptor: 's' line appears twice")
+ line = parser.read_keyword_line("s")
+ if not line: continue
+ seen_keywords.add("s")
+ # s Named Running Stable Valid
+ #A series of space-separated status flags, in *lexical order*
+ flags = line.split(" ")
+ flag_map = {
+ "Valid": "is_valid",
+ "Guard": "is_guard",
+ "Named": "is_named",
+ "Unnamed": "is_unnamed",
+ "Running": "is_running",
+ "Stable": "is_stable",
+ "Exit": "is_exit",
+ "Fast": "is_fast",
+ "Authority": "is_authority",
+ "V2Dir": "supports_v2dir",
+ "V3Dir": "supports_v3dir",
+ "HSDir": "is_hsdir",
+ "BadExit": "is_badexit",
+ "BadDirectory": "is_baddirectory",
+ }
+ map(lambda flag: setattr(self, flag_map[flag], True), flags)
+
+ if self.is_unnamed: self.is_named = False
+ elif self.is_named: self.is_unnamed = False
+
+ elif peek_check_kw("v"):
+ if "v" in seen_keywords: raise ValueError("Invalid router descriptor: 'v' line appears twice")
+ line = parser.read_keyword_line("v", True)
+ seen_keywords.add("v")
+ # v Tor 0.2.2.35
+ if line:
+ if line.startswith("Tor "):
+ self.version = stem.version.Version(line[4:])
+ else:
+ self.version = line
+ elif validate: raise ValueError("Invalid router descriptor: empty 'v' line" )
+
+ elif peek_check_kw("w"):
+ if "w" in seen_keywords: raise ValueError("Invalid router descriptor: 'w' line appears twice")
+ w = parser.read_keyword_line("w", True)
+ # "w" SP "Bandwidth=" INT [SP "Measured=" INT] NL
+ seen_keywords.add("w")
+ if w:
+ values = w.split(" ")
+ if len(values) <= 2 and len(values) > 0:
+ key, value = values[0].split("=")
+ if key == "Bandwidth": self.bandwidth = int(value)
+ elif validate: raise ValueError("Router descriptor contains invalid 'w' line: expected Bandwidth, read " + key)
+
+ if len(values) == 2:
+ key, value = values[1].split("=")
+ if key == "Measured": self.measured_bandwidth = int(value)
+ elif validate: raise ValueError("Router descriptor contains invalid 'w' line: expected Measured, read " + key)
+ elif validate: raise ValueError("Router descriptor contains invalid 'w' line")
+ elif validate: raise ValueError("Router descriptor contains empty 'w' line")
+
+ elif peek_check_kw("p"):
+ if "p" in seen_keywords: raise ValueError("Invalid router descriptor: 'p' line appears twice")
+ p = parser.read_keyword_line("p", True)
+ seen_keywords.add("p")
+ # "p" SP ("accept" / "reject") SP PortList NL
+ if p:
+ self.exit_policy = stem.exit_policy.MicrodescriptorExitPolicy(p)
+ #self.exit_policy = p
+
+ elif vote and peek_check_kw("m"):
+ # microdescriptor hashes
+ m = parser.read_keyword_line("m", True)
+ methods, digests = m.split(" ", 1)
+ method_list = methods.split(",")
+ digest_dict = [digest.split("=", 1) for digest in digests.split(" ")]
+ self.microdescriptor_hashes.append((method_list, digest_dict))
+
+ elif validate:
+ raise ValueError("Router descriptor contains unrecognized trailing lines: %s" % parser.line)
+
+ else:
+ self._unrecognized_lines.append(parser.read_line()) # ignore unrecognized lines if we aren't validating
+
+ def get_unrecognized_lines(self):
+ """
+ Returns any unrecognized lines.
+
+ :returns: a list of unrecognized lines
+ """
+
+ return self._unrecognized_lines
+
diff --git a/stem/descriptor/networkstatus_descriptor.py b/stem/descriptor/networkstatus_descriptor.py
deleted file mode 100644
index 8daf6f7..0000000
--- a/stem/descriptor/networkstatus_descriptor.py
+++ /dev/null
@@ -1,614 +0,0 @@
-"""
-Parsing for Tor network status documents. Currently supports parsing v3 network
-status documents (both votes and consensus').
-
-The network status documents also contain a list of router descriptors,
-directory authorities, signatures etc.
-
-The votes and consensus' can be obtained from any of the following sources...
-
-* the 'cached-consensus' file in tor's data directory
-* tor metrics, at https://metrics.torproject.org/data.html
-* directory authorities and mirrors via their DirPort
-
-**Module Overview:**
-
-::
-
- parse_file - parses a network status file and provides a NetworkStatusDocument
- NetworkStatusDocument - Tor v3 network status document
- +- MicrodescriptorConsensus - Tor microdescriptor consensus document
- RouterDescriptor - Router descriptor; contains information about a Tor relay
- +- RouterMicrodescriptor - Router microdescriptor; contains information that doesn't change often
- DirectorySignature
- DirectoryAuthority
-"""
-
-import re
-import base64
-import hashlib
-import datetime
-
-import stem.prereq
-import stem.descriptor
-import stem.descriptor.extrainfo_descriptor
-import stem.version
-import stem.exit_policy
-import stem.util.log as log
-import stem.util.connection
-import stem.util.tor_tools
-
-_bandwidth_weights_regex = re.compile(" ".join(["W%s=\d+" % weight for weight in ["bd",
- "be", "bg", "bm", "db", "eb", "ed", "ee", "eg", "em", "gb", "gd", "gg", "gm", "mb", "md", "me", "mg", "mm"]]))
-
-def parse_file(document_file, validate = True):
- """
- Iterates over the router descriptors in a network status document.
-
- :param file document_file: file with network status document content
- :param bool validate: checks the validity of the document's contents if True, skips these checks otherwise
-
- :returns: iterator for :class:`stem.descriptor.networkstatus_descriptor.RouterDescriptor` instances in the file
-
- :raises:
- * ValueError if the contents is malformed and validate is True
- * IOError if the file can't be read
- """
-
- document = NetworkStatusDocument(document_file.read(), validate)
- return document.router_descriptors
-
-def _strptime(string, validate = True, optional = False):
- try:
- return datetime.datetime.strptime(string, "%Y-%m-%d %H:%M:%S")
- except ValueError, exc:
- if validate or not optional: raise exc
-
-class NetworkStatusDocument(stem.descriptor.Descriptor):
- """
- A v3 network status document.
-
- This could be a v3 consensus or vote document.
-
- :var bool validated: **\*** whether the document is validated
- :var str network_status_version: **\*** a document format version. For v3 documents this is "3"
- :var str vote_status: **\*** status of the vote (is either "vote" or "consensus")
- :var list consensus_methods: A list of supported consensus generation methods (integers)
- :var datetime published: time when the document was published
- :var int consensus_method: consensus method used to generate a consensus
- :var datetime valid_after: **\*** time when the consensus becomes valid
- :var datetime fresh_until: **\*** time until when the consensus is considered to be fresh
- :var datetime valid_until: **\*** time until when the consensus is valid
- :var int vote_delay: **\*** number of seconds allowed for collecting votes from all authorities
- :var int dist_delay: number of seconds allowed for collecting signatures from all authorities
- :var list client_versions: list of recommended Tor client versions
- :var list server_versions: list of recommended Tor server versions
- :var list known_flags: **\*** list of known router flags
- :var list params: dict of parameter(str) => value(int) mappings
- :var list router_descriptors: **\*** list of RouterDescriptor objects defined in the document
- :var list directory_authorities: **\*** list of DirectoryAuthority objects that have generated this document
- :var dict bandwidth_weights: dict of weight(str) => value(int) mappings
- :var list directory_signatures: **\*** list of signatures this document has
-
- **\*** attribute is either required when we're parsed with validation or has a default value, others are left as None if undefined
- """
-
- def __init__(self, raw_content, validate = True):
- """
- Parse a v3 network status document and provide a new NetworkStatusDocument object.
-
- :param str raw_content: raw network status document data
- :param bool validate: True if the document is to be validated, False otherwise
-
- :raises: ValueError if the document is invalid
- """
-
- super(NetworkStatusDocument, self).__init__(raw_content)
-
- self.router_descriptors = []
- self.directory_authorities = []
- self.directory_signatures = []
- self.validated = validate
-
- self.network_status_version = None
- self.vote_status = None
- self.consensus_methods = []
- self.published = None
- self.consensus_method = None
- self.valid_after = None
- self.fresh_until = None
- self.valid_until = None
- self.vote_delay = None
- self.dist_delay = None
- self.client_versions = []
- self.server_versions = []
- self.known_flags = []
- self.params = {}
- self.bandwidth_weights = {}
-
- self._parse(raw_content)
-
- def _generate_router(self, raw_content, vote, validate):
- return RouterDescriptor(raw_content, vote, validate)
-
- def _validate_network_status_version(self):
- return self.network_status_version == "3"
-
- def get_unrecognized_lines(self):
- """
- Returns any unrecognized trailing lines.
-
- :returns: a list of unrecognized trailing lines
- """
-
- return self._unrecognized_lines
-
- def _parse(self, raw_content):
- # preamble
- validate = self.validated
- doc_parser = stem.descriptor.DescriptorParser(raw_content, validate)
-
- read_keyword_line = lambda keyword, optional = False: setattr(self, keyword.replace("-", "_"), doc_parser.read_keyword_line(keyword, optional))
-
- map(read_keyword_line, ["network-status-version", "vote-status"])
- if validate and not self._validate_network_status_version():
- raise ValueError("Invalid network-status-version: %s" % self.network_status_version)
-
- if self.vote_status == "vote": vote = True
- elif self.vote_status == "consensus": vote = False
- elif validate: raise ValueError("Unrecognized document type specified in vote-status")
-
- if vote:
- read_keyword_line("consensus-methods", True)
- self.consensus_methods = [int(method) for method in self.consensus_methods.split(" ")]
- self.published = _strptime(doc_parser.read_keyword_line("published", True), validate, True)
- else:
- self.consensus_method = int(doc_parser.read_keyword_line("consensus-method", True))
-
- map(read_keyword_line, ["valid-after", "fresh-until", "valid-until"])
- self.valid_after = _strptime(self.valid_after, validate)
- self.fresh_until = _strptime(self.fresh_until, validate)
- self.valid_until = _strptime(self.valid_until, validate)
- voting_delay = doc_parser.read_keyword_line("voting-delay")
- self.vote_delay, self.dist_delay = [int(delay) for delay in voting_delay.split(" ")]
-
- client_versions = doc_parser.read_keyword_line("client-versions", True)
- if client_versions:
- self.client_versions = [stem.version.Version(version_string) for version_string in client_versions.split(",")]
- server_versions = doc_parser.read_keyword_line("server-versions", True)
- if server_versions:
- self.server_versions = [stem.version.Version(version_string) for version_string in server_versions.split(",")]
- self.known_flags = doc_parser.read_keyword_line("known-flags").split(" ")
- read_keyword_line("params", True)
- if self.params:
- self.params = dict([(param.split("=")[0], int(param.split("=")[1])) for param in self.params.split(" ")])
-
- # authority section
- while doc_parser.line.startswith("dir-source "):
- dirauth_data = doc_parser.read_until(["dir-source", "r"])
- self.directory_authorities.append(DirectoryAuthority(dirauth_data, vote, validate))
-
- def _router_desc_generator(raw_content, vote, validate):
- parser = stem.descriptor.DescriptorParser(raw_content, validate)
- while parser.line != None:
- descriptor = parser.read_until("r")
- yield self._generate_router(descriptor, vote, validate)
-
- # router descriptors
- if doc_parser.peek_keyword() == "r":
- router_descriptors_data = doc_parser.read_until(["bandwidth-weights", "directory-footer", "directory-signature"])
- self.router_descriptors = _router_desc_generator(router_descriptors_data, vote, validate)
- elif validate:
- raise ValueError("No router descriptors found")
-
- # footer section
- if self.consensus_method > 9 or vote and filter(lambda x: x >= 9, self.consensus_methods):
- if doc_parser.line == "directory-footer":
- doc_parser.read_line()
- elif validate:
- raise ValueError("Network status document missing directory-footer")
-
- if not vote:
- read_keyword_line("bandwidth-weights", True)
- if _bandwidth_weights_regex.match(self.bandwidth_weights):
- self.bandwidth_weights = dict([(weight.split("=")[0], int(weight.split("=")[1])) for weight in self.bandwidth_weights.split(" ")])
- elif validate:
- raise ValueError("Invalid bandwidth-weights line")
-
- while doc_parser.line.startswith("directory-signature "):
- signature_data = doc_parser.read_until(["directory-signature"])
- self.directory_signatures.append(DirectorySignature(signature_data))
-
- self._unrecognized_lines = doc_parser.remaining()
- if validate and self._unrecognized_lines: raise ValueError("Unrecognized trailing data")
-
-class DirectoryAuthority(stem.descriptor.Descriptor):
- """
- Contains directory authority information obtained from v3 network status
- documents.
-
- :var str nickname: directory authority's nickname
- :var str identity: uppercase hex fingerprint of the authority's identity key
- :var str address: hostname
- :var str ip: current IP address
- :var int dirport: current directory port
- :var int orport: current orport
- :var str contact: directory authority's contact information
- :var str legacy_dir_key: fingerprint of and obsolete identity key
- :var :class:`stem.descriptor.networkstatus_descriptor.KeyCertificate` key_certificate: directory authority's current key certificate
- :var str vote_digest: digest of the authority that contributed to the consensus
- """
-
- def __init__(self, raw_content, vote = True, validate = True):
- """
- Parse a directory authority entry in a v3 network status document and
- provide a DirectoryAuthority object.
-
- :param str raw_content: raw directory authority entry information
- :param bool validate: True if the document is to be validated, False otherwise
-
- :raises: ValueError if the raw data is invalid
- """
-
- super(DirectoryAuthority, self).__init__(raw_content)
- self.nickname, self.identity, self.address, self.ip = None, None, None, None
- self.dirport, self.orport, self.legacy_dir_key = None, None, None
- self.key_certificate, self.contact, self.vote_digest = None, None, None
- parser = stem.descriptor.DescriptorParser(raw_content, validate)
-
- dir_source = parser.read_keyword_line("dir-source")
- self.nickname, self.identity, self.address, self.ip, self.dirport, self.orport = dir_source.split(" ")
- self.dirport = int(self.dirport)
- self.orport = int(self.orport)
-
- self.contact = parser.read_keyword_line("contact")
- if vote:
- self.legacy_dir_key = parser.read_keyword_line("legacy-dir-key", True)
- self.key_certificate = KeyCertificate("\n".join(parser.remaining()), validate)
- else:
- self.vote_digest = parser.read_keyword_line("vote-digest", True)
- rmng = parser.remaining()
- if rmng and validate:
- raise ValueError("Unrecognized trailing data in directory authority information")
-
-class KeyCertificate(stem.descriptor.Descriptor):
- """
- Directory key certificate.
-
- :var str key_certificate_version: **\*** version of the key certificate (Should be "3")
- :var str ip: IP address on which the directory authority is listening
- :var int port: port on which the directory authority is listening
- :var str fingerprint: **\*** hex encoded fingerprint of the authority's identity key
- :var str identity_key: **\*** long term authority identity key
- :var datetime published: **\*** time (in GMT) when this document & the key were last generated
- :var str expires: **\*** time (in GMT) after which this key becomes invalid
- :var str signing_key: **\*** directory server's public signing key
- :var str crosscert: signature made using certificate's signing key
- :var str certification: **\*** signature of this key certificate signed with the identity key
-
- **\*** attribute is either required when we're parsed with validation or has a default value, others are left as None if undefined
- """
-
- def __init__(self, raw_content, validate = True):
- """
- Parse a key certificate entry and provide a KeyCertificate object.
-
- :param str raw_content: raw key certificate information
- :param bool validate: True if the document is to be validated, False otherwise
-
- :raises: ValueError if the raw data is invalid
- """
-
- super(KeyCertificate, self).__init__(raw_content)
- self.key_certificate_version, self.ip, self.port = None, None, None
- self.fingerprint, self.identity_key, self.published = None, None, None
- self.expires, self.signing_key, self.crosscert = None, None, None
- self.certification = None
- parser = stem.descriptor.DescriptorParser(raw_content, validate)
- peek_check_kw = lambda keyword: keyword == parser.peek_keyword()
- seen_keywords = set()
-
- self.key_certificate_version = parser.read_keyword_line("dir-key-certificate-version")
- if validate and self.key_certificate_version != "3": raise ValueError("Unrecognized dir-key-certificate-version")
-
- def _read_keyword_line(keyword):
- if validate and keyword in seen_keywords:
- raise ValueError("Invalid key certificate: '%s' appears twice" % keyword)
- seen_keywords.add(keyword)
- return parser.read_keyword_line(keyword)
-
- while parser.line:
- if peek_check_kw("dir-address"):
- line = _read_keyword_line("dir-address")
- try:
- self.ip, self.port = line.rsplit(":", 1)
- self.port = int(self.port)
- except Exception:
- if validate: raise ValueError("Invalid dir-address line: %s" % line)
-
- elif peek_check_kw("fingerprint"):
- self.fingerprint = _read_keyword_line("fingerprint")
-
- elif peek_check_kw("dir-identity-key"):
- _read_keyword_line("dir-identity-key")
- self.identity_key = parser.read_block("RSA PUBLIC KEY")
-
- elif peek_check_kw("dir-key-published"):
- self.published = _strptime(_read_keyword_line("dir-key-published"))
-
- elif peek_check_kw("dir-key-expires"):
- self.expires = _strptime(_read_keyword_line("dir-key-expires"))
-
- elif peek_check_kw("dir-signing-key"):
- _read_keyword_line("dir-signing-key")
- self.signing_key = parser.read_block("RSA PUBLIC KEY")
-
- elif peek_check_kw("dir-key-crosscert"):
- _read_keyword_line("dir-key-crosscert")
- self.crosscert = parser.read_block("ID SIGNATURE")
-
- elif peek_check_kw("dir-key-certification"):
- _read_keyword_line("dir-key-certification")
- self.certification = parser.read_block("SIGNATURE")
- break
-
- elif validate:
- raise ValueError("Key certificate contains unrecognized lines: %s" % parser.line)
-
- else:
- # ignore unrecognized lines if we aren't validating
- self._unrecognized_lines.append(parser.read_line())
-
- self._unrecognized_lines = parser.remaining()
- if self._unrecognized_lines and validate:
- raise ValueError("Unrecognized trailing data in key certificate")
-
- def get_unrecognized_lines(self):
- """
- Returns any unrecognized lines.
-
- :returns: a list of unrecognized lines
- """
-
- return self._unrecognized_lines
-
-class DirectorySignature(stem.descriptor.Descriptor):
- """
- Contains directory signature information described in a v3 network status
- document.
-
- :var str identity: signature identity
- :var str key_digest: signature key digest
- :var str method: method used to generate the signature
- :var str signature: the signature data
- """
-
- def __init__(self, raw_content, validate = True):
- """
- Parse a directory signature entry in a v3 network status document and
- provide a DirectorySignature object.
-
- :param str raw_content: raw directory signature entry information
- :param bool validate: True if the document is to be validated, False otherwise
-
- :raises: ValueError if the raw data is invalid
- """
-
- super(DirectorySignature, self).__init__(raw_content)
- self.identity, self.key_digest, self.method, self.signature = None, None, None, None
- parser = stem.descriptor.DescriptorParser(raw_content, validate)
-
- signature_line = parser.read_keyword_line("directory-signature").split(" ")
-
- if len(signature_line) == 2:
- self.identity, self.key_digest = signature_line
- if len(signature_line) == 3: # for microdescriptor consensuses
- self.method, self.identity, self.key_digest = signature_line
-
- self.signature = parser.read_block("SIGNATURE")
- self._unrecognized_lines = parser.remaining()
- if self._unrecognized_lines and validate:
- raise ValueError("Unrecognized trailing data in directory signature")
-
-class RouterDescriptor(stem.descriptor.Descriptor):
- """
- Router descriptor object. Parses and stores router information in a router
- entry read from a v3 network status document.
-
- :var str nickname: **\*** router's nickname
- :var str identity: **\*** router's identity
- :var str digest: **\*** router's digest
- :var datetime publication: **\*** router's publication
- :var str ip: **\*** router's IP address
- :var int orport: **\*** router's ORPort
- :var int dirport: **\*** router's DirPort
-
- :var bool is_valid: **\*** router is valid
- :var bool is_guard: **\*** router is suitable for use as an entry guard
- :var bool is_named: **\*** router is named
- :var bool is_unnamed: **\*** router is unnamed
- :var bool is_running: **\*** router is running and currently usable
- :var bool is_stable: **\*** router is stable, i.e., it's suitable for for long-lived circuits
- :var bool is_exit: **\*** router is an exit router
- :var bool is_fast: **\*** router is Fast, i.e., it's usable for high-bandwidth circuits
- :var bool is_authority: **\*** router is a directory authority
- :var bool supports_v2dir: **\*** router supports v2dir
- :var bool supports_v3dir: **\*** router supports v3dir
- :var bool is_hsdir: **\*** router is a hidden status
- :var bool is_badexit: **\*** router is marked a bad exit
- :var bool is_baddirectory: **\*** router is a bad directory
-
- :var :class:`stem.version.Version`,str version: Version of the Tor protocol this router is running
-
- :var int bandwidth: router's claimed bandwidth
- :var int measured_bandwidth: router's measured bandwidth
-
- :var :class:`stem.exit_policy.MicrodescriptorExitPolicy` exitpolicy: router's exitpolicy
-
- :var str microdescriptor_hashes: a list of two-tuples with a list of consensus methods(int) that may produce the digest and a dict with algorithm(str) => digest(str) mappings. algorithm is the hashing algorithm (usually "sha256") that is used to produce digest (the base64 encoding of the hash of the router's microdescriptor with trailing =s omitted).
-
- **\*** attribute is either required when we're parsed with validation or has a default value, others are left as None if undefined
- """
-
- def __init__(self, raw_contents, vote = True, validate = True):
- """
- Parse a router descriptor in a v3 network status document and provide a new
- RouterDescriptor object.
-
- :param str raw_content: router descriptor content to be parsed
- :param bool validate: whether the router descriptor should be validated
- """
-
- super(RouterDescriptor, self).__init__(raw_contents)
-
- self.nickname = None
- self.identity = None
- self.digest = None
- self.publication = None
- self.ip = None
- self.orport = None
- self.dirport = None
-
- self.is_valid = False
- self.is_guard = False
- self.is_named = False
- self.is_unnamed = False
- self.is_running = False
- self.is_stable = False
- self.is_exit = False
- self.is_fast = False
- self.is_authority = False
- self.supports_v2dir = False
- self.supports_v3dir = False
- self.is_hsdir = False
- self.is_badexit = False
- self.is_baddirectory = False
-
- self.version = None
-
- self.bandwidth = None
- self.measured_bandwidth = None
-
- self.exit_policy = None
-
- self.microdescriptor_hashes = []
-
- self._parse(raw_contents, vote, validate)
-
- def _parse(self, raw_content, vote, validate):
- """
- :param dict raw_content: iptor contents to be applied
- :param bool validate: checks the validity of descriptor content if True
-
- :raises: ValueError if an error occures in validation
- """
-
- parser = stem.descriptor.DescriptorParser(raw_content, validate)
- seen_keywords = set()
- peek_check_kw = lambda keyword: keyword == parser.peek_keyword()
-
- r = parser.read_keyword_line("r")
- # r mauer BD7xbfsCFku3+tgybEZsg8Yjhvw itcuKQ6PuPLJ7m/Oi928WjO2j8g 2012-06-22 13:19:32 80.101.105.103 9001 0
- # "r" SP nickname SP identity SP digest SP publication SP IP SP ORPort SP DirPort NL
- seen_keywords.add("r")
- if r:
- values = r.split(" ")
- self.nickname, self.identity, self.digest = values[0], values[1], values[2]
- self.publication = _strptime(" ".join((values[3], values[4])), validate)
- self.ip, self.orport, self.dirport = values[5], int(values[6]), int(values[7])
- if self.dirport == 0: self.dirport = None
- elif validate: raise ValueError("Invalid router descriptor: empty 'r' line" )
-
- while parser.line:
- if peek_check_kw("s"):
- if "s" in seen_keywords: raise ValueError("Invalid router descriptor: 's' line appears twice")
- line = parser.read_keyword_line("s")
- if not line: continue
- seen_keywords.add("s")
- # s Named Running Stable Valid
- #A series of space-separated status flags, in *lexical order*
- flags = line.split(" ")
- flag_map = {
- "Valid": "is_valid",
- "Guard": "is_guard",
- "Named": "is_named",
- "Unnamed": "is_unnamed",
- "Running": "is_running",
- "Stable": "is_stable",
- "Exit": "is_exit",
- "Fast": "is_fast",
- "Authority": "is_authority",
- "V2Dir": "supports_v2dir",
- "V3Dir": "supports_v3dir",
- "HSDir": "is_hsdir",
- "BadExit": "is_badexit",
- "BadDirectory": "is_baddirectory",
- }
- map(lambda flag: setattr(self, flag_map[flag], True), flags)
-
- if self.is_unnamed: self.is_named = False
- elif self.is_named: self.is_unnamed = False
-
- elif peek_check_kw("v"):
- if "v" in seen_keywords: raise ValueError("Invalid router descriptor: 'v' line appears twice")
- line = parser.read_keyword_line("v", True)
- seen_keywords.add("v")
- # v Tor 0.2.2.35
- if line:
- if line.startswith("Tor "):
- self.version = stem.version.Version(line[4:])
- else:
- self.version = line
- elif validate: raise ValueError("Invalid router descriptor: empty 'v' line" )
-
- elif peek_check_kw("w"):
- if "w" in seen_keywords: raise ValueError("Invalid router descriptor: 'w' line appears twice")
- w = parser.read_keyword_line("w", True)
- # "w" SP "Bandwidth=" INT [SP "Measured=" INT] NL
- seen_keywords.add("w")
- if w:
- values = w.split(" ")
- if len(values) <= 2 and len(values) > 0:
- key, value = values[0].split("=")
- if key == "Bandwidth": self.bandwidth = int(value)
- elif validate: raise ValueError("Router descriptor contains invalid 'w' line: expected Bandwidth, read " + key)
-
- if len(values) == 2:
- key, value = values[1].split("=")
- if key == "Measured": self.measured_bandwidth = int(value)
- elif validate: raise ValueError("Router descriptor contains invalid 'w' line: expected Measured, read " + key)
- elif validate: raise ValueError("Router descriptor contains invalid 'w' line")
- elif validate: raise ValueError("Router descriptor contains empty 'w' line")
-
- elif peek_check_kw("p"):
- if "p" in seen_keywords: raise ValueError("Invalid router descriptor: 'p' line appears twice")
- p = parser.read_keyword_line("p", True)
- seen_keywords.add("p")
- # "p" SP ("accept" / "reject") SP PortList NL
- if p:
- self.exit_policy = stem.exit_policy.MicrodescriptorExitPolicy(p)
- #self.exit_policy = p
-
- elif vote and peek_check_kw("m"):
- # microdescriptor hashes
- m = parser.read_keyword_line("m", True)
- methods, digests = m.split(" ", 1)
- method_list = methods.split(",")
- digest_dict = [digest.split("=", 1) for digest in digests.split(" ")]
- self.microdescriptor_hashes.append((method_list, digest_dict))
-
- elif validate:
- raise ValueError("Router descriptor contains unrecognized trailing lines: %s" % parser.line)
-
- else:
- self._unrecognized_lines.append(parser.read_line()) # ignore unrecognized lines if we aren't validating
-
- def get_unrecognized_lines(self):
- """
- Returns any unrecognized lines.
-
- :returns: a list of unrecognized lines
- """
-
- return self._unrecognized_lines
-
diff --git a/test/integ/descriptor/networkstatus.py b/test/integ/descriptor/networkstatus.py
new file mode 100644
index 0000000..e65d960
--- /dev/null
+++ b/test/integ/descriptor/networkstatus.py
@@ -0,0 +1,228 @@
+"""
+Integration tests for stem.descriptor.server_descriptor.
+"""
+
+from __future__ import with_statement
+
+import os
+import resource
+import datetime
+import unittest
+
+import stem.exit_policy
+import stem.version
+import stem.descriptor.networkstatus
+import test.integ.descriptor
+
+def _strptime(string):
+ return datetime.datetime.strptime(string, "%Y-%m-%d %H:%M:%S")
+
+class TestNetworkStatusDocument(unittest.TestCase):
+ def test_metrics_consensus(self):
+ """
+ Checks if consensus documents from Metrics are parsed properly.
+ """
+
+ descriptor_path = test.integ.descriptor.get_resource("metrics_consensus")
+
+ with file(descriptor_path) as descriptor_file:
+ desc = stem.descriptor.parse_file(descriptor_path, descriptor_file)
+
+ router = next(desc)
+ self.assertEquals("sumkledi", router.nickname)
+ self.assertEquals("ABPSI4nNUNC3hKPkBhyzHozozrU", router.identity)
+ self.assertEquals("8mCr8Sl7RF4ENU4jb0FZFA/3do8", router.digest)
+ self.assertEquals(_strptime("2012-07-12 04:01:55"), router.publication)
+ self.assertEquals("178.218.213.229", router.ip)
+ self.assertEquals(80, router.orport)
+ self.assertEquals(None, router.dirport)
+
+ def test_cached_consensus(self):
+ """
+ Parses the cached-consensus file in our data directory.
+ """
+
+ # lengthy test and uneffected by targets, so only run once
+ if test.runner.only_run_once(self, "test_cached_consensus"): return
+
+ descriptor_path = test.runner.get_runner().get_test_dir("cached-consensus")
+
+ if not os.path.exists(descriptor_path):
+ test.runner.skip(self, "(no cached-consensus)")
+
+ if stem.util.system.is_windows():
+ # might hog memory and hang the system
+ # and we aren't checking for memory usage in windows, so, skip.
+ test.runner.skip(self, "(unavailable on windows)")
+
+ count = 0
+ with open(descriptor_path) as descriptor_file:
+ for desc in stem.descriptor.networkstatus.parse_file(descriptor_file):
+ if resource.getrusage(resource.RUSAGE_SELF).ru_maxrss > 100000:
+ # if we're using > 100 MB we should fail
+ self.fail()
+ assert desc.nickname # check that the router has a nickname
+ count += 1
+
+ assert count > 100 # sanity check - assuming atleast 100 relays in the Tor network
+
+ def test_consensus(self):
+ """
+ Checks that consensus documents are properly parsed.
+ """
+
+ descriptor_path = test.integ.descriptor.get_resource("consensus")
+
+ descriptor_file = file(descriptor_path)
+ desc = stem.descriptor.networkstatus.NetworkStatusDocument(descriptor_file.read())
+ descriptor_file.close()
+
+ self.assertEquals(True, desc.validated)
+ self.assertEquals("3", desc.network_status_version)
+ self.assertEquals("consensus", desc.vote_status)
+ self.assertEquals([], desc.consensus_methods)
+ self.assertEquals(None, desc.published)
+ self.assertEquals(12, desc.consensus_method)
+ self.assertEquals(_strptime("2012-07-12 10:00:00"), desc.valid_after)
+ self.assertEquals(_strptime("2012-07-12 11:00:00"), desc.fresh_until)
+ self.assertEquals(_strptime("2012-07-12 13:00:00"), desc.valid_until)
+ self.assertEquals(300, desc.vote_delay)
+ self.assertEquals(300, desc.dist_delay)
+ expected_client_versions = [stem.version.Version(version_string) for version_string in ["0.2.2.35",
+ "0.2.2.36", "0.2.2.37", "0.2.3.10-alpha", "0.2.3.11-alpha", "0.2.3.12-alpha",
+ "0.2.3.13-alpha", "0.2.3.14-alpha", "0.2.3.15-alpha", "0.2.3.16-alpha", "0.2.3.17-beta",
+ "0.2.3.18-rc", "0.2.3.19-rc"]]
+ expected_server_versions = [stem.version.Version(version_string) for version_string in ["0.2.2.35",
+ "0.2.2.36", "0.2.2.37", "0.2.3.10-alpha", "0.2.3.11-alpha", "0.2.3.12-alpha",
+ "0.2.3.13-alpha", "0.2.3.14-alpha", "0.2.3.15-alpha", "0.2.3.16-alpha", "0.2.3.17-beta",
+ "0.2.3.18-rc", "0.2.3.19-rc"]]
+ self.assertEquals(expected_client_versions, desc.client_versions)
+ self.assertEquals(expected_server_versions, desc.server_versions)
+ known_flags = ["Authority", "BadExit", "Exit", "Fast", "Guard", "HSDir", "Named", "Running", "Stable", "Unnamed", "V2Dir", "Valid"]
+ self.assertEquals(known_flags, desc.known_flags)
+ expected_params = {"CircuitPriorityHalflifeMsec": 30000, "bwauthpid": 1}
+ self.assertEquals(expected_params, desc.params)
+ router1 = next(desc.router_descriptors)
+ self.assertEquals("sumkledi", router1.nickname)
+ self.assertEquals("ABPSI4nNUNC3hKPkBhyzHozozrU", router1.identity)
+ self.assertEquals("8mCr8Sl7RF4ENU4jb0FZFA/3do8", router1.digest)
+ self.assertEquals(_strptime("2012-07-12 04:01:55"), router1.publication)
+ self.assertEquals("178.218.213.229", router1.ip)
+ self.assertEquals(80, router1.orport)
+ self.assertEquals(None, router1.dirport)
+
+ self.assertEquals(8, len(desc.directory_authorities))
+ self.assertEquals("tor26", desc.directory_authorities[0].nickname)
+ self.assertEquals("14C131DFC5C6F93646BE72FA1401C02A8DF2E8B4", desc.directory_authorities[0].identity)
+ self.assertEquals("86.59.21.38", desc.directory_authorities[0].address)
+ self.assertEquals("86.59.21.38", desc.directory_authorities[0].ip)
+ self.assertEquals(80, desc.directory_authorities[0].dirport)
+ self.assertEquals(443, desc.directory_authorities[0].orport)
+ self.assertEquals("Peter Palfrader", desc.directory_authorities[0].contact)
+ self.assertEquals(None, desc.directory_authorities[0].legacy_dir_key)
+ self.assertEquals(None, desc.directory_authorities[0].key_certificate)
+ self.assertEquals("0B6D1E9A300B895AA2D0B427F92917B6995C3C1C", desc.directory_authorities[0].vote_digest)
+ expected_bandwidth_weights = {
+ "Wbd": 3335, "Wbe": 0, "Wbg": 3536, "Wbm": 10000, "Wdb": 10000, "Web": 10000,
+ "Wed": 3329, "Wee": 10000, "Weg": 3329, "Wem": 10000, "Wgb": 10000, "Wgd": 3335,
+ "Wgg": 6464, "Wgm": 6464, "Wmb": 10000, "Wmd": 3335, "Wme": 0, "Wmg": 3536, "Wmm": 10000
+ }
+ self.assertEquals(expected_bandwidth_weights, desc.bandwidth_weights)
+
+ expected_signature = """HFXB4497LzESysYJ/4jJY83E5vLjhv+igIxD9LU6lf6ftkGeF+lNmIAIEKaMts8H
+mfWcW0b+jsrXcJoCxV5IrwCDF3u1aC3diwZY6yiG186pwWbOwE41188XI2DeYPwE
+I/TJmV928na7RLZe2mGHCAW3VQOvV+QkCfj05VZ8CsY="""
+ self.assertEquals(8, len(desc.directory_signatures))
+ self.assertEquals("14C131DFC5C6F93646BE72FA1401C02A8DF2E8B4", desc.directory_signatures[0].identity)
+ self.assertEquals("BF112F1C6D5543CFD0A32215ACABD4197B5279AD", desc.directory_signatures[0].key_digest)
+ self.assertEquals(expected_signature, desc.directory_signatures[0].signature)
+
+ def test_vote(self):
+ """
+ Checks that vote documents are properly parsed.
+ """
+
+ descriptor_path = test.integ.descriptor.get_resource("vote")
+
+ descriptor_file = file(descriptor_path)
+ desc = stem.descriptor.networkstatus.NetworkStatusDocument(descriptor_file.read())
+ descriptor_file.close()
+
+ self.assertEquals(True, desc.validated)
+ self.assertEquals("3", desc.network_status_version)
+ self.assertEquals("vote", desc.vote_status)
+ self.assertEquals(range(1, 13), desc.consensus_methods)
+ self.assertEquals(_strptime("2012-07-11 23:50:01"), desc.published)
+ self.assertEquals(None, desc.consensus_method)
+ self.assertEquals(_strptime("2012-07-12 00:00:00"), desc.valid_after)
+ self.assertEquals(_strptime("2012-07-12 01:00:00"), desc.fresh_until)
+ self.assertEquals(_strptime("2012-07-12 03:00:00"), desc.valid_until)
+ self.assertEquals(300, desc.vote_delay)
+ self.assertEquals(300, desc.dist_delay)
+ self.assertEquals([], desc.client_versions)
+ self.assertEquals([], desc.server_versions)
+ known_flags = ["Authority", "BadExit", "Exit", "Fast", "Guard", "HSDir", "Running", "Stable", "V2Dir", "Valid"]
+ self.assertEquals(known_flags, desc.known_flags)
+ expected_params = {"CircuitPriorityHalflifeMsec": 30000, "bwauthpid": 1}
+ self.assertEquals(expected_params, desc.params)
+ router1 = next(desc.router_descriptors)
+ self.assertEquals("sumkledi", router1.nickname)
+ self.assertEquals("ABPSI4nNUNC3hKPkBhyzHozozrU", router1.identity)
+ self.assertEquals("B5n4BiALAF8B5AqafxohyYiuj7E", router1.digest)
+ self.assertEquals(_strptime("2012-07-11 04:22:53"), router1.publication)
+ self.assertEquals("178.218.213.229", router1.ip)
+ self.assertEquals(80, router1.orport)
+ self.assertEquals(None, router1.dirport)
+
+ self.assertEquals(1, len(desc.directory_authorities))
+ self.assertEquals("turtles", desc.directory_authorities[0].nickname)
+ self.assertEquals("27B6B5996C426270A5C95488AA5BCEB6BCC86956", desc.directory_authorities[0].identity)
+ self.assertEquals("76.73.17.194", desc.directory_authorities[0].address)
+ self.assertEquals("76.73.17.194", desc.directory_authorities[0].ip)
+ self.assertEquals(9030, desc.directory_authorities[0].dirport)
+ self.assertEquals(9090, desc.directory_authorities[0].orport)
+ self.assertEquals("Mike Perry <email>", desc.directory_authorities[0].contact)
+ self.assertEquals(None, desc.directory_authorities[0].legacy_dir_key)
+
+ expected_identity_key = """MIIBigKCAYEA6uSmsoxj2MiJ3qyZq0qYXlRoG8o82SNqg+22m+t1c7MlQOZWPJYn
+XeMcBCt8xrTeIt2ZI+Q/Kt2QJSeD9WZRevTKk/kn5Tg2+xXPogalUU47y5tUohGz
++Q8+CxtRSXpDxBHL2P8rLHvGrI69wbNHGoQkce/7gJy9vw5Ie2qzbyXk1NG6V8Fb
+pr6A885vHo6TbhUnolz2Wqt/kN+UorjLkN2H3fV+iGcQFv42SyHYGDLa0WwL3PJJ
+r/veu36S3VaHBrfhutfioi+d3d4Ya0bKwiWi5Lm2CHuuRTgMpHLU9vlci8Hunuxq
+HsULe2oMsr4VEic7sW5SPC5Obpx6hStHdNv1GxoSEm3/vIuPM8pINpU5ZYAyH9yO
+Ef22ZHeiVMMKmpV9TtFyiFqvlI6GpQn3mNbsQqF1y3XCA3Q4vlRAkpgJVUSvTxFP
+2bNDobOyVCpCM/rwxU1+RCNY5MFJ/+oktUY+0ydvTen3gFdZdgNqCYjKPLfBNm9m
+RGL7jZunMUNvAgMBAAE="""
+ expected_signing_key = """MIGJAoGBAJ5itcJRYNEM3Qf1OVWLRkwjqf84oXPc2ZusaJ5zOe7TVvBMra9GNyc0
+NM9y6zVkHCAePAjr4KbW/8P1olA6FUE2LV9bozaU1jFf6K8B2OELKs5FUEW+n+ic
+GM0x6MhngyXonWOcKt5Gj+mAu5lrno9tpNbPkz2Utr/Pi0nsDhWlAgMBAAE="""
+ expected_key_crosscert = """RHYImGTwg36wmEdAn7qaRg2sAfql7ZCtPIL/O3lU5OIdXXp0tNn/K00Bamqohjk+
+Tz4FKsKXGDlbGv67PQcZPOK6NF0GRkNh4pk89prrDO4XwtEn7rkHHdBH6/qQ7IRG
+GdDZHtZ1a69oFZvPWD3hUaB50xeIe7GoKdKIfdNNJ+8="""
+ expected_key_certification = """fasWOGyUZ3iMCYpDfJ+0JcMiTH25sXPWzvlHorEOyOMbaMqRYpZU4GHzt1jLgdl6
+AAoR6KdamsLg5VE8xzst48a4UFuzHFlklZ5O8om2rcvDd5DhSnWWYZnYJecqB+bo
+dNisPmaIVSAWb29U8BpNRj4GMC9KAgGYUj8aE/KtutAeEekFfFEHTfWZ2fFp4j3m
+9rY8FWraqyiF+Emq1T8pAAgMQ+79R3oZxq0TXS42Z4Anhms735ccauKhI3pDKjbl
+tD5vAzIHOyjAOXj7a6jY/GrnaBNuJ4qe/4Hf9UmzK/jKKwG95BPJtPTT4LoFwEB0
+KG2OUeQUNoCck4nDpsZwFqPlrWCHcHfTV2iDYFV1HQWDTtZz/qf+GtB8NXsq+I1w
+brADmvReM2BD6p/13h0QURCI5hq7ZYlIKcKrBa0jn1d9cduULl7vgKsRCJDls/ID
+emBZ6pUxMpBmV0v+PrA3v9w4DlE7GHAq61FF/zju2kpqj6MInbEvI/E+e438sWsL"""
+ self.assertEquals("3", desc.directory_authorities[0].key_certificate.key_certificate_version)
+ self.assertEquals("27B6B5996C426270A5C95488AA5BCEB6BCC86956", desc.directory_authorities[0].key_certificate.fingerprint)
+ self.assertEquals(_strptime("2011-11-28 21:51:04"), desc.directory_authorities[0].key_certificate.published)
+ self.assertEquals(_strptime("2012-11-28 21:51:04"), desc.directory_authorities[0].key_certificate.expires)
+ self.assertEquals(expected_identity_key, desc.directory_authorities[0].key_certificate.identity_key)
+ self.assertEquals(expected_signing_key, desc.directory_authorities[0].key_certificate.signing_key)
+ self.assertEquals(expected_key_crosscert, desc.directory_authorities[0].key_certificate.crosscert)
+ self.assertEquals(expected_key_certification, desc.directory_authorities[0].key_certificate.certification)
+ self.assertEquals(None, desc.directory_authorities[0].vote_digest)
+ self.assertEquals({}, desc.bandwidth_weights)
+
+ expected_signature = """fskXN84wB3mXfo+yKGSt0AcDaaPuU3NwMR3ROxWgLN0KjAaVi2eV9PkPCsQkcgw3
+JZ/1HL9sHyZfo6bwaC6YSM9PNiiY6L7rnGpS7UkHiFI+M96VCMorvjm5YPs3FioJ
+DnN5aFtYKiTc19qIC7Nmo+afPdDEf0MlJvEOP5EWl3w="""
+ self.assertEquals(1, len(desc.directory_signatures))
+ self.assertEquals("27B6B5996C426270A5C95488AA5BCEB6BCC86956", desc.directory_signatures[0].identity)
+ self.assertEquals("D5C30C15BB3F1DA27669C2D88439939E8F418FCF", desc.directory_signatures[0].key_digest)
+ self.assertEquals(expected_signature, desc.directory_signatures[0].signature)
+
diff --git a/test/integ/descriptor/networkstatus_descriptor.py b/test/integ/descriptor/networkstatus_descriptor.py
deleted file mode 100644
index 46019ea..0000000
--- a/test/integ/descriptor/networkstatus_descriptor.py
+++ /dev/null
@@ -1,228 +0,0 @@
-"""
-Integration tests for stem.descriptor.server_descriptor.
-"""
-
-from __future__ import with_statement
-
-import os
-import resource
-import datetime
-import unittest
-
-import stem.exit_policy
-import stem.version
-import stem.descriptor.networkstatus_descriptor
-import test.integ.descriptor
-
-def _strptime(string):
- return datetime.datetime.strptime(string, "%Y-%m-%d %H:%M:%S")
-
-class TestNetworkStatusDocument(unittest.TestCase):
- def test_metrics_consensus(self):
- """
- Checks if consensus documents from Metrics are parsed properly.
- """
-
- descriptor_path = test.integ.descriptor.get_resource("metrics_consensus")
-
- with file(descriptor_path) as descriptor_file:
- desc = stem.descriptor.parse_file(descriptor_path, descriptor_file)
-
- router = next(desc)
- self.assertEquals("sumkledi", router.nickname)
- self.assertEquals("ABPSI4nNUNC3hKPkBhyzHozozrU", router.identity)
- self.assertEquals("8mCr8Sl7RF4ENU4jb0FZFA/3do8", router.digest)
- self.assertEquals(_strptime("2012-07-12 04:01:55"), router.publication)
- self.assertEquals("178.218.213.229", router.ip)
- self.assertEquals(80, router.orport)
- self.assertEquals(None, router.dirport)
-
- def test_cached_consensus(self):
- """
- Parses the cached-consensus file in our data directory.
- """
-
- # lengthy test and uneffected by targets, so only run once
- if test.runner.only_run_once(self, "test_cached_consensus"): return
-
- descriptor_path = test.runner.get_runner().get_test_dir("cached-consensus")
-
- if not os.path.exists(descriptor_path):
- test.runner.skip(self, "(no cached-consensus)")
-
- if stem.util.system.is_windows():
- # might hog memory and hang the system
- # and we aren't checking for memory usage in windows, so, skip.
- test.runner.skip(self, "(unavailable on windows)")
-
- count = 0
- with open(descriptor_path) as descriptor_file:
- for desc in stem.descriptor.networkstatus_descriptor.parse_file(descriptor_file):
- if resource.getrusage(resource.RUSAGE_SELF).ru_maxrss > 100000:
- # if we're using > 100 MB we should fail
- self.fail()
- assert desc.nickname # check that the router has a nickname
- count += 1
-
- assert count > 100 # sanity check - assuming atleast 100 relays in the Tor network
-
- def test_consensus(self):
- """
- Checks that consensus documents are properly parsed.
- """
-
- descriptor_path = test.integ.descriptor.get_resource("consensus")
-
- descriptor_file = file(descriptor_path)
- desc = stem.descriptor.networkstatus_descriptor.NetworkStatusDocument(descriptor_file.read())
- descriptor_file.close()
-
- self.assertEquals(True, desc.validated)
- self.assertEquals("3", desc.network_status_version)
- self.assertEquals("consensus", desc.vote_status)
- self.assertEquals([], desc.consensus_methods)
- self.assertEquals(None, desc.published)
- self.assertEquals(12, desc.consensus_method)
- self.assertEquals(_strptime("2012-07-12 10:00:00"), desc.valid_after)
- self.assertEquals(_strptime("2012-07-12 11:00:00"), desc.fresh_until)
- self.assertEquals(_strptime("2012-07-12 13:00:00"), desc.valid_until)
- self.assertEquals(300, desc.vote_delay)
- self.assertEquals(300, desc.dist_delay)
- expected_client_versions = [stem.version.Version(version_string) for version_string in ["0.2.2.35",
- "0.2.2.36", "0.2.2.37", "0.2.3.10-alpha", "0.2.3.11-alpha", "0.2.3.12-alpha",
- "0.2.3.13-alpha", "0.2.3.14-alpha", "0.2.3.15-alpha", "0.2.3.16-alpha", "0.2.3.17-beta",
- "0.2.3.18-rc", "0.2.3.19-rc"]]
- expected_server_versions = [stem.version.Version(version_string) for version_string in ["0.2.2.35",
- "0.2.2.36", "0.2.2.37", "0.2.3.10-alpha", "0.2.3.11-alpha", "0.2.3.12-alpha",
- "0.2.3.13-alpha", "0.2.3.14-alpha", "0.2.3.15-alpha", "0.2.3.16-alpha", "0.2.3.17-beta",
- "0.2.3.18-rc", "0.2.3.19-rc"]]
- self.assertEquals(expected_client_versions, desc.client_versions)
- self.assertEquals(expected_server_versions, desc.server_versions)
- known_flags = ["Authority", "BadExit", "Exit", "Fast", "Guard", "HSDir", "Named", "Running", "Stable", "Unnamed", "V2Dir", "Valid"]
- self.assertEquals(known_flags, desc.known_flags)
- expected_params = {"CircuitPriorityHalflifeMsec": 30000, "bwauthpid": 1}
- self.assertEquals(expected_params, desc.params)
- router1 = next(desc.router_descriptors)
- self.assertEquals("sumkledi", router1.nickname)
- self.assertEquals("ABPSI4nNUNC3hKPkBhyzHozozrU", router1.identity)
- self.assertEquals("8mCr8Sl7RF4ENU4jb0FZFA/3do8", router1.digest)
- self.assertEquals(_strptime("2012-07-12 04:01:55"), router1.publication)
- self.assertEquals("178.218.213.229", router1.ip)
- self.assertEquals(80, router1.orport)
- self.assertEquals(None, router1.dirport)
-
- self.assertEquals(8, len(desc.directory_authorities))
- self.assertEquals("tor26", desc.directory_authorities[0].nickname)
- self.assertEquals("14C131DFC5C6F93646BE72FA1401C02A8DF2E8B4", desc.directory_authorities[0].identity)
- self.assertEquals("86.59.21.38", desc.directory_authorities[0].address)
- self.assertEquals("86.59.21.38", desc.directory_authorities[0].ip)
- self.assertEquals(80, desc.directory_authorities[0].dirport)
- self.assertEquals(443, desc.directory_authorities[0].orport)
- self.assertEquals("Peter Palfrader", desc.directory_authorities[0].contact)
- self.assertEquals(None, desc.directory_authorities[0].legacy_dir_key)
- self.assertEquals(None, desc.directory_authorities[0].key_certificate)
- self.assertEquals("0B6D1E9A300B895AA2D0B427F92917B6995C3C1C", desc.directory_authorities[0].vote_digest)
- expected_bandwidth_weights = {
- "Wbd": 3335, "Wbe": 0, "Wbg": 3536, "Wbm": 10000, "Wdb": 10000, "Web": 10000,
- "Wed": 3329, "Wee": 10000, "Weg": 3329, "Wem": 10000, "Wgb": 10000, "Wgd": 3335,
- "Wgg": 6464, "Wgm": 6464, "Wmb": 10000, "Wmd": 3335, "Wme": 0, "Wmg": 3536, "Wmm": 10000
- }
- self.assertEquals(expected_bandwidth_weights, desc.bandwidth_weights)
-
- expected_signature = """HFXB4497LzESysYJ/4jJY83E5vLjhv+igIxD9LU6lf6ftkGeF+lNmIAIEKaMts8H
-mfWcW0b+jsrXcJoCxV5IrwCDF3u1aC3diwZY6yiG186pwWbOwE41188XI2DeYPwE
-I/TJmV928na7RLZe2mGHCAW3VQOvV+QkCfj05VZ8CsY="""
- self.assertEquals(8, len(desc.directory_signatures))
- self.assertEquals("14C131DFC5C6F93646BE72FA1401C02A8DF2E8B4", desc.directory_signatures[0].identity)
- self.assertEquals("BF112F1C6D5543CFD0A32215ACABD4197B5279AD", desc.directory_signatures[0].key_digest)
- self.assertEquals(expected_signature, desc.directory_signatures[0].signature)
-
- def test_vote(self):
- """
- Checks that vote documents are properly parsed.
- """
-
- descriptor_path = test.integ.descriptor.get_resource("vote")
-
- descriptor_file = file(descriptor_path)
- desc = stem.descriptor.networkstatus_descriptor.NetworkStatusDocument(descriptor_file.read())
- descriptor_file.close()
-
- self.assertEquals(True, desc.validated)
- self.assertEquals("3", desc.network_status_version)
- self.assertEquals("vote", desc.vote_status)
- self.assertEquals(range(1, 13), desc.consensus_methods)
- self.assertEquals(_strptime("2012-07-11 23:50:01"), desc.published)
- self.assertEquals(None, desc.consensus_method)
- self.assertEquals(_strptime("2012-07-12 00:00:00"), desc.valid_after)
- self.assertEquals(_strptime("2012-07-12 01:00:00"), desc.fresh_until)
- self.assertEquals(_strptime("2012-07-12 03:00:00"), desc.valid_until)
- self.assertEquals(300, desc.vote_delay)
- self.assertEquals(300, desc.dist_delay)
- self.assertEquals([], desc.client_versions)
- self.assertEquals([], desc.server_versions)
- known_flags = ["Authority", "BadExit", "Exit", "Fast", "Guard", "HSDir", "Running", "Stable", "V2Dir", "Valid"]
- self.assertEquals(known_flags, desc.known_flags)
- expected_params = {"CircuitPriorityHalflifeMsec": 30000, "bwauthpid": 1}
- self.assertEquals(expected_params, desc.params)
- router1 = next(desc.router_descriptors)
- self.assertEquals("sumkledi", router1.nickname)
- self.assertEquals("ABPSI4nNUNC3hKPkBhyzHozozrU", router1.identity)
- self.assertEquals("B5n4BiALAF8B5AqafxohyYiuj7E", router1.digest)
- self.assertEquals(_strptime("2012-07-11 04:22:53"), router1.publication)
- self.assertEquals("178.218.213.229", router1.ip)
- self.assertEquals(80, router1.orport)
- self.assertEquals(None, router1.dirport)
-
- self.assertEquals(1, len(desc.directory_authorities))
- self.assertEquals("turtles", desc.directory_authorities[0].nickname)
- self.assertEquals("27B6B5996C426270A5C95488AA5BCEB6BCC86956", desc.directory_authorities[0].identity)
- self.assertEquals("76.73.17.194", desc.directory_authorities[0].address)
- self.assertEquals("76.73.17.194", desc.directory_authorities[0].ip)
- self.assertEquals(9030, desc.directory_authorities[0].dirport)
- self.assertEquals(9090, desc.directory_authorities[0].orport)
- self.assertEquals("Mike Perry <email>", desc.directory_authorities[0].contact)
- self.assertEquals(None, desc.directory_authorities[0].legacy_dir_key)
-
- expected_identity_key = """MIIBigKCAYEA6uSmsoxj2MiJ3qyZq0qYXlRoG8o82SNqg+22m+t1c7MlQOZWPJYn
-XeMcBCt8xrTeIt2ZI+Q/Kt2QJSeD9WZRevTKk/kn5Tg2+xXPogalUU47y5tUohGz
-+Q8+CxtRSXpDxBHL2P8rLHvGrI69wbNHGoQkce/7gJy9vw5Ie2qzbyXk1NG6V8Fb
-pr6A885vHo6TbhUnolz2Wqt/kN+UorjLkN2H3fV+iGcQFv42SyHYGDLa0WwL3PJJ
-r/veu36S3VaHBrfhutfioi+d3d4Ya0bKwiWi5Lm2CHuuRTgMpHLU9vlci8Hunuxq
-HsULe2oMsr4VEic7sW5SPC5Obpx6hStHdNv1GxoSEm3/vIuPM8pINpU5ZYAyH9yO
-Ef22ZHeiVMMKmpV9TtFyiFqvlI6GpQn3mNbsQqF1y3XCA3Q4vlRAkpgJVUSvTxFP
-2bNDobOyVCpCM/rwxU1+RCNY5MFJ/+oktUY+0ydvTen3gFdZdgNqCYjKPLfBNm9m
-RGL7jZunMUNvAgMBAAE="""
- expected_signing_key = """MIGJAoGBAJ5itcJRYNEM3Qf1OVWLRkwjqf84oXPc2ZusaJ5zOe7TVvBMra9GNyc0
-NM9y6zVkHCAePAjr4KbW/8P1olA6FUE2LV9bozaU1jFf6K8B2OELKs5FUEW+n+ic
-GM0x6MhngyXonWOcKt5Gj+mAu5lrno9tpNbPkz2Utr/Pi0nsDhWlAgMBAAE="""
- expected_key_crosscert = """RHYImGTwg36wmEdAn7qaRg2sAfql7ZCtPIL/O3lU5OIdXXp0tNn/K00Bamqohjk+
-Tz4FKsKXGDlbGv67PQcZPOK6NF0GRkNh4pk89prrDO4XwtEn7rkHHdBH6/qQ7IRG
-GdDZHtZ1a69oFZvPWD3hUaB50xeIe7GoKdKIfdNNJ+8="""
- expected_key_certification = """fasWOGyUZ3iMCYpDfJ+0JcMiTH25sXPWzvlHorEOyOMbaMqRYpZU4GHzt1jLgdl6
-AAoR6KdamsLg5VE8xzst48a4UFuzHFlklZ5O8om2rcvDd5DhSnWWYZnYJecqB+bo
-dNisPmaIVSAWb29U8BpNRj4GMC9KAgGYUj8aE/KtutAeEekFfFEHTfWZ2fFp4j3m
-9rY8FWraqyiF+Emq1T8pAAgMQ+79R3oZxq0TXS42Z4Anhms735ccauKhI3pDKjbl
-tD5vAzIHOyjAOXj7a6jY/GrnaBNuJ4qe/4Hf9UmzK/jKKwG95BPJtPTT4LoFwEB0
-KG2OUeQUNoCck4nDpsZwFqPlrWCHcHfTV2iDYFV1HQWDTtZz/qf+GtB8NXsq+I1w
-brADmvReM2BD6p/13h0QURCI5hq7ZYlIKcKrBa0jn1d9cduULl7vgKsRCJDls/ID
-emBZ6pUxMpBmV0v+PrA3v9w4DlE7GHAq61FF/zju2kpqj6MInbEvI/E+e438sWsL"""
- self.assertEquals("3", desc.directory_authorities[0].key_certificate.key_certificate_version)
- self.assertEquals("27B6B5996C426270A5C95488AA5BCEB6BCC86956", desc.directory_authorities[0].key_certificate.fingerprint)
- self.assertEquals(_strptime("2011-11-28 21:51:04"), desc.directory_authorities[0].key_certificate.published)
- self.assertEquals(_strptime("2012-11-28 21:51:04"), desc.directory_authorities[0].key_certificate.expires)
- self.assertEquals(expected_identity_key, desc.directory_authorities[0].key_certificate.identity_key)
- self.assertEquals(expected_signing_key, desc.directory_authorities[0].key_certificate.signing_key)
- self.assertEquals(expected_key_crosscert, desc.directory_authorities[0].key_certificate.crosscert)
- self.assertEquals(expected_key_certification, desc.directory_authorities[0].key_certificate.certification)
- self.assertEquals(None, desc.directory_authorities[0].vote_digest)
- self.assertEquals({}, desc.bandwidth_weights)
-
- expected_signature = """fskXN84wB3mXfo+yKGSt0AcDaaPuU3NwMR3ROxWgLN0KjAaVi2eV9PkPCsQkcgw3
-JZ/1HL9sHyZfo6bwaC6YSM9PNiiY6L7rnGpS7UkHiFI+M96VCMorvjm5YPs3FioJ
-DnN5aFtYKiTc19qIC7Nmo+afPdDEf0MlJvEOP5EWl3w="""
- self.assertEquals(1, len(desc.directory_signatures))
- self.assertEquals("27B6B5996C426270A5C95488AA5BCEB6BCC86956", desc.directory_signatures[0].identity)
- self.assertEquals("D5C30C15BB3F1DA27669C2D88439939E8F418FCF", desc.directory_signatures[0].key_digest)
- self.assertEquals(expected_signature, desc.directory_signatures[0].signature)
-
_______________________________________________
tor-commits mailing list
tor-commits@xxxxxxxxxxxxxxxxxxxx
https://lists.torproject.org/cgi-bin/mailman/listinfo/tor-commits