commit bcb75e8bfad2d9c64655a6064ca5c5e15d03a3d7
Author: Colin Childs <colin(a)torproject.org>
Date: Thu Apr 28 00:42:08 2016 -0500
Add note about removing Tor Browser on Linux
---
C/uninstalling.page | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)
diff --git a/C/uninstalling.page b/C/uninstalling.page
index eab010e..fbb8fa7 100644
--- a/C/uninstalling.page
+++ b/C/uninstalling.page
@@ -23,7 +23,9 @@ Removing Tor Browser from your system is simple:
<item>
&…
[View More]lt;p>
Locate your Tor Browser folder. The default location on Windows is the Desktop;
- on Mac OS X it is the Applications folder.
+ on Mac OS X it is the Applications folder. On Linux, there is no default location,
+ however the folder will be named "tor-browser_en-US" if you are running the English
+ Tor Browser.
</p>
</item>
<item>
[View Less]
commit 4d64c10b63d403223e08fffcc3bdbcc299802f3d
Author: Roger Dingledine <arma(a)torproject.org>
Date: Wed Apr 27 17:42:16 2016 -0400
remove distracting lines about obsolete packages
also find the new tails key and put it back on the page
---
docs/en/signing-keys.wml | 18 +++++++++---------
1 file changed, 9 insertions(+), 9 deletions(-)
diff --git a/docs/en/signing-keys.wml b/docs/en/signing-keys.wml
index a1ab724..f169d36 100644
--- a/docs/en/signing-keys.wml
+++ b/…
[View More]docs/en/signing-keys.wml
@@ -21,19 +21,13 @@
<li>Roger Dingledine (0x28988BF5 and 0x19F78451) or Nick Mathewson
(0x165733EA, or its subkey 0x8D29319A) sign the Tor source code
tarballs.</li>
- <li>Erinn Clark (0x63FEE659) signed earlier Tor Browser Bundles
- and many other packages, and used to sign RPMs with her other key
- (0xF1F5C9B5). Andrew Lewman (0x31B0974B, 0x6B4D6475) used to sign
- packages for RPMs, Windows, and OS X.</li>
<li>Tor Project Archive (0x886DDD89) signs the deb.torproject.org
repositories and archives.</li>
<li>Damian Johnson (0x9ABBEEC6) signs Arm releases.</li>
- <li>Sebastian Hahn (0xC5AA446D), and David Fifield (0xC11F6276) sign Pluggable Transport Tor Browser Bundles. Sometimes Sebastian signs the Tor Browser Bundles.</li>
- <li>The Tails team (0xBE2CD9C1) signs the Tails live system
- releases.</li>
- <li>David Goulet (0x42E86A2A11F48D36) signs Torsocks releases.</li>
+ <li>The Tails team (0x58ACD84F) signs the Tails live system releases.</li>
+ <li>David Goulet (0x42E86A2A11F48D36) signs Torsocks releases.</li>
<li>Other developers include Peter Palfrader (0xC82E0039, or its
- subkey 0xE1DEC577) and Jacob Appelbaum (0xD255D3F5C868227F).</li>
+ subkey 0xE1DEC577) and Jacob Appelbaum (0xFA7F0E44D487F03F).</li>
</ul>
The fingerprints for the keys should be:
@@ -132,6 +126,12 @@
uid David Goulet <dgoulet(a)torproject.org>
sub 4096g/FE9D6620 2011-05-11 [expires: 2016-05-09]
sub 4096R/93CC198D 2013-09-10 [expires: 2016-09-10]
+
+ pub 4096R/58ACD84F 2015-01-18 [expires: 2017-01-11]
+ Key fingerprint = A490 D0F4 D311 A415 3E2B B7CA DBB8 02B2 58AC D84F
+ uid Tails developers <tails(a)boum.org>
+ sub 4096R/752A3DB6 2015-01-18 [expires: 2017-01-11]
+ sub 4096R/2F699C56 2015-01-18 [expires: 2017-01-11]
</pre>
</div>
[View Less]
commit de5def32a1dbe35d773219a11bfcf9dac3fe96f2
Author: teor (Tim Wilson-Brown) <teor2345(a)gmail.com>
Date: Wed Mar 30 12:45:22 2016 +1100
Changes for #17158, #17905, #18689, #18749 & April 2016 fallbacks
---
changes/fallbacks-201604 | 8 ++++++++
1 file changed, 8 insertions(+)
diff --git a/changes/fallbacks-201604 b/changes/fallbacks-201604
new file mode 100644
index 0000000..f88d5c6
--- /dev/null
+++ b/changes/fallbacks-201604
@@ -0,0 +1,8 @@
+ o Minor enhancements (…
[View More]fallback directory mirrors):
+ - Give each fallback the same weight for client selection.
+ Restrict fallbacks to one per operator.
+ Add new fallback directory mirrors to the whitelist.
+ Update fallback directories based on the latest OnionOO data.
+ Many other minor simplifications and fixes.
+ Closes tasks 17158, 17905, 18749, and bug 18689 on
+ tor 0.2.8.1-alpha; patch by "teor".
[View Less]
commit 205a641e1dad6db967825dcad01bc59c6909b395
Author: teor (Tim Wilson-Brown) <teor2345(a)gmail.com>
Date: Thu Mar 31 12:47:42 2016 +1100
Remove fallback directory weights
Give each fallback a set weight of 10.0 for client selection.
Fallbacks must have at least 3000 consensus weight.
This is (nominally) 100 times the expected extra load of
20 kilobytes per second (50 GB per month).
Fixes issue #17905.
---
scripts/maint/updateFallbackDirs.py | …
[View More]221 +++++++-----------------------------
1 file changed, 40 insertions(+), 181 deletions(-)
diff --git a/scripts/maint/updateFallbackDirs.py b/scripts/maint/updateFallbackDirs.py
index 4860700..124f85f 100755
--- a/scripts/maint/updateFallbackDirs.py
+++ b/scripts/maint/updateFallbackDirs.py
@@ -120,39 +120,31 @@ CONSENSUS_DOWNLOAD_RETRY = True
# The target for these parameters is 20% of the guards in the network
# This is around 200 as of October 2015
-FALLBACK_PROPORTION_OF_GUARDS = None if OUTPUT_CANDIDATES else 0.2
+_FB_POG = 0.2
+FALLBACK_PROPORTION_OF_GUARDS = None if OUTPUT_CANDIDATES else _FB_POG
# Limit the number of fallbacks (eliminating lowest by weight)
MAX_FALLBACK_COUNT = None if OUTPUT_CANDIDATES else 500
# Emit a C #error if the number of fallbacks is below
-MIN_FALLBACK_COUNT = 50
+MIN_FALLBACK_COUNT = 100
## Fallback Weight Settings
-# Any fallback with the Exit flag has its weight multipled by this fraction
+# Any fallback with the Exit flag has its consensus weight multipled by this
EXIT_WEIGHT_FRACTION = 1.0
-# If True, emit a C #error if we can't satisfy various constraints
-# If False, emit a C comment instead
-STRICT_FALLBACK_WEIGHTS = False
-
-# Limit the proportional weight
-# If a single fallback's weight is too high, it will see too many clients
-# We reweight using a lower threshold to provide some leeway for:
-# * elimination of low weight relays
-# * consensus weight changes
-# * fallback directory losses over time
-# A relay weighted at 1 in 10 fallbacks will see about 10% of clients that
-# use the fallback directories. (The 9 directory authorities see a similar
-# proportion of clients.)
-TARGET_MAX_WEIGHT_FRACTION = 1/10.0
-REWEIGHTING_FUDGE_FACTOR = 0.8
-MAX_WEIGHT_FRACTION = TARGET_MAX_WEIGHT_FRACTION * REWEIGHTING_FUDGE_FACTOR
-# If a single fallback's weight is too low, it's pointless adding it.
-# (Final weights may be slightly higher than this, due to low weight relays
-# being excluded.)
-# A relay weighted at 1 in 1000 fallbacks will see about 0.1% of clients.
-MIN_WEIGHT_FRACTION = 0.0 if OUTPUT_CANDIDATES else 1/1000.0
+# If a single fallback's consensus weight is too low, it's pointless adding it
+# We expect fallbacks to handle an extra 30 kilobytes per second of traffic
+# Make sure they support a hundred times that
+MIN_CONSENSUS_WEIGHT = 30.0 * 100.0
+
+# All fallback weights are equal, and set to the value below
+# Authorities are weighted 1.0 by default
+# Clients use these weights to select fallbacks and authorities at random
+# If there are 100 fallbacks and 9 authorities:
+# - each fallback is chosen with probability 10/(1000 + 9) ~= 0.99%
+# - each authority is chosen with probability 1/(1000 + 9) ~= 0.09%
+FALLBACK_OUTPUT_WEIGHT = 10.0
## Other Configuration Parameters
@@ -465,9 +457,7 @@ class Candidate(object):
logging.debug("Failed to get an ipv6 address for %s."%(self._fpr,))
# Reduce the weight of exits to EXIT_WEIGHT_FRACTION * consensus_weight
if self.is_exit():
- current_weight = self._data['consensus_weight']
- exit_weight = current_weight * EXIT_WEIGHT_FRACTION
- self._data['original_consensus_weight'] = current_weight
+ exit_weight = self._data['consensus_weight'] * EXIT_WEIGHT_FRACTION
self._data['consensus_weight'] = exit_weight
def _stable_sort_or_addresses(self):
@@ -757,6 +747,12 @@ class Candidate(object):
logging.info('%s not a candidate: guard avg too low (%lf)',
self._fpr, self._guard)
return False
+ if (MIN_CONSENSUS_WEIGHT is not None
+ and self._data['consensus_weight'] < MIN_CONSENSUS_WEIGHT):
+ logging.info('%s not a candidate: consensus weight %.0f too low, must ' +
+ 'be at least %.0f', self._fpr,
+ self._data['consensus_weight'], MIN_CONSENSUS_WEIGHT)
+ return False
return True
def is_in_whitelist(self, relaylist):
@@ -895,20 +891,6 @@ class Candidate(object):
def is_running(self):
return 'Running' in self._data['flags']
- def fallback_weight_fraction(self, total_weight):
- return float(self._data['consensus_weight']) / total_weight
-
- # return the original consensus weight, if it exists,
- # or, if not, return the consensus weight
- def original_consensus_weight(self):
- if self._data.has_key('original_consensus_weight'):
- return self._data['original_consensus_weight']
- else:
- return self._data['consensus_weight']
-
- def original_fallback_weight_fraction(self, total_weight):
- return float(self.original_consensus_weight()) / total_weight
-
@staticmethod
def fallback_consensus_dl_speed(dirip, dirport, nickname, max_time):
download_failed = False
@@ -976,17 +958,15 @@ class Candidate(object):
CONSENSUS_DOWNLOAD_SPEED_MAX)
return ((not ipv4_failed) and (not ipv6_failed))
- def fallbackdir_line(self, total_weight, original_total_weight, dl_speed_ok):
+ def fallbackdir_line(self, dl_speed_ok):
# /*
# nickname
# flags
- # weight / total (percentage)
- # [original weight / original total (original percentage)]
# [contact]
# */
# "address:dirport orport=port id=fingerprint"
# "[ipv6=addr:orport]"
- # "weight=num",
+ # "weight=FALLBACK_OUTPUT_WEIGHT",
#
# Multiline C comment
s = '/*'
@@ -996,19 +976,6 @@ class Candidate(object):
s += 'Flags: '
s += cleanse_c_multiline_comment(' '.join(sorted(self._data['flags'])))
s += '\n'
- weight = self._data['consensus_weight']
- percent_weight = self.fallback_weight_fraction(total_weight)*100
- s += 'Fallback Weight: %d / %d (%.3f%%)'%(weight, total_weight,
- percent_weight)
- s += '\n'
- o_weight = self.original_consensus_weight()
- if o_weight != weight:
- o_percent_weight = self.original_fallback_weight_fraction(
- original_total_weight)*100
- s += 'Consensus Weight: %d / %d (%.3f%%)'%(o_weight,
- original_total_weight,
- o_percent_weight)
- s += '\n'
if self._data['contact'] is not None:
s += cleanse_c_multiline_comment(self._data['contact'])
s += '\n'
@@ -1030,7 +997,7 @@ class Candidate(object):
s += '" ipv6=%s:%s"'%(
cleanse_c_string(self.ipv6addr), cleanse_c_string(self.ipv6orport))
s += '\n'
- s += '" weight=%d",'%(weight)
+ s += '" weight=%d",'%(FALLBACK_OUTPUT_WEIGHT)
if not dl_speed_ok:
s += '\n'
s += '*/'
@@ -1205,48 +1172,11 @@ class CandidateList(dict):
# Remove any fallbacks in excess of MAX_FALLBACK_COUNT,
# starting with the lowest-weighted fallbacks
- # total_weight should be recalculated after calling this
+ # this changes total weight
def exclude_excess_fallbacks(self):
if MAX_FALLBACK_COUNT is not None:
self.fallbacks = self.fallbacks[:MAX_FALLBACK_COUNT]
- # Clamp the weight of all fallbacks to MAX_WEIGHT_FRACTION * total_weight
- # fallbacks are kept sorted, but since excessive weights are reduced to
- # the maximum acceptable weight, these relays end up with equal weights
- def clamp_high_weight_fallbacks(self, total_weight):
- if MAX_WEIGHT_FRACTION * len(self.fallbacks) < 1.0:
- error_str = 'Max Fallback Weight %.3f%% is unachievable'%(
- MAX_WEIGHT_FRACTION)
- error_str += ' with Current Fallback Count %d.'%(len(self.fallbacks))
- if STRICT_FALLBACK_WEIGHTS:
- print '#error ' + error_str
- else:
- print '/* ' + error_str + ' */'
- relays_clamped = 0
- max_acceptable_weight = total_weight * MAX_WEIGHT_FRACTION
- for f in self.fallbacks:
- frac_weight = f.fallback_weight_fraction(total_weight)
- if frac_weight > MAX_WEIGHT_FRACTION:
- relays_clamped += 1
- current_weight = f._data['consensus_weight']
- # if we already have an original weight, keep it
- if (not f._data.has_key('original_consensus_weight')
- or f._data['original_consensus_weight'] == current_weight):
- f._data['original_consensus_weight'] = current_weight
- f._data['consensus_weight'] = max_acceptable_weight
- return relays_clamped
-
- # Remove any fallbacks with weights lower than MIN_WEIGHT_FRACTION
- # total_weight should be recalculated after calling this
- def exclude_low_weight_fallbacks(self, total_weight):
- self.fallbacks = filter(
- lambda x:
- x.fallback_weight_fraction(total_weight) >= MIN_WEIGHT_FRACTION,
- self.fallbacks)
-
- def fallback_weight_total(self):
- return sum(f._data['consensus_weight'] for f in self.fallbacks)
-
def fallback_min_weight(self):
if len(self.fallbacks) > 0:
return self.fallbacks[-1]
@@ -1259,14 +1189,12 @@ class CandidateList(dict):
else:
return None
- def summarise_fallbacks(self, eligible_count, eligible_weight,
- relays_clamped, clamped_weight,
- guard_count, target_count, max_count):
+ def summarise_fallbacks(self, eligible_count, guard_count, target_count,
+ max_count):
# Report:
# the number of fallback directories (with min & max limits);
# #error if below minimum count
- # the total weight, min & max fallback proportions
- # #error if outside max weight proportion
+ # min & max fallback weights
# Multiline C comment with #error if things go bad
s = '/*'
s += '\n'
@@ -1279,7 +1207,7 @@ class CandidateList(dict):
else:
fallback_proportion = '%d (%d * %f)'%(target_count, guard_count,
FALLBACK_PROPORTION_OF_GUARDS)
- s += 'Final Count: %d (Eligible %d, Usable %d, Target %d%s'%(
+ s += 'Final Count: %d (Eligible %d, Target %d%s'%(
min(max_count, fallback_count),
eligible_count,
fallback_count,
@@ -1299,51 +1227,19 @@ class CandidateList(dict):
s += '\n'
s += '/*'
s += '\n'
- total_weight = self.fallback_weight_total()
min_fb = self.fallback_min_weight()
min_weight = min_fb._data['consensus_weight']
- min_percent = min_fb.fallback_weight_fraction(total_weight)*100.0
max_fb = self.fallback_max_weight()
max_weight = max_fb._data['consensus_weight']
- max_frac = max_fb.fallback_weight_fraction(total_weight)
- max_percent = max_frac*100.0
- s += 'Final Weight: %d (Eligible %d)'%(total_weight, eligible_weight)
- s += '\n'
- s += 'Max Weight: %d (%.3f%%) (Clamped to %.3f%%)'%(
- max_weight,
- max_percent,
- TARGET_MAX_WEIGHT_FRACTION*100)
+ s += 'Max Weight: %d'%(max_weight)
s += '\n'
- s += 'Min Weight: %d (%.3f%%) (Clamped to %.3f%%)'%(
- min_weight,
- min_percent,
- MIN_WEIGHT_FRACTION*100)
+ s += 'Min Weight: %d'%(min_weight)
s += '\n'
if eligible_count != fallback_count:
- s += 'Excluded: %d (Clamped, Below Target, or Low Weight)'%(
+ s += 'Excluded: %d (Eligible Count Exceeded Target Count)'%(
eligible_count - fallback_count)
s += '\n'
- if relays_clamped > 0:
- s += 'Clamped: %d (%.3f%%) Excess Weight, '%(
- clamped_weight,
- (100.0 * clamped_weight) / total_weight)
- s += '%d High Weight Fallbacks (%.1f%%)'%(
- relays_clamped,
- (100.0 * relays_clamped) / fallback_count)
- s += '\n'
s += '*/'
- if max_frac > TARGET_MAX_WEIGHT_FRACTION:
- s += '\n'
- # We must restrict the maximum fallback weight, so an adversary
- # at or near the fallback doesn't see too many clients
- error_str = 'Max Fallback Weight %.3f%% is too high. '%(max_frac*100)
- error_str += 'Must be at most %.3f%% for client anonymity.'%(
- TARGET_MAX_WEIGHT_FRACTION*100)
- if STRICT_FALLBACK_WEIGHTS:
- s += '#error ' + error_str
- else:
- s += '/* ' + error_str + ' */'
- s += '\n'
if PERFORM_IPV4_DIRPORT_CHECKS or PERFORM_IPV6_DIRPORT_CHECKS:
s += '/* Checked %s%s%s DirPorts served a consensus within %.1fs. */'%(
'IPv4' if PERFORM_IPV4_DIRPORT_CHECKS else '',
@@ -1386,54 +1282,17 @@ def list_fallbacks():
excluded_count = candidates.apply_filter_lists()
print candidates.summarise_filters(initial_count, excluded_count)
eligible_count = len(candidates.fallbacks)
- eligible_weight = candidates.fallback_weight_total()
# print the raw fallback list
- #total_weight = candidates.fallback_weight_total()
#for x in candidates.fallbacks:
- # print x.fallbackdir_line(total_weight, total_weight)
+ # print x.fallbackdir_line(True)
- # When candidates are excluded, total_weight decreases, and
- # the proportional weight of other candidates increases.
+ # exclude low-weight fallbacks if we have more than we want
candidates.exclude_excess_fallbacks()
- total_weight = candidates.fallback_weight_total()
-
- # When candidates are reweighted, total_weight decreases, and
- # the proportional weight of other candidates increases.
- # Previously low-weight candidates might obtain sufficient proportional
- # weights to be included.
- # Save the weight at which we reweighted fallbacks for the summary.
- pre_clamp_total_weight = total_weight
- relays_clamped = candidates.clamp_high_weight_fallbacks(total_weight)
-
- # When candidates are excluded, total_weight decreases, and
- # the proportional weight of other candidates increases.
- # No new low weight candidates will be created during exclusions.
- # However, high weight candidates may increase over the maximum proportion.
- # This should not be an issue, except in pathological cases.
- candidates.exclude_low_weight_fallbacks(total_weight)
- total_weight = candidates.fallback_weight_total()
-
- # check we haven't exceeded TARGET_MAX_WEIGHT_FRACTION
- # since reweighting preserves the orginal sort order,
- # the maximum weights will be at the head of the list
- if len(candidates.fallbacks) > 0:
- max_weight_fb = candidates.fallback_max_weight()
- max_weight = max_weight_fb.fallback_weight_fraction(total_weight)
- if max_weight > TARGET_MAX_WEIGHT_FRACTION:
- error_str = 'Maximum fallback weight: %.3f%% exceeds target %.3f%%. '%(
- max_weight*100.0,
- TARGET_MAX_WEIGHT_FRACTION*100.0)
- error_str += 'Try decreasing REWEIGHTING_FUDGE_FACTOR.'
- if STRICT_FALLBACK_WEIGHTS:
- print '#error ' + error_str
- else:
- print '/* ' + error_str + ' */'
- print candidates.summarise_fallbacks(eligible_count, eligible_weight,
- relays_clamped,
- pre_clamp_total_weight - total_weight,
- guard_count, target_count, max_count)
+ if len(candidates.fallbacks) > 0:
+ print candidates.summarise_fallbacks(eligible_count, guard_count,
+ target_count, max_count)
else:
print '/* No Fallbacks met criteria */'
@@ -1442,7 +1301,7 @@ def list_fallbacks():
for x in candidates.fallbacks[:max_count]:
dl_speed_ok = x.fallback_consensus_dl_check()
- print x.fallbackdir_line(total_weight, pre_clamp_total_weight, dl_speed_ok)
+ print x.fallbackdir_line(dl_speed_ok)
#print json.dumps(candidates[x]._data, sort_keys=True, indent=4,
# separators=(',', ': '), default=json_util.default)
[View Less]
commit ba7691071e284623cc0c6e3e8ca8ff94d4be7ded
Author: teor (Tim Wilson-Brown) <teor2345(a)gmail.com>
Date: Sat Apr 16 01:43:11 2016 +1000
Report fallback directory detail changes when rebuilding list
As well as the existing reports of IPv6 address additions or removals,
the script now warns when keys change but IPv4:ORPort or
IPv6:IPv6ORPort remain the same.
Existing checks for other whitelist detail changes have also
been re-worded and upgraded to …
[View More]warnings.
This makes it easier for changes to be identified so operators can
be contacted to confirm whether the change is stable.
---
changes/fallbacks-201604 | 5 ++--
scripts/maint/updateFallbackDirs.py | 46 ++++++++++++++++++-------------------
2 files changed, 26 insertions(+), 25 deletions(-)
diff --git a/changes/fallbacks-201604 b/changes/fallbacks-201604
index f88d5c6..d61615a 100644
--- a/changes/fallbacks-201604
+++ b/changes/fallbacks-201604
@@ -1,8 +1,9 @@
o Minor enhancements (fallback directory mirrors):
- Give each fallback the same weight for client selection.
Restrict fallbacks to one per operator.
+ Report fallback directory detail changes when rebuilding list.
Add new fallback directory mirrors to the whitelist.
Update fallback directories based on the latest OnionOO data.
Many other minor simplifications and fixes.
- Closes tasks 17158, 17905, 18749, and bug 18689 on
- tor 0.2.8.1-alpha; patch by "teor".
+ Closes tasks 17158, 17905, 18749, bug 18689, and fixes part of
+ bug 18812 on tor 0.2.8.1-alpha; patch by "teor".
diff --git a/scripts/maint/updateFallbackDirs.py b/scripts/maint/updateFallbackDirs.py
index 4cfee5d..d27c144 100755
--- a/scripts/maint/updateFallbackDirs.py
+++ b/scripts/maint/updateFallbackDirs.py
@@ -806,48 +806,48 @@ class Candidate(object):
ipv6 address and port (if present)
If the fallback has an ipv6 key, the whitelist line must also have
it, and vice versa, otherwise they don't match. """
+ ipv6 = None
+ if self.has_ipv6():
+ ipv6 = '%s:%d'%(self.ipv6addr, self.ipv6orport)
for entry in relaylist:
- if entry['id'] != self._fpr:
- # can't log here, every relay's fingerprint is compared to the entry
+ if entry['id'] != self._fpr:
+ # can't log here unless we match an IP and port, because every relay's
+ # fingerprint is compared to every entry's fingerprint
+ if entry['ipv4'] == self.dirip and int(entry['orport']) == self.orport:
+ logging.warning('%s excluded: has OR %s:%d changed fingerprint to ' +
+ '%s?', entry['id'], self.dirip, self.orport,
+ self._fpr)
+ if self.has_ipv6() and entry.has_key('ipv6') and entry['ipv6'] == ipv6:
+ logging.warning('%s excluded: has OR %s changed fingerprint to ' +
+ '%s?', entry['id'], ipv6, self._fpr)
continue
if entry['ipv4'] != self.dirip:
- logging.info('%s is not in the whitelist: fingerprint matches, but ' +
- 'IPv4 (%s) does not match entry IPv4 (%s)',
- self._fpr, self.dirip, entry['ipv4'])
+ logging.warning('%s excluded: has it changed IPv4 from %s to %s?',
+ self._fpr, entry['ipv4'], self.dirip)
continue
if int(entry['dirport']) != self.dirport:
- logging.info('%s is not in the whitelist: fingerprint matches, but ' +
- 'DirPort (%d) does not match entry DirPort (%d)',
- self._fpr, self.dirport, int(entry['dirport']))
+ logging.warning('%s excluded: has it changed DirPort from %s:%d to ' +
+ '%s:%d?', self._fpr, self.dirip, int(entry['dirport']),
+ self.dirip, self.dirport)
continue
if int(entry['orport']) != self.orport:
- logging.info('%s is not in the whitelist: fingerprint matches, but ' +
- 'ORPort (%d) does not match entry ORPort (%d)',
- self._fpr, self.orport, int(entry['orport']))
+ logging.warning('%s excluded: has it changed ORPort from %s:%d to ' +
+ '%s:%d?', self._fpr, self.dirip, int(entry['orport']),
+ self.dirip, self.orport)
continue
- ipv6 = None
- if self.has_ipv6():
- ipv6 = '%s:%d'%(self.ipv6addr, self.ipv6orport)
if entry.has_key('ipv6') and self.has_ipv6():
# if both entry and fallback have an ipv6 address, compare them
if entry['ipv6'] != ipv6:
- logging.info('%s is not in the whitelist: fingerprint matches, ' +
- 'but IPv6 (%s) does not match entry IPv6 (%s)',
- self._fpr, ipv6, entry['ipv6'])
+ logging.warning('%s excluded: has it changed IPv6 ORPort from %s ' +
+ 'to %s?', self._fpr, entry['ipv6'], ipv6)
continue
# if the fallback has an IPv6 address but the whitelist entry
# doesn't, or vice versa, the whitelist entry doesn't match
elif entry.has_key('ipv6') and not self.has_ipv6():
- logging.info('%s is not in the whitelist: fingerprint matches, but ' +
- 'it has no IPv6, and entry has IPv6 (%s)', self._fpr,
- entry['ipv6'])
logging.warning('%s excluded: has it lost its former IPv6 address %s?',
self._fpr, entry['ipv6'])
continue
elif not entry.has_key('ipv6') and self.has_ipv6():
- logging.info('%s is not in the whitelist: fingerprint matches, but ' +
- 'it has IPv6 (%s), and entry has no IPv6', self._fpr,
- ipv6)
logging.warning('%s excluded: has it gained an IPv6 address %s?',
self._fpr, ipv6)
continue
[View Less]