commit 466725e2ea478420fddd4a8bc6d6e199d5d31b8e Author: Karsten Loesing karsten.loesing@gmx.net Date: Sat May 19 19:30:28 2012 +0200
Parse v1 directories and contained server descriptors. --- .../torproject/descriptor/NetworkStatusEntry.java | 2 + src/org/torproject/descriptor/RelayDirectory.java | 41 ++ .../torproject/descriptor/RouterStatusEntry.java | 20 + .../torproject/descriptor/ServerDescriptor.java | 4 +- .../descriptor/impl/BandwidthHistoryImpl.java | 38 +- .../torproject/descriptor/impl/DescriptorImpl.java | 5 + .../descriptor/impl/RelayDirectoryImpl.java | 513 ++++++++++++++++++++ .../descriptor/impl/RouterStatusEntryImpl.java | 37 ++ .../descriptor/impl/ServerDescriptorImpl.java | 28 +- 9 files changed, 671 insertions(+), 17 deletions(-)
diff --git a/src/org/torproject/descriptor/NetworkStatusEntry.java b/src/org/torproject/descriptor/NetworkStatusEntry.java index ba5939c..3bda176 100644 --- a/src/org/torproject/descriptor/NetworkStatusEntry.java +++ b/src/org/torproject/descriptor/NetworkStatusEntry.java @@ -5,6 +5,8 @@ package org.torproject.descriptor; import java.util.List; import java.util.SortedSet;
+/* Status entry contained in a network status with version 2 or higher or + * in a bridge network status. */ public interface NetworkStatusEntry {
/* Return the raw status entry bytes. */ diff --git a/src/org/torproject/descriptor/RelayDirectory.java b/src/org/torproject/descriptor/RelayDirectory.java new file mode 100644 index 0000000..b8a9472 --- /dev/null +++ b/src/org/torproject/descriptor/RelayDirectory.java @@ -0,0 +1,41 @@ +/* Copyright 2012 The Tor Project + * See LICENSE for licensing information */ +package org.torproject.descriptor; + +import java.util.List; + +/* Contains a v1 signed directory. */ +public interface RelayDirectory extends Descriptor { + + /* Return the published time in milliseconds. */ + public long getPublishedMillis(); + + /* Return the directory signing key digest. */ + public String getDirSigningKey(); + + /* Return recommended software versions or null if the directory doesn't + * list recommended software. */ + public List<String> getRecommendedSoftware(); + + /* Return the directory signature. */ + public String getDirectorySignature(); + + /* Return router status entries, one for each contained relay. */ + public List<RouterStatusEntry> getRouterStatusEntries(); + + /* Return a list of server descriptors contained in the signed + * directory. */ + public List<ServerDescriptor> getServerDescriptors(); + + /* Return a (very likely empty) list of exceptions from parsing the + * contained server descriptors. */ + public List<Exception> getServerDescriptorParseExceptions(); + + /* Return the directory nickname. */ + public String getNickname(); + + /* Return the directory digest that the directory authority used to sign + * the directory. */ + public String getDirectoryDigest(); +} + diff --git a/src/org/torproject/descriptor/RouterStatusEntry.java b/src/org/torproject/descriptor/RouterStatusEntry.java new file mode 100644 index 0000000..6652e94 --- /dev/null +++ b/src/org/torproject/descriptor/RouterStatusEntry.java @@ -0,0 +1,20 @@ +/* Copyright 2012 The Tor Project + * See LICENSE for licensing information */ +package org.torproject.descriptor; + +/* Status entry contained in a v1 signed directory. */ +public interface RouterStatusEntry { + + /* Return the relay nickname, or null if the relay is unverified. */ + public String getNickname(); + + /* Return the relay fingerprint. */ + public String getFingerprint(); + + /* Return whether the relay is verified. */ + public boolean isVerified(); + + /* Return whether the relay is live. */ + public boolean isLive(); +} + diff --git a/src/org/torproject/descriptor/ServerDescriptor.java b/src/org/torproject/descriptor/ServerDescriptor.java index bcc4913..a7f76c7 100644 --- a/src/org/torproject/descriptor/ServerDescriptor.java +++ b/src/org/torproject/descriptor/ServerDescriptor.java @@ -40,7 +40,9 @@ public interface ServerDescriptor extends Descriptor { public int getBandwidthBurst();
/* Return the observed bandwidth in bytes per second as an estimate of - * the capacity that the relay can handle. */ + * the capacity that the relay can handle, or -1 if the descriptor + * doesn't contain an observed bandwidth value (which is the case for + * Tor versions 0.0.8 or older). */ public int getBandwidthObserved();
/* Return the platform string containing the Tor software version and diff --git a/src/org/torproject/descriptor/impl/BandwidthHistoryImpl.java b/src/org/torproject/descriptor/impl/BandwidthHistoryImpl.java index 56ae512..65def52 100644 --- a/src/org/torproject/descriptor/impl/BandwidthHistoryImpl.java +++ b/src/org/torproject/descriptor/impl/BandwidthHistoryImpl.java @@ -12,32 +12,42 @@ public class BandwidthHistoryImpl implements BandwidthHistory { protected BandwidthHistoryImpl(String line, String lineNoOpt, String[] partsNoOpt) throws DescriptorParseException { boolean isValid = false; - if (partsNoOpt.length >= 5) { + this.line = line; + if (lineNoOpt.startsWith("read-history ")) { + lineNoOpt = "read-history " + + lineNoOpt.substring("read-history ".length()); + partsNoOpt = lineNoOpt.split(" "); + } + if (partsNoOpt.length == 5 || partsNoOpt.length == 6) { try { - this.line = line; - if (lineNoOpt.startsWith("read-history ")) { - lineNoOpt = "read-history " - + lineNoOpt.substring("read-history ".length()); - partsNoOpt = lineNoOpt.split(" "); - } this.historyEndMillis = ParseHelper.parseTimestampAtIndex(line, partsNoOpt, 1, 2); if (partsNoOpt[3].startsWith("(") && - partsNoOpt[4].equals("s)")) { + partsNoOpt[4].startsWith("s)")) { this.intervalLength = Long.parseLong(partsNoOpt[3]. substring(1)); if (this.intervalLength <= 0L) { throw new DescriptorParseException("Only positive interval " + "lengths are allowed in line '" + line + "'."); } - if (partsNoOpt.length > 6) { - /* Invalid line, handle below. */ - } else if (partsNoOpt.length == 5) { - /* No bandwidth values to parse. */ + String[] values = null; + if (partsNoOpt.length == 5 && + partsNoOpt[4].equals("s)")) { + /* There are no bandwidth values to parse. */ isValid = true; - } else { + } else if (partsNoOpt.length == 6) { + /* There are bandwidth values to parse. */ + values = partsNoOpt[5].split(",", -1); + } else if (partsNoOpt[4].length() > 2) { + /* There are bandwidth values to parse, but there is no space + * between "s)" and "0,0,0,0". Very old Tor versions around + * Tor 0.0.8 wrote such history lines, and even though + * dir-spec.txt implies a space here, the old format isn't + * totally broken. Let's pretend there's a space. */ + values = partsNoOpt[4].substring(2).split(",", -1); + } + if (values != null) { long endMillis = this.historyEndMillis; - String[] values = partsNoOpt[5].split(",", -1); for (int i = values.length - 1; i >= 0; i--) { long bandwidthValue = Long.parseLong(values[i]); if (bandwidthValue < 0L) { diff --git a/src/org/torproject/descriptor/impl/DescriptorImpl.java b/src/org/torproject/descriptor/impl/DescriptorImpl.java index afaacc7..27e5153 100644 --- a/src/org/torproject/descriptor/impl/DescriptorImpl.java +++ b/src/org/torproject/descriptor/impl/DescriptorImpl.java @@ -78,6 +78,11 @@ public abstract class DescriptorImpl implements Descriptor { firstLines.contains("\nnetwork-status-version 2\n")) { parsedDescriptors.add(new RelayNetworkStatusImpl(rawDescriptorBytes, failUnrecognizedDescriptorLines)); + } else if (firstLines.startsWith("@type directory 1.0\n") || + firstLines.startsWith("signed-directory\n") || + firstLines.contains("\nsigned-directory\n")) { + parsedDescriptors.add(new RelayDirectoryImpl(rawDescriptorBytes, + failUnrecognizedDescriptorLines)); } else { throw new DescriptorParseException("Could not detect descriptor " + "type in descriptor starting with '" + firstLines + "'."); diff --git a/src/org/torproject/descriptor/impl/RelayDirectoryImpl.java b/src/org/torproject/descriptor/impl/RelayDirectoryImpl.java new file mode 100644 index 0000000..03d727e --- /dev/null +++ b/src/org/torproject/descriptor/impl/RelayDirectoryImpl.java @@ -0,0 +1,513 @@ +/* Copyright 2012 The Tor Project + * See LICENSE for licensing information */ +package org.torproject.descriptor.impl; + +import java.io.UnsupportedEncodingException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashSet; +import java.util.List; +import java.util.Scanner; +import java.util.Set; + +import org.apache.commons.codec.digest.DigestUtils; +import org.torproject.descriptor.RelayDirectory; +import org.torproject.descriptor.RouterStatusEntry; +import org.torproject.descriptor.ServerDescriptor; + +/* TODO Write unit tests. */ + +public class RelayDirectoryImpl extends DescriptorImpl + implements RelayDirectory { + + protected static List<RelayDirectory> parseDirectories( + byte[] directoriesBytes, boolean failUnrecognizedDescriptorLines) + throws DescriptorParseException { + List<RelayDirectory> parsedDirectories = + new ArrayList<RelayDirectory>(); + List<byte[]> splitDirectoriesBytes = + DescriptorImpl.splitRawDescriptorBytes(directoriesBytes, + "signed-directory\n"); + for (byte[] directoryBytes : splitDirectoriesBytes) { + RelayDirectory parsedDirectory = + new RelayDirectoryImpl(directoryBytes, + failUnrecognizedDescriptorLines); + parsedDirectories.add(parsedDirectory); + } + return parsedDirectories; + } + + protected RelayDirectoryImpl(byte[] directoryBytes, + boolean failUnrecognizedDescriptorLines) + throws DescriptorParseException { + super(directoryBytes, failUnrecognizedDescriptorLines, true); + this.splitAndParseParts(rawDescriptorBytes); + this.calculateDigest(); + Set<String> exactlyOnceKeywords = new HashSet<String>(Arrays.asList(( + "signed-directory,recommended-software," + + "directory-signature").split(","))); + this.checkExactlyOnceKeywords(exactlyOnceKeywords); + Set<String> atMostOnceKeywords = new HashSet<String>(Arrays.asList( + "dir-signing-key,running-routers,router-status".split(","))); + this.checkAtMostOnceKeywords(atMostOnceKeywords); + this.checkFirstKeyword("signed-directory"); + } + + private void calculateDigest() throws DescriptorParseException { + try { + String ascii = new String(this.getRawDescriptorBytes(), "US-ASCII"); + String startToken = "signed-directory\n"; + String sigToken = "\ndirectory-signature "; + if (!ascii.contains(sigToken)) { + return; + } + int start = ascii.indexOf(startToken); + int sig = ascii.indexOf(sigToken) + sigToken.length(); + sig = ascii.indexOf("\n", sig) + 1; + if (start >= 0 && sig >= 0 && sig > start) { + byte[] forDigest = new byte[sig - start]; + System.arraycopy(this.getRawDescriptorBytes(), start, + forDigest, 0, sig - start); + this.directoryDigest = DigestUtils.shaHex(forDigest); + } + } catch (UnsupportedEncodingException e) { + /* Handle below. */ + } + if (this.directoryDigest == null) { + throw new DescriptorParseException("Could not calculate v1 " + + "directory digest."); + } + } + + private void splitAndParseParts(byte[] rawDescriptorBytes) + throws DescriptorParseException { + if (this.rawDescriptorBytes.length == 0) { + throw new DescriptorParseException("Descriptor is empty."); + } + String descriptorString = new String(rawDescriptorBytes); + int startIndex = 0; + int firstRouterIndex = this.findFirstIndexOfKeyword(descriptorString, + "router"); + int directorySignatureIndex = this.findFirstIndexOfKeyword( + descriptorString, "directory-signature"); + int endIndex = descriptorString.length(); + if (directorySignatureIndex < 0) { + directorySignatureIndex = endIndex; + } + if (firstRouterIndex < 0) { + firstRouterIndex = directorySignatureIndex; + } + if (firstRouterIndex > startIndex) { + this.parseHeaderBytes(descriptorString, startIndex, + firstRouterIndex); + } + if (directorySignatureIndex > firstRouterIndex) { + this.parseServerDescriptorBytes(descriptorString, firstRouterIndex, + directorySignatureIndex); + } + if (endIndex > directorySignatureIndex) { + this.parseDirectorySignatureBytes(descriptorString, + directorySignatureIndex, endIndex); + } + } + + private int findFirstIndexOfKeyword(String descriptorString, + String keyword) { + if (descriptorString.startsWith(keyword)) { + return 0; + } else if (descriptorString.contains("\n" + keyword + " ")) { + return descriptorString.indexOf("\n" + keyword + " ") + 1; + } else if (descriptorString.contains("\n" + keyword + "\n")) { + return descriptorString.indexOf("\n" + keyword + "\n") + 1; + } else { + return -1; + } + } + + private void parseHeaderBytes(String descriptorString, int start, + int end) throws DescriptorParseException { + byte[] headerBytes = new byte[end - start]; + System.arraycopy(this.rawDescriptorBytes, start, + headerBytes, 0, end - start); + this.parseHeader(headerBytes); + } + + private void parseServerDescriptorBytes(String descriptorString, + int start, int end) throws DescriptorParseException { + List<byte[]> splitServerDescriptorBytes = + this.splitByKeyword(descriptorString, "router", start, end); + for (byte[] statusEntryBytes : splitServerDescriptorBytes) { + this.parseServerDescriptor(statusEntryBytes); + } + } + + private void parseDirectorySignatureBytes(String descriptorString, + int start, int end) throws DescriptorParseException { + List<byte[]> splitDirectorySignatureBytes = this.splitByKeyword( + descriptorString, "directory-signature", start, end); + for (byte[] directorySignatureBytes : splitDirectorySignatureBytes) { + this.parseDirectorySignature(directorySignatureBytes); + } + } + + private List<byte[]> splitByKeyword(String descriptorString, + String keyword, int start, int end) { + List<byte[]> splitParts = new ArrayList<byte[]>(); + int from = start; + while (from < end) { + int to = descriptorString.indexOf("\n" + keyword + " ", from); + if (to < 0) { + to = descriptorString.indexOf("\n" + keyword + "\n", from); + } + if (to < 0) { + to = end; + } else { + to += 1; + } + int toNoNewline = to; + while (toNoNewline > from && + descriptorString.charAt(toNoNewline - 1) == '\n') { + toNoNewline--; + } + byte[] part = new byte[toNoNewline - from]; + System.arraycopy(this.rawDescriptorBytes, from, part, 0, + toNoNewline - from); + from = to; + splitParts.add(part); + } + return splitParts; + } + + private void parseHeader(byte[] headerBytes) + throws DescriptorParseException { + Scanner s = new Scanner(new String(headerBytes)).useDelimiter("\n"); + String publishedLine = null, nextCrypto = null, + runningRoutersLine = null, routerStatusLine = null; + StringBuilder crypto = null; + while (s.hasNext()) { + String line = s.next(); + if (line.isEmpty() || line.startsWith("@")) { + continue; + } + String lineNoOpt = line.startsWith("opt ") ? + line.substring("opt ".length()) : line; + String[] partsNoOpt = lineNoOpt.split(" "); + String keyword = partsNoOpt[0]; + if (keyword.equals("signed-directory")) { + this.parseSignedDirectoryLine(line, lineNoOpt, partsNoOpt); + } else if (keyword.equals("published")) { + if (publishedLine != null) { + throw new DescriptorParseException("Keyword 'published' is " + + "contained more than once, but must be contained exactly " + + "once."); + } else { + publishedLine = line; + } + } else if (keyword.equals("dir-signing-key")) { + this.parseDirSigningKeyLine(line, lineNoOpt, partsNoOpt); + nextCrypto = "dir-signing-key"; + } else if (keyword.equals("recommended-software")) { + this.parseRecommendedSoftwareLine(line, lineNoOpt, partsNoOpt); + } else if (keyword.equals("running-routers")) { + runningRoutersLine = line; + } else if (keyword.equals("router-status")) { + routerStatusLine = line; + } else if (line.startsWith("-----BEGIN")) { + crypto = new StringBuilder(); + crypto.append(line + "\n"); + } else if (line.startsWith("-----END")) { + crypto.append(line + "\n"); + String cryptoString = crypto.toString(); + crypto = null; + if (nextCrypto.equals("dir-signing-key") && + this.dirSigningKey == null) { + this.dirSigningKey = cryptoString; + } else { + throw new DescriptorParseException("Unrecognized crypto " + + "block in v1 directory."); + } + nextCrypto = null; + } else if (crypto != null) { + crypto.append(line + "\n"); + } else { + if (this.failUnrecognizedDescriptorLines) { + throw new DescriptorParseException("Unrecognized line '" + + line + "' in v1 directory."); + } else { + if (this.unrecognizedLines == null) { + this.unrecognizedLines = new ArrayList<String>(); + } + this.unrecognizedLines.add(line); + } + } + } + if (publishedLine == null) { + throw new DescriptorParseException("Keyword 'published' is " + + "contained 0 times, but must be contained exactly once."); + } else { + String publishedLineNoOpt = publishedLine.startsWith("opt ") ? + publishedLine.substring("opt ".length()) : publishedLine; + String[] publishedPartsNoOpt = publishedLineNoOpt.split(" "); + this.parsePublishedLine(publishedLine, publishedLineNoOpt, + publishedPartsNoOpt); + } + if (routerStatusLine != null) { + String routerStatusLineNoOpt = routerStatusLine.startsWith("opt ") ? + routerStatusLine.substring("opt ".length()) : routerStatusLine; + String[] routerStatusPartsNoOpt = routerStatusLineNoOpt.split(" "); + this.parseRouterStatusLine(routerStatusLine, routerStatusLineNoOpt, + routerStatusPartsNoOpt); + } else if (runningRoutersLine != null) { + String runningRoutersLineNoOpt = + runningRoutersLine.startsWith("opt ") ? + runningRoutersLine.substring("opt ".length()) : + runningRoutersLine; + String[] runningRoutersPartsNoOpt = + runningRoutersLineNoOpt.split(" "); + this.parseRunningRoutersLine(runningRoutersLine, + runningRoutersLineNoOpt, runningRoutersPartsNoOpt); + } else { + throw new DescriptorParseException("Either running-routers or " + + "router-status line must be given."); + } + } + + protected void parseServerDescriptor(byte[] serverDescriptorBytes) { + try { + ServerDescriptorImpl serverDescriptor = new ServerDescriptorImpl( + serverDescriptorBytes, this.failUnrecognizedDescriptorLines); + this.serverDescriptors.add(serverDescriptor); + } catch (DescriptorParseException e) { + this.serverDescriptorParseExceptions.add(e); + } + } + + private void parseDirectorySignature(byte[] directorySignatureBytes) + throws DescriptorParseException { + Scanner s = new Scanner(new String(directorySignatureBytes)). + useDelimiter("\n"); + String nextCrypto = null; + StringBuilder crypto = null; + while (s.hasNext()) { + String line = s.next(); + String lineNoOpt = line.startsWith("opt ") ? + line.substring("opt ".length()) : line; + String[] partsNoOpt = lineNoOpt.split(" "); + String keyword = partsNoOpt[0]; + if (keyword.equals("directory-signature")) { + this.parseDirectorySignatureLine(line, lineNoOpt, partsNoOpt); + nextCrypto = "directory-signature"; + } else if (line.startsWith("-----BEGIN")) { + crypto = new StringBuilder(); + crypto.append(line + "\n"); + } else if (line.startsWith("-----END")) { + crypto.append(line + "\n"); + String cryptoString = crypto.toString(); + crypto = null; + if (nextCrypto.equals("directory-signature")) { + this.directorySignature = cryptoString; + } else { + throw new DescriptorParseException("Unrecognized crypto " + + "block in v2 network status."); + } + nextCrypto = null; + } else if (crypto != null) { + crypto.append(line + "\n"); + } else if (this.failUnrecognizedDescriptorLines) { + throw new DescriptorParseException("Unrecognized line '" + line + + "' in v2 network status."); + } else { + if (this.unrecognizedLines == null) { + this.unrecognizedLines = new ArrayList<String>(); + } + this.unrecognizedLines.add(line); + } + } + } + + private void parseSignedDirectoryLine(String line, String lineNoOpt, + String[] partsNoOpt) throws DescriptorParseException { + if (!lineNoOpt.equals("signed-directory")) { + throw new DescriptorParseException("Illegal line '" + line + "'."); + } + } + + private void parsePublishedLine(String line, String lineNoOpt, + String[] partsNoOpt) throws DescriptorParseException { + this.publishedMillis = ParseHelper.parseTimestampAtIndex(line, + partsNoOpt, 1, 2); + } + + private void parseDirSigningKeyLine(String line, String lineNoOpt, + String[] partsNoOpt) throws DescriptorParseException { + if (partsNoOpt.length > 2) { + throw new DescriptorParseException("Illegal line '" + line + "'."); + } else if (partsNoOpt.length == 2) { + /* Early directories didn't have a crypto object following the + * "dir-signing-key" line, but had the key base64-encoded in the + * same line. */ + StringBuilder sb = new StringBuilder(); + sb.append("-----BEGIN RSA PUBLIC KEY-----\n"); + String keyString = partsNoOpt[1]; + while (keyString.length() > 64) { + sb.append(keyString.substring(0, 64) + "\n"); + keyString = keyString.substring(64); + } + if (keyString.length() > 0) { + sb.append(keyString + "\n"); + } + sb.append("-----END RSA PUBLIC KEY-----\n"); + this.dirSigningKey = sb.toString(); + } + } + + private void parseRecommendedSoftwareLine(String line, String lineNoOpt, + String[] partsNoOpt) throws DescriptorParseException { + List<String> result = new ArrayList<String>(); + if (partsNoOpt.length > 2) { + throw new DescriptorParseException("Illegal versions line '" + line + + "'."); + } else if (partsNoOpt.length == 2) { + String[] versions = partsNoOpt[1].split(",", -1); + for (int i = 0; i < versions.length; i++) { + String version = versions[i]; + if (version.length() < 1) { + throw new DescriptorParseException("Illegal versions line '" + + line + "'."); + } + result.add(version); + } + } + this.recommendedSoftware = result; + } + + private void parseRunningRoutersLine(String line, String lineNoOpt, + String[] partsNoOpt) throws DescriptorParseException { + for (int i = 1; i < partsNoOpt.length; i++) { + String part = partsNoOpt[i]; + String debugLine = "running-routers [...] " + part + " [...]"; + boolean isLive = true; + if (part.startsWith("!")) { + isLive = false; + part = part.substring(1); + } + boolean isVerified; + String fingerprint = null, nickname = null; + if (part.startsWith("$")) { + isVerified = false; + fingerprint = ParseHelper.parseTwentyByteHexString(debugLine, + part.substring(1)); + } else { + isVerified = true; + nickname = ParseHelper.parseNickname(debugLine, part); + } + this.statusEntries.add(new RouterStatusEntryImpl(fingerprint, + nickname, isLive, isVerified)); + } + } + + private void parseRouterStatusLine(String line, String lineNoOpt, + String[] partsNoOpt) throws DescriptorParseException { + for (int i = 1; i < partsNoOpt.length; i++) { + String part = partsNoOpt[i]; + String debugLine = "router-status [...] " + part + " [...]"; + RouterStatusEntry entry = null; + if (part.contains("=")) { + String[] partParts = part.split("="); + if (partParts.length == 2) { + boolean isVerified = true, isLive; + String nickname; + if (partParts[0].startsWith("!")) { + isLive = false; + nickname = ParseHelper.parseNickname(debugLine, + partParts[0].substring(1)); + } else { + isLive = true; + nickname = ParseHelper.parseNickname(debugLine, partParts[0]); + } + String fingerprint = ParseHelper.parseTwentyByteHexString( + debugLine, partParts[1].substring(1)); + entry = new RouterStatusEntryImpl(fingerprint, nickname, isLive, + isVerified); + } + } else { + boolean isVerified = false, isLive; + String nickname = null, fingerprint; + if (part.startsWith("!")) { + isLive = false; + fingerprint = ParseHelper.parseTwentyByteHexString( + debugLine, part.substring(2)); + } else { + isLive = true; + fingerprint = ParseHelper.parseTwentyByteHexString( + debugLine, part.substring(1));; + } + entry = new RouterStatusEntryImpl(fingerprint, nickname, isLive, + isVerified); + } + if (entry == null) { + throw new DescriptorParseException("Illegal router-status entry '" + + part + "' in v1 directory."); + } + this.statusEntries.add(entry); + } + } + + private void parseDirectorySignatureLine(String line, String lineNoOpt, + String[] partsNoOpt) throws DescriptorParseException { + if (partsNoOpt.length < 2) { + throw new DescriptorParseException("Illegal line '" + line + "'."); + } + this.nickname = ParseHelper.parseNickname(line, partsNoOpt[1]); + } + + private long publishedMillis; + public long getPublishedMillis() { + return this.publishedMillis; + } + + private String dirSigningKey; + public String getDirSigningKey() { + return this.dirSigningKey; + } + + private List<String> recommendedSoftware; + public List<String> getRecommendedSoftware() { + return this.recommendedSoftware == null ? null : + new ArrayList<String>(this.recommendedSoftware); + } + + private String directorySignature; + public String getDirectorySignature() { + return this.directorySignature; + } + + private List<RouterStatusEntry> statusEntries = + new ArrayList<RouterStatusEntry>(); + public List<RouterStatusEntry> getRouterStatusEntries() { + return new ArrayList<RouterStatusEntry>(this.statusEntries); + } + + private List<ServerDescriptor> serverDescriptors = + new ArrayList<ServerDescriptor>(); + public List<ServerDescriptor> getServerDescriptors() { + return new ArrayList<ServerDescriptor>(this.serverDescriptors); + } + + private List<Exception> serverDescriptorParseExceptions = + new ArrayList<Exception>(); + public List<Exception> getServerDescriptorParseExceptions() { + return new ArrayList<Exception>(this.serverDescriptorParseExceptions); + } + + private String nickname; + public String getNickname() { + return this.nickname; + } + + private String directoryDigest; + public String getDirectoryDigest() { + return this.directoryDigest; + } +} + diff --git a/src/org/torproject/descriptor/impl/RouterStatusEntryImpl.java b/src/org/torproject/descriptor/impl/RouterStatusEntryImpl.java new file mode 100644 index 0000000..68f549e --- /dev/null +++ b/src/org/torproject/descriptor/impl/RouterStatusEntryImpl.java @@ -0,0 +1,37 @@ +/* Copyright 2012 The Tor Project + * See LICENSE for licensing information */ +package org.torproject.descriptor.impl; + +import org.torproject.descriptor.RouterStatusEntry; + +public class RouterStatusEntryImpl implements RouterStatusEntry { + + protected RouterStatusEntryImpl(String fingerprint, String nickname, + boolean isLive, boolean isVerified) { + this.fingerprint = fingerprint; + this.nickname = nickname; + this.isLive = isLive; + this.isVerified = isVerified; + } + + private String nickname; + public String getNickname() { + return this.nickname; + } + + private String fingerprint; + public String getFingerprint() { + return this.fingerprint; + } + + private boolean isLive; + public boolean isLive() { + return this.isLive; + } + + private boolean isVerified; + public boolean isVerified() { + return this.isVerified; + } +} + diff --git a/src/org/torproject/descriptor/impl/ServerDescriptorImpl.java b/src/org/torproject/descriptor/impl/ServerDescriptorImpl.java index 77b06dd..5237348 100644 --- a/src/org/torproject/descriptor/impl/ServerDescriptorImpl.java +++ b/src/org/torproject/descriptor/impl/ServerDescriptorImpl.java @@ -123,6 +123,8 @@ public class ServerDescriptorImpl extends DescriptorImpl this.parseProtocolsLine(line, lineNoOpt, partsNoOpt); } else if (keyword.equals("allow-single-hop-exits")) { this.parseAllowSingleHopExitsLine(line, lineNoOpt, partsNoOpt); + } else if (keyword.equals("dircacheport")) { + this.parseDircacheportLine(line, lineNoOpt, partsNoOpt); } else if (line.startsWith("-----BEGIN")) { crypto = new StringBuilder(); crypto.append(line + "\n"); @@ -183,7 +185,7 @@ public class ServerDescriptorImpl extends DescriptorImpl
private void parseBandwidthLine(String line, String lineNoOpt, String[] partsNoOpt) throws DescriptorParseException { - if (partsNoOpt.length != 4) { + if (partsNoOpt.length < 3 || partsNoOpt.length > 4) { throw new DescriptorParseException("Wrong number of values in line " + "'" + line + "'."); } @@ -191,11 +193,18 @@ public class ServerDescriptorImpl extends DescriptorImpl try { this.bandwidthRate = Integer.parseInt(partsNoOpt[1]); this.bandwidthBurst = Integer.parseInt(partsNoOpt[2]); - this.bandwidthObserved = Integer.parseInt(partsNoOpt[3]); + if (partsNoOpt.length == 4) { + this.bandwidthObserved = Integer.parseInt(partsNoOpt[3]); + } if (this.bandwidthRate >= 0 && this.bandwidthBurst >= 0 && this.bandwidthObserved >= 0) { isValid = true; } + if (partsNoOpt.length < 4) { + /* Tor versions 0.0.8 and older only wrote bandwidth lines with + * rate and burst values, but no observed value. */ + this.bandwidthObserved = -1; + } } catch (NumberFormatException e) { /* Handle below. */ } @@ -435,6 +444,21 @@ public class ServerDescriptorImpl extends DescriptorImpl this.allowSingleHopExits = true; }
+ private void parseDircacheportLine(String line, String lineNoOpt, + String[] partsNoOpt) throws DescriptorParseException { + /* The dircacheport line was only contained in server descriptors + * published by Tor 0.0.8 and before. It's only specified in old + * tor-spec.txt versions. */ + if (partsNoOpt.length != 2) { + throw new DescriptorParseException("Illegal line '" + line + "'."); + } + if (this.dirPort != 0) { + throw new DescriptorParseException("At most one of dircacheport " + + "and the directory port in the router line may be non-zero."); + } + this.dirPort = ParseHelper.parsePort(line, partsNoOpt[1]); + } + private void calculateDigest() throws DescriptorParseException { try { String ascii = new String(this.getRawDescriptorBytes(), "US-ASCII");