src/allmydata/test/common.py

   1 import os, random, struct
   2 from zope.interface import implements
   3 from twisted.internet import defer
   4 from twisted.internet.interfaces import IConsumer
   5 from twisted.python import failure
   6 from twisted.application import service
   7 from twisted.web.error import Error as WebError
   8 from foolscap.eventual import flushEventualQueue, fireEventually
   9 from allmydata import uri, dirnode, client
  10 from allmydata.introducer.server import IntroducerNode
  11 from allmydata.interfaces import IURI, IMutableFileNode, IFileNode, \
  12      FileTooLargeError, NotEnoughSharesError, ICheckable
  13 from allmydata.check_results import CheckResults, CheckAndRepairResults, \
  14      DeepCheckResults, DeepCheckAndRepairResults
  15 from allmydata.mutable.common import CorruptShareError
  16 from allmydata.storage import storage_index_to_dir
  17 from allmydata.util import hashutil, log, fileutil, pollmixin
  18 from allmydata.util.assertutil import precondition
  19 from allmydata.stats import StatsGathererService
  20 from allmydata.key_generator import KeyGeneratorService
  21 import common_util as testutil
  22 from allmydata import immutable
  23
  24
  25 def flush_but_dont_ignore(res):
  26     d = flushEventualQueue()
  27     def _done(ignored):
  28         return res
  29     d.addCallback(_done)
  30     return d
  31
  32 class FakeCHKFileNode:
  33     """I provide IFileNode, but all of my data is stored in a class-level
  34     dictionary."""
  35     implements(IFileNode)
  36     all_contents = {}
  37     bad_shares = {}
  38
  39     def __init__(self, u, thisclient):
  40         precondition(IURI.providedBy(u), u)
  41         self.client = thisclient
  42         self.my_uri = u
  43         self.storage_index = u.storage_index
  44
  45     def get_uri(self):
  46         return self.my_uri.to_string()
  47     def get_readonly_uri(self):
  48         return self.my_uri.to_string()
  49     def get_verify_cap(self):
  50         return self.my_uri.get_verify_cap()
  51     def get_repair_cap(self):
  52         return self.my_uri.get_verify_cap()
  53     def get_storage_index(self):
  54         return self.storage_index
  55
  56     def check(self, monitor, verify=False):
  57         r = CheckResults(self.my_uri, self.storage_index)
  58         is_bad = self.bad_shares.get(self.storage_index, None)
  59         data = {}
  60         data["count-shares-needed"] = 3
  61         data["count-shares-expected"] = 10
  62         data["count-good-share-hosts"] = 10
  63         data["count-wrong-shares"] = 0
  64         nodeid = "\x00"*20
  65         data["list-corrupt-shares"] = []
  66         data["sharemap"] = {1: [nodeid]}
  67         data["servers-responding"] = [nodeid]
  68         data["count-recoverable-versions"] = 1
  69         data["count-unrecoverable-versions"] = 0
  70         if is_bad:
  71              r.set_healthy(False)
  72              r.set_recoverable(True)
  73              data["count-shares-good"] = 9
  74              data["list-corrupt-shares"] = [(nodeid, self.storage_index, 0)]
  75              r.problems = failure.Failure(CorruptShareError(is_bad))
  76         else:
  77              r.set_healthy(True)
  78              r.set_recoverable(True)
  79              data["count-shares-good"] = 10
  80              r.problems = []
  81         r.set_data(data)
  82         r.set_needs_rebalancing(False)
  83         return defer.succeed(r)
  84     def check_and_repair(self, monitor, verify=False):
  85         d = self.check(verify)
  86         def _got(cr):
  87             r = CheckAndRepairResults(self.storage_index)
  88             r.pre_repair_results = r.post_repair_results = cr
  89             return r
  90         d.addCallback(_got)
  91         return d
  92
  93     def is_mutable(self):
  94         return False
  95     def is_readonly(self):
  96         return True
  97
  98     def download(self, target):
  99         if self.my_uri.to_string() not in self.all_contents:
 100             f = failure.Failure(NotEnoughSharesError())
 101             target.fail(f)
 102             return defer.fail(f)
 103         data = self.all_contents[self.my_uri.to_string()]
 104         target.open(len(data))
 105         target.write(data)
 106         target.close()
 107         return defer.maybeDeferred(target.finish)
 108     def download_to_data(self):
 109         if self.my_uri.to_string() not in self.all_contents:
 110             return defer.fail(NotEnoughSharesError())
 111         data = self.all_contents[self.my_uri.to_string()]
 112         return defer.succeed(data)
 113     def get_size(self):
 114         try:
 115             data = self.all_contents[self.my_uri.to_string()]
 116         except KeyError, le:
 117             raise NotEnoughSharesError(le)
 118         return len(data)
 119     def read(self, consumer, offset=0, size=None):
 120         d = self.download_to_data()
 121         def _got(data):
 122             start = offset
 123             if size is not None:
 124                 end = offset + size
 125             else:
 126                 end = len(data)
 127             consumer.write(data[start:end])
 128             return consumer
 129         d.addCallback(_got)
 130         return d
 131
 132 def make_chk_file_uri(size):
 133     return uri.CHKFileURI(key=os.urandom(16),
 134                           uri_extension_hash=os.urandom(32),
 135                           needed_shares=3,
 136                           total_shares=10,
 137                           size=size)
 138
 139 def create_chk_filenode(thisclient, contents):
 140     u = make_chk_file_uri(len(contents))
 141     n = FakeCHKFileNode(u, thisclient)
 142     FakeCHKFileNode.all_contents[u.to_string()] = contents
 143     return n
 144
 145
 146 class FakeMutableFileNode:
 147     """I provide IMutableFileNode, but all of my data is stored in a
 148     class-level dictionary."""
 149
 150     implements(IMutableFileNode, ICheckable)
 151     MUTABLE_SIZELIMIT = 10000
 152     all_contents = {}
 153     bad_shares = {}
 154
 155     def __init__(self, thisclient):
 156         self.client = thisclient
 157         self.my_uri = make_mutable_file_uri()
 158         self.storage_index = self.my_uri.storage_index
 159     def create(self, initial_contents, key_generator=None):
 160         if len(initial_contents) > self.MUTABLE_SIZELIMIT:
 161             raise FileTooLargeError("SDMF is limited to one segment, and "
 162                                     "%d > %d" % (len(initial_contents),
 163                                                  self.MUTABLE_SIZELIMIT))
 164         self.all_contents[self.storage_index] = initial_contents
 165         return defer.succeed(self)
 166     def init_from_uri(self, myuri):
 167         self.my_uri = IURI(myuri)
 168         self.storage_index = self.my_uri.storage_index
 169         return self
 170     def get_uri(self):
 171         return self.my_uri.to_string()
 172     def get_readonly(self):
 173         return self.my_uri.get_readonly()
 174     def get_readonly_uri(self):
 175         return self.my_uri.get_readonly().to_string()
 176     def is_readonly(self):
 177         return self.my_uri.is_readonly()
 178     def is_mutable(self):
 179         return self.my_uri.is_mutable()
 180     def get_writekey(self):
 181         return "\x00"*16
 182     def get_size(self):
 183         return "?" # TODO: see mutable.MutableFileNode.get_size
 184     def get_size_of_best_version(self):
 185         return defer.succeed(len(self.all_contents[self.storage_index]))
 186
 187     def get_storage_index(self):
 188         return self.storage_index
 189
 190     def check(self, monitor, verify=False):
 191         r = CheckResults(self.my_uri, self.storage_index)
 192         is_bad = self.bad_shares.get(self.storage_index, None)
 193         data = {}
 194         data["count-shares-needed"] = 3
 195         data["count-shares-expected"] = 10
 196         data["count-good-share-hosts"] = 10
 197         data["count-wrong-shares"] = 0
 198         data["list-corrupt-shares"] = []
 199         nodeid = "\x00"*20
 200         data["sharemap"] = {"seq1-abcd-sh0": [nodeid]}
 201         data["servers-responding"] = [nodeid]
 202         data["count-recoverable-versions"] = 1
 203         data["count-unrecoverable-versions"] = 0
 204         if is_bad:
 205              r.set_healthy(False)
 206              r.set_recoverable(True)
 207              data["count-shares-good"] = 9
 208              r.problems = failure.Failure(CorruptShareError("peerid",
 209                                                             0, # shnum
 210                                                             is_bad))
 211         else:
 212              r.set_healthy(True)
 213              r.set_recoverable(True)
 214              data["count-shares-good"] = 10
 215              r.problems = []
 216         r.set_data(data)
 217         r.set_needs_rebalancing(False)
 218         return defer.succeed(r)
 219
 220     def check_and_repair(self, monitor, verify=False):
 221         d = self.check(verify)
 222         def _got(cr):
 223             r = CheckAndRepairResults(self.storage_index)
 224             r.pre_repair_results = r.post_repair_results = cr
 225             return r
 226         d.addCallback(_got)
 227         return d
 228
 229     def deep_check(self, verify=False):
 230         d = self.check(verify)
 231         def _done(r):
 232             dr = DeepCheckResults(self.storage_index)
 233             dr.add_check(r, [])
 234             return dr
 235         d.addCallback(_done)
 236         return d
 237
 238     def deep_check_and_repair(self, verify=False):
 239         d = self.check_and_repair(verify)
 240         def _done(r):
 241             dr = DeepCheckAndRepairResults(self.storage_index)
 242             dr.add_check(r, [])
 243             return dr
 244         d.addCallback(_done)
 245         return d
 246
 247     def download_best_version(self):
 248         return defer.succeed(self.all_contents[self.storage_index])
 249     def overwrite(self, new_contents):
 250         if len(new_contents) > self.MUTABLE_SIZELIMIT:
 251             raise FileTooLargeError("SDMF is limited to one segment, and "
 252                                     "%d > %d" % (len(new_contents),
 253                                                  self.MUTABLE_SIZELIMIT))
 254         assert not self.is_readonly()
 255         self.all_contents[self.storage_index] = new_contents
 256         return defer.succeed(None)
 257     def modify(self, modifier):
 258         # this does not implement FileTooLargeError, but the real one does
 259         return defer.maybeDeferred(self._modify, modifier)
 260     def _modify(self, modifier):
 261         assert not self.is_readonly()
 262         old_contents = self.all_contents[self.storage_index]
 263         self.all_contents[self.storage_index] = modifier(old_contents, None, True)
 264         return None
 265
 266     def download(self, target):
 267         if self.storage_index not in self.all_contents:
 268             f = failure.Failure(NotEnoughSharesError())
 269             target.fail(f)
 270             return defer.fail(f)
 271         data = self.all_contents[self.storage_index]
 272         target.open(len(data))
 273         target.write(data)
 274         target.close()
 275         return defer.maybeDeferred(target.finish)
 276     def download_to_data(self):
 277         if self.storage_index not in self.all_contents:
 278             return defer.fail(NotEnoughSharesError())
 279         data = self.all_contents[self.storage_index]
 280         return defer.succeed(data)
 281
 282 def make_mutable_file_uri():
 283     return uri.WriteableSSKFileURI(writekey=os.urandom(16),
 284                                    fingerprint=os.urandom(32))
 285 def make_verifier_uri():
 286     return uri.SSKVerifierURI(storage_index=os.urandom(16),
 287                               fingerprint=os.urandom(32))
 288
 289 class FakeDirectoryNode(dirnode.NewDirectoryNode):
 290     """This offers IDirectoryNode, but uses a FakeMutableFileNode for the
 291     backing store, so it doesn't go to the grid. The child data is still
 292     encrypted and serialized, so this isn't useful for tests that want to
 293     look inside the dirnodes and check their contents.
 294     """
 295     filenode_class = FakeMutableFileNode
 296
 297 class LoggingServiceParent(service.MultiService):
 298     def log(self, *args, **kwargs):
 299         return log.msg(*args, **kwargs)
 300
 301
 302 class SystemTestMixin(pollmixin.PollMixin, testutil.StallMixin):
 303
 304     def setUp(self):
 305         self.sparent = service.MultiService()
 306         self.sparent.startService()
 307
 308         self.stats_gatherer = None
 309         self.stats_gatherer_furl = None
 310         self.key_generator_svc = None
 311         self.key_generator_furl = None
 312
 313     def tearDown(self):
 314         log.msg("shutting down SystemTest services")
 315         d = self.sparent.stopService()
 316         d.addBoth(flush_but_dont_ignore)
 317         return d
 318
 319     def getdir(self, subdir):
 320         return os.path.join(self.basedir, subdir)
 321
 322     def add_service(self, s):
 323         s.setServiceParent(self.sparent)
 324         return s
 325
 326     def set_up_nodes(self, NUMCLIENTS=5,
 327                      use_stats_gatherer=False, use_key_generator=False):
 328         self.numclients = NUMCLIENTS
 329         iv_dir = self.getdir("introducer")
 330         if not os.path.isdir(iv_dir):
 331             fileutil.make_dirs(iv_dir)
 332             f = open(os.path.join(iv_dir, "webport"), "w")
 333             f.write("tcp:0:interface=127.0.0.1\n")
 334             f.close()
 335             if SYSTEM_TEST_CERTS:
 336                 os.mkdir(os.path.join(iv_dir, "private"))
 337                 f = open(os.path.join(iv_dir, "private", "node.pem"), "w")
 338                 f.write(SYSTEM_TEST_CERTS[0])
 339                 f.close()
 340         iv = IntroducerNode(basedir=iv_dir)
 341         self.introducer = self.add_service(iv)
 342         d = self.introducer.when_tub_ready()
 343         d.addCallback(self._get_introducer_web)
 344         if use_stats_gatherer:
 345             d.addCallback(self._set_up_stats_gatherer)
 346         if use_key_generator:
 347             d.addCallback(self._set_up_key_generator)
 348         d.addCallback(self._set_up_nodes_2)
 349         if use_stats_gatherer:
 350             d.addCallback(self._grab_stats)
 351         return d
 352
 353     def _get_introducer_web(self, res):
 354         f = open(os.path.join(self.getdir("introducer"), "node.url"), "r")
 355         self.introweb_url = f.read().strip()
 356         f.close()
 357
 358     def _set_up_stats_gatherer(self, res):
 359         statsdir = self.getdir("stats_gatherer")
 360         fileutil.make_dirs(statsdir)
 361         self.stats_gatherer_svc = StatsGathererService(statsdir)
 362         self.stats_gatherer = self.stats_gatherer_svc.stats_gatherer
 363         self.add_service(self.stats_gatherer_svc)
 364
 365         d = fireEventually()
 366         sgf = os.path.join(statsdir, 'stats_gatherer.furl')
 367         def check_for_furl():
 368             return os.path.exists(sgf)
 369         d.addCallback(lambda junk: self.poll(check_for_furl, timeout=30))
 370         def get_furl(junk):
 371             self.stats_gatherer_furl = file(sgf, 'rb').read().strip()
 372         d.addCallback(get_furl)
 373         return d
 374
 375     def _set_up_key_generator(self, res):
 376         kgsdir = self.getdir("key_generator")
 377         fileutil.make_dirs(kgsdir)
 378
 379         self.key_generator_svc = KeyGeneratorService(kgsdir, display_furl=False)
 380         self.key_generator_svc.key_generator.pool_size = 4
 381         self.key_generator_svc.key_generator.pool_refresh_delay = 60
 382         self.add_service(self.key_generator_svc)
 383
 384         d = fireEventually()
 385         def check_for_furl():
 386             return os.path.exists(os.path.join(kgsdir, 'key_generator.furl'))
 387         d.addCallback(lambda junk: self.poll(check_for_furl, timeout=30))
 388         def get_furl(junk):
 389             kgf = os.path.join(kgsdir, 'key_generator.furl')
 390             self.key_generator_furl = file(kgf, 'rb').read().strip()
 391         d.addCallback(get_furl)
 392         return d
 393
 394     def _set_up_nodes_2(self, res):
 395         q = self.introducer
 396         self.introducer_furl = q.introducer_url
 397         self.clients = []
 398         basedirs = []
 399         for i in range(self.numclients):
 400             basedir = self.getdir("client%d" % i)
 401             basedirs.append(basedir)
 402             fileutil.make_dirs(os.path.join(basedir, "private"))
 403             if len(SYSTEM_TEST_CERTS) > (i+1):
 404                 f = open(os.path.join(basedir, "private", "node.pem"), "w")
 405                 f.write(SYSTEM_TEST_CERTS[i+1])
 406                 f.close()
 407
 408             def write(name, value):
 409                 open(os.path.join(basedir, name), "w").write(value+"\n")
 410             if i == 0:
 411                 # clients[0] runs a webserver and a helper, no key_generator
 412                 write("webport", "tcp:0:interface=127.0.0.1")
 413                 write("run_helper", "yes")
 414                 write("keepalive_timeout", "600")
 415             if i == 3:
 416                 # clients[3] runs a webserver and uses a helper, uses
 417                 # key_generator
 418                 write("webport", "tcp:0:interface=127.0.0.1")
 419                 write("disconnect_timeout", "1800")
 420                 if self.key_generator_furl:
 421                     kgf = "%s\n" % (self.key_generator_furl,)
 422                     write("key_generator.furl", kgf)
 423             write("introducer.furl", self.introducer_furl)
 424             if self.stats_gatherer_furl:
 425                 write("stats_gatherer.furl", self.stats_gatherer_furl)
 426
 427         # give subclasses a chance to append liens to the node's tahoe.cfg
 428         # files before they are launched.
 429         self._set_up_nodes_extra_config()
 430
 431         # start clients[0], wait for it's tub to be ready (at which point it
 432         # will have registered the helper furl).
 433         c = self.add_service(client.Client(basedir=basedirs[0]))
 434         self.clients.append(c)
 435         d = c.when_tub_ready()
 436         def _ready(res):
 437             f = open(os.path.join(basedirs[0],"private","helper.furl"), "r")
 438             helper_furl = f.read()
 439             f.close()
 440             self.helper_furl = helper_furl
 441             if self.numclients >= 4:
 442                 f = open(os.path.join(basedirs[3],"helper.furl"), "w")
 443                 f.write(helper_furl)
 444                 f.close()
 445
 446             # this starts the rest of the clients
 447             for i in range(1, self.numclients):
 448                 c = self.add_service(client.Client(basedir=basedirs[i]))
 449                 self.clients.append(c)
 450             log.msg("STARTING")
 451             return self.wait_for_connections()
 452         d.addCallback(_ready)
 453         def _connected(res):
 454             log.msg("CONNECTED")
 455             # now find out where the web port was
 456             l = self.clients[0].getServiceNamed("webish").listener
 457             port = l._port.getHost().port
 458             self.webish_url = "http://localhost:%d/" % port
 459             if self.numclients >=4:
 460                 # and the helper-using webport
 461                 l = self.clients[3].getServiceNamed("webish").listener
 462                 port = l._port.getHost().port
 463                 self.helper_webish_url = "http://localhost:%d/" % port
 464         d.addCallback(_connected)
 465         return d
 466
 467     def _set_up_nodes_extra_config(self):
 468         # for overriding by subclasses
 469         pass
 470
 471     def _grab_stats(self, res):
 472         d = self.stats_gatherer.poll()
 473         return d
 474
 475     def bounce_client(self, num):
 476         c = self.clients[num]
 477         d = c.disownServiceParent()
 478         # I think windows requires a moment to let the connection really stop
 479         # and the port number made available for re-use. TODO: examine the
 480         # behavior, see if this is really the problem, see if we can do
 481         # better than blindly waiting for a second.
 482         d.addCallback(self.stall, 1.0)
 483         def _stopped(res):
 484             new_c = client.Client(basedir=self.getdir("client%d" % num))
 485             self.clients[num] = new_c
 486             self.add_service(new_c)
 487             return new_c.when_tub_ready()
 488         d.addCallback(_stopped)
 489         d.addCallback(lambda res: self.wait_for_connections())
 490         def _maybe_get_webport(res):
 491             if num == 0:
 492                 # now find out where the web port was
 493                 l = self.clients[0].getServiceNamed("webish").listener
 494                 port = l._port.getHost().port
 495                 self.webish_url = "http://localhost:%d/" % port
 496         d.addCallback(_maybe_get_webport)
 497         return d
 498
 499     def add_extra_node(self, client_num, helper_furl=None,
 500                        add_to_sparent=False):
 501         # usually this node is *not* parented to our self.sparent, so we can
 502         # shut it down separately from the rest, to exercise the
 503         # connection-lost code
 504         basedir = self.getdir("client%d" % client_num)
 505         if not os.path.isdir(basedir):
 506             fileutil.make_dirs(basedir)
 507         open(os.path.join(basedir, "introducer.furl"), "w").write(self.introducer_furl)
 508         if helper_furl:
 509             f = open(os.path.join(basedir, "helper.furl") ,"w")
 510             f.write(helper_furl+"\n")
 511             f.close()
 512
 513         c = client.Client(basedir=basedir)
 514         self.clients.append(c)
 515         self.numclients += 1
 516         if add_to_sparent:
 517             c.setServiceParent(self.sparent)
 518         else:
 519             c.startService()
 520         d = self.wait_for_connections()
 521         d.addCallback(lambda res: c)
 522         return d
 523
 524     def _check_connections(self):
 525         for c in self.clients:
 526             ic = c.introducer_client
 527             if not ic.connected_to_introducer():
 528                 return False
 529             if len(ic.get_all_peerids()) != self.numclients:
 530                 return False
 531         return True
 532
 533     def wait_for_connections(self, ignored=None):
 534         # TODO: replace this with something that takes a list of peerids and
 535         # fires when they've all been heard from, instead of using a count
 536         # and a threshold
 537         return self.poll(self._check_connections, timeout=200)
 538
 539
 540 # our system test uses the same Tub certificates each time, to avoid the
 541 # overhead of key generation
 542 SYSTEM_TEST_CERTS = [
 543 """-----BEGIN CERTIFICATE-----
 544 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 545 aW5neTAeFw0wODA3MjUyMjQyMDVaFw0wOTA3MjUyMjQyMDVaMBcxFTATBgNVBAMU
 546 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAxHCWajrR
 547 2h/iurw8k93m8WUdE3xypJiiAITw7GkKlKbCLD+dEce2MXwVVYca0n/MZZsj89Cu
 548 Ko0lLjksMseoSDoj98iEmVpaY5mc2ntpQ+FXdoEmPP234XRWEg2HQ+EaK6+WkGQg
 549 DDXQvFJCVCQk/n1MdAwZZ6vqf2ITzSuD44kCAwEAATANBgkqhkiG9w0BAQQFAAOB
 550 gQBn6qPKGdFjWJy7sOOTUFfm/THhHQqAh1pBDLkjR+OtzuobCoP8n8J1LNG3Yxds
 551 Jj7NWQL7X5TfOlfoi7e9jK0ujGgWh3yYU6PnHzJLkDiDT3LCSywQuGXCjh0tOStS
 552 2gaCmmAK2cfxSStKzNcewl2Zs8wHMygq8TLFoZ6ozN1+xQ==
 553 -----END CERTIFICATE-----
 554 -----BEGIN RSA PRIVATE KEY-----
 555 MIICXQIBAAKBgQDEcJZqOtHaH+K6vDyT3ebxZR0TfHKkmKIAhPDsaQqUpsIsP50R
 556 x7YxfBVVhxrSf8xlmyPz0K4qjSUuOSwyx6hIOiP3yISZWlpjmZzae2lD4Vd2gSY8
 557 /bfhdFYSDYdD4Rorr5aQZCAMNdC8UkJUJCT+fUx0DBlnq+p/YhPNK4PjiQIDAQAB
 558 AoGAZyDMdrymiyMOPwavrtlicvyohSBid3MCKc+hRBvpSB0790r2RO1aAySndp1V
 559 QYmCXx1RhKDbrs8m49t0Dryu5T+sQrFl0E3usAP3vvXWeh4jwJ9GyiRWy4xOEuEQ
 560 3ewjbEItHqA/bRJF0TNtbOmZTDC7v9FRPf2bTAyFfTZep5kCQQD33q1RA8WUYtmQ
 561 IArgHqt69i421lpXlOgqotFHwTx4FiGgVzDQCDuXU6txB9EeKRM340poissav/n6
 562 bkLZ7/VDAkEAyuIPkeI59sE5NnmW+N47NbCfdM1Smy1YxZpv942EmP9Veub5N0dw
 563 iK5bLAgEguUIjpTsh3BRmsE9Xd+ItmnRQwJBAMZhbg19G1EbnE0BmDKv2UbcaThy
 564 bnPSNc6J6T2opqDl9ZvCrMqTDD6dNIWOYAvni/4a556sFsoeBBAu10peBskCQE6S
 565 cB86cuJagLLVMh/dySaI6ahNoFFSpY+ZuQUxfInYUR2Q+DFtbGqyw8JwtHaRBthZ
 566 WqU1XZVGg2KooISsxIsCQQD1PS7//xHLumBb0jnpL7n6W8gmiTyzblT+0otaCisP
 567 fN6rTlwV1o8VsOUAz0rmKO5RArCbkmb01WtMgPCDBYkk
 568 -----END RSA PRIVATE KEY-----
 569 """, # 0
 570 """-----BEGIN CERTIFICATE-----
 571 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 572 aW5neTAeFw0wODA3MjUyMjQyMDVaFw0wOTA3MjUyMjQyMDVaMBcxFTATBgNVBAMU
 573 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAs9CALdmW
 574 kJ6r0KPSLdGCA8rzQKxWayrMckT22ZtbRv3aw6VA96dWclpY+T2maV0LrAzmMSL8
 575 n61ydJHM33iYDOyWbwHWN45XCjY/e20PL54XUl/DmbBHEhQVQLIfCldcRcnWEfoO
 576 iOhDJfWpDO1dmP/aOYLdkZCZvBtPAfyUqRcCAwEAATANBgkqhkiG9w0BAQQFAAOB
 577 gQAN9eaCREkzzk4yPIaWYkWHg3Igs1vnOR/iDw3OjyxO/xJFP2lkA2WtrwL2RTRq
 578 dxA8gwdPyrWgdiZElwZH8mzTJ4OdUXLSMclLOg9kvH6gtSvhLztfEDwDP1wRhikh
 579 OeWWu2GIC+uqFCI1ftoGgU+aIa6yrHswf66rrQvBSSvJPQ==
 580 -----END CERTIFICATE-----
 581 -----BEGIN RSA PRIVATE KEY-----
 582 MIICXQIBAAKBgQCz0IAt2ZaQnqvQo9It0YIDyvNArFZrKsxyRPbZm1tG/drDpUD3
 583 p1ZyWlj5PaZpXQusDOYxIvyfrXJ0kczfeJgM7JZvAdY3jlcKNj97bQ8vnhdSX8OZ
 584 sEcSFBVAsh8KV1xFydYR+g6I6EMl9akM7V2Y/9o5gt2RkJm8G08B/JSpFwIDAQAB
 585 AoGBAIUy5zCPpSP+FeJY6CG+t6Pdm/IFd4KtUoM3KPCrT6M3+uzApm6Ny9Crsor2
 586 qyYTocjSSVaOxzn1fvpw4qWLrH1veUf8ozMs8Z0VuPHD1GYUGjOXaBPXb5o1fQL9
 587 h7pS5/HrDDPN6wwDNTsxRf/fP58CnfwQUhwdoxcx8TnVmDQxAkEA6N3jBXt/Lh0z
 588 UbXHhv3QBOcqLZA2I4tY7wQzvUvKvVmCJoW1tfhBdYQWeQv0jzjL5PzrrNY8hC4l
 589 8+sFM3h5TwJBAMWtbFIEZfRSG1JhHK3evYHDTZnr/j+CdoWuhzP5RkjkIKsiLEH7
 590 2ZhA7CdFQLZF14oXy+g1uVCzzfB2WELtUbkCQQDKrb1XWzrBlzbAipfkXWs9qTmj
 591 uJ32Z+V6+0xRGPOXxJ0sDDqw7CeFMfchWg98zLFiV+SEZV78qPHtkAPR3ayvAkB+
 592 hUMhM4N13t9x2IoclsXAOhp++9bdG0l0woHyuAdOPATUw6iECwf4NQVxFRgYEZek
 593 4Ro3Y7taddrHn1dabr6xAkAic47OoLOROYLpljmJJO0eRe3Z5IFe+0D2LfhAW3LQ
 594 JU+oGq5pCjfnoaDElRRZn0+GmunnWeQEYKoflTi/lI9d
 595 -----END RSA PRIVATE KEY-----
 596 """, # 1
 597 """-----BEGIN CERTIFICATE-----
 598 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 599 aW5neTAeFw0wODA3MjUyMjQyMDZaFw0wOTA3MjUyMjQyMDZaMBcxFTATBgNVBAMU
 600 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAsxG7LTrz
 601 DF+9wegOR/BRJhjSumPUbYQnNAUKtPraFsGjAJILP44AHdnHt1MONLgTeX1ynapo
 602 q6O/q5cdKtBB7uEh7FpkLCCwpZt/m0y79cynn8AmWoQVgl8oS0567UmPeJnTzFPv
 603 dmT5dlaQALeX5YGceAsEvhmAsdOMttaor38CAwEAATANBgkqhkiG9w0BAQQFAAOB
 604 gQA345rxotfvh2kfgrmRzAyGewVBV4r23Go30GSZir8X2GoH3qKNwO4SekAohuSw
 605 AiXzLUbwIdSRSqaLFxSC7Duqc9eIeFDAWjeEmpfFLBNiw3K8SLA00QrHCUXnECTD
 606 b/Kk6OGuvPOiuuONVjEuEcRdCH3/Li30D0AhJaMynjhQJQ==
 607 -----END CERTIFICATE-----
 608 -----BEGIN RSA PRIVATE KEY-----
 609 MIICXQIBAAKBgQCzEbstOvMMX73B6A5H8FEmGNK6Y9RthCc0BQq0+toWwaMAkgs/
 610 jgAd2ce3Uw40uBN5fXKdqmiro7+rlx0q0EHu4SHsWmQsILClm3+bTLv1zKefwCZa
 611 hBWCXyhLTnrtSY94mdPMU+92ZPl2VpAAt5flgZx4CwS+GYCx04y21qivfwIDAQAB
 612 AoGBAIlhFg/aRPL+VM9539LzHN60dp8GzceDdqwjHhbAySZiQlLCuJx2rcI4/U65
 613 CpIJku9G/fLV9N2RkA/trDPXeGyqCTJfnNzyZcvvMscRMFqSGyc21Y0a+GS8bIxt
 614 1R2B18epSVMsWSWWMypeEgsfv29LV7oSWG8UKaqQ9+0h63DhAkEA4i2L/rori/Fb
 615 wpIBfA+xbXL/GmWR7xPW+3nG3LdLQpVzxz4rIsmtO9hIXzvYpcufQbwgVACyMmRf
 616 TMABeSDM7wJBAMquEdTaVXjGfH0EJ7z95Ys2rYTiCXjBfyEOi6RXXReqV9SXNKlN
 617 aKsO22zYecpkAjY1EdUdXWP/mNVEybjpZnECQQCcuh0JPS5RwcTo9c2rjyBOjGIz
 618 g3B1b5UIG2FurmCrWe6pgO3ZJFEzZ/L2cvz0Hj5UCa2JKBZTDvRutZoPumfnAkAb
 619 nSW+y1Rz1Q8m9Ub4v9rjYbq4bRd/RVWtyk6KQIDldYbr5wH8wxgsniSVKtVFFuUa
 620 P5bDY3HS6wMGo42cTOhxAkAcdweQSQ3j7mfc5vh71HeAC1v/VAKGehGOUdeEIQNl
 621 Sb2WuzpZkbfsrVzW6MdlgY6eE7ufRswhDPLWPC8MP0d1
 622 -----END RSA PRIVATE KEY-----
 623 """, # 2
 624 """-----BEGIN CERTIFICATE-----
 625 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 626 aW5neTAeFw0wODA3MjUyMjQyMDZaFw0wOTA3MjUyMjQyMDZaMBcxFTATBgNVBAMU
 627 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAxnH+pbOS
 628 qlJlsHpKUQtV0oN1Mv+ESG+yUDxStFFGjkJv/UIRzpxqFqY/6nJ3D03kZsDdcXyi
 629 CfV9hPYQaVNMn6z+puPmIagfBQ0aOyuI+nUhCttZIYD9071BjW5bCMX5NZWL/CZm
 630 E0HdAZ77H6UrRckJ7VR8wAFpihBxD5WliZcCAwEAATANBgkqhkiG9w0BAQQFAAOB
 631 gQAwXqY1Sjvp9JSTHKklu7s0T6YmH/BKSXrHpS2xO69svK+ze5/+5td3jPn4Qe50
 632 xwRNZSFmSLuJLfCO32QJSJTB7Vs5D3dNTZ2i8umsaodm97t8hit7L75nXRGHKH//
 633 xDVWAFB9sSgCQyPMRkL4wB4YSfRhoSKVwMvaz+XRZDUU0A==
 634 -----END CERTIFICATE-----
 635 -----BEGIN RSA PRIVATE KEY-----
 636 MIICXAIBAAKBgQDGcf6ls5KqUmWwekpRC1XSg3Uy/4RIb7JQPFK0UUaOQm/9QhHO
 637 nGoWpj/qcncPTeRmwN1xfKIJ9X2E9hBpU0yfrP6m4+YhqB8FDRo7K4j6dSEK21kh
 638 gP3TvUGNblsIxfk1lYv8JmYTQd0BnvsfpStFyQntVHzAAWmKEHEPlaWJlwIDAQAB
 639 AoGAdHNMlXwtItm7ZrY8ihZ2xFP0IHsk60TwhHkBp2LSXoTKJvnwbSgIcUYZ18BX
 640 8Zkp4MpoqEIU7HcssyuaMdR572huV2w0D/2gYJQLQ5JapaR3hMox3YG4wjXasN1U
 641 1iZt7JkhKlOy+ElL5T9mKTE1jDsX2RAv4WALzMpYFo7vs4ECQQDxqrPaqRQ5uYS/
 642 ejmIk05nM3Q1zmoLtMDrfRqrjBhaf/W3hqGihiqN2kL3PIIYcxSRWiyNlYXjElsR
 643 2sllBTe3AkEA0jcMHVThwKt1+Ce5VcE7N6hFfbsgISTjfJ+Q3K2NkvJkmtE8ZRX5
 644 XprssnPN8owkfF5yuKbcSZL3uvaaSGN9IQJAfTVnN9wwOXQwHhDSbDt9/KRBCnum
 645 n+gHqDrKLaVJHOJ9SZf8eLswoww5c+UqtkYxmtlwie61Tp+9BXQosilQ4wJBAIZ1
 646 XVNZmriBM4jR59L5MOZtxF0ilu98R+HLsn3kqLyIPF9mXCoQPxwLHkEan213xFKk
 647 mt6PJDIPRlOZLqAEuuECQFQMCrn0VUwPg8E40pxMwgMETvVflPs/oZK1Iu+b7+WY
 648 vBptAyhMu31fHQFnJpiUOyHqSZnOZyEn1Qu2lszNvUg=
 649 -----END RSA PRIVATE KEY-----
 650 """, # 3
 651 """-----BEGIN CERTIFICATE-----
 652 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 653 aW5neTAeFw0wODA3MjUyMjQyMDZaFw0wOTA3MjUyMjQyMDZaMBcxFTATBgNVBAMU
 654 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAnjiOwipn
 655 jigDuNMfNG/tBJhPwYUHhSbQdvrTubhsxw1oOq5XpNqUwRtC8hktOKM3hghyqExP
 656 62EOi0aJBkRhtwtPSLBCINptArZLfkog/nTIqVv4eLEzJ19nTi/llHHWKcgA6XTI
 657 sU/snUhGlySA3RpETvXqIJTauQRZz0kToSUCAwEAATANBgkqhkiG9w0BAQQFAAOB
 658 gQCQ+u/CsX5WC5m0cLrpyIS6qZa62lrB3mj9H1aIQhisT5kRsMz3FJ1aOaS8zPRz
 659 w0jhyRmamCcSsWf5WK539iOtsXbKMdAyjNtkQO3g+fnsLgmznAjjst24jfr+XU59
 660 0amiy1U6TY93gtEBZHtiLldPdUMsTuFbBlqbcMBQ50x9rA==
 661 -----END CERTIFICATE-----
 662 -----BEGIN RSA PRIVATE KEY-----
 663 MIICXAIBAAKBgQCeOI7CKmeOKAO40x80b+0EmE/BhQeFJtB2+tO5uGzHDWg6rlek
 664 2pTBG0LyGS04ozeGCHKoTE/rYQ6LRokGRGG3C09IsEIg2m0Ctkt+SiD+dMipW/h4
 665 sTMnX2dOL+WUcdYpyADpdMixT+ydSEaXJIDdGkRO9eoglNq5BFnPSROhJQIDAQAB
 666 AoGAAPrst3s3xQOucjismtCOsVaYN+SxFTwWUoZfRWlFEz6cBLELzfOktEWM9p79
 667 TrqEH4px22UNobGqO2amdql5yXwEFVhYQkRB8uDA8uVaqpL8NLWTGPRXxZ2DSU+n
 668 7/FLf/TWT3ti/ZtXaPVRj6E2/Mq9AVEVOjUYzkNjM02OxcECQQDKEqmPbdZq2URU
 669 7RbUxkq5aTp8nzAgbpUsgBGQ9PDAymhj60BDEP0q28Ssa7tU70pRnQ3AZs9txgmL
 670 kK2g97FNAkEAyHH9cIb6qXOAJPIr/xamFGr5uuYw9TJPz/hfVkVimW/aZnBB+e6Q
 671 oALJBDKJWeYPzdNbouJYg8MeU0qWdZ5DOQJADUk+1sxc/bd9U6wnBSRog1pU2x7I
 672 VkmPC1b8ULCaJ8LnLDKqjf5O9wNuIfwPXB1DoKwX3F+mIcyUkhWYJO5EPQJAUj5D
 673 KMqZSrGzYHVlC/M1Daee88rDR7fu+3wDUhiCDkbQq7tftrbl7GF4LRq3NIWq8l7I
 674 eJq6isWiSbaO6Y+YMQJBAJFBpVhlY5Px2BX5+Hsfq6dSP3sVVc0eHkdsoZFFxq37
 675 fksL/q2vlPczvBihgcxt+UzW/UrNkelOuX3i57PDvFs=
 676 -----END RSA PRIVATE KEY-----
 677 """, # 4
 678 """-----BEGIN CERTIFICATE-----
 679 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 680 aW5neTAeFw0wODA3MjUyMjQyMDZaFw0wOTA3MjUyMjQyMDZaMBcxFTATBgNVBAMU
 681 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAsCQuudDF
 682 zgmY5tDpT0TkUo8fpJ5JcvgCkLFpSDD8REpXhLFkHWhTmTj3CAxfv4lA3sQzHZxe
 683 4S9YCb5c/VTbFEdgwc/wlxMmJiz2jYghdmWPBb8pBEk31YihIhC+u4kex6gJBH5y
 684 ixiZ3PPRRMaOBBo+ZfM50XIyWbFOOM/7FwcCAwEAATANBgkqhkiG9w0BAQQFAAOB
 685 gQB4cFURaiiUx6n8eS4j4Vxrii5PtsaNEI4acANFSYknGd0xTP4vnmoivNmo5fWE
 686 Q4hYtGezNu4a9MnNhcQmI20KzXmvhLJtkwWCgGOVJtMem8hDWXSALV1Ih8hmVkGS
 687 CI1elfr9eyguunGp9eMMQfKhWH52WHFA0NYa0Kpv5BY33A==
 688 -----END CERTIFICATE-----
 689 -----BEGIN RSA PRIVATE KEY-----
 690 MIICWwIBAAKBgQCwJC650MXOCZjm0OlPRORSjx+knkly+AKQsWlIMPxESleEsWQd
 691 aFOZOPcIDF+/iUDexDMdnF7hL1gJvlz9VNsUR2DBz/CXEyYmLPaNiCF2ZY8FvykE
 692 STfViKEiEL67iR7HqAkEfnKLGJnc89FExo4EGj5l8znRcjJZsU44z/sXBwIDAQAB
 693 AoGABA7xXKqoxBSIh1js5zypHhXaHsre2l1Igdj0mgs25MPpvE7yBZNvyan8Vx0h
 694 36Hj8r4Gh3og3YNfvem67sNTwNwONY0ep+Xho/3vG0jFATGduSXdcT04DusgZNqg
 695 UJqW75cqxrD6o/nya5wUoN9NL5pcd5AgVMdOYvJGbrwQuaECQQDiCs/5dsUkUkeC
 696 Tlur1wh0wJpW4Y2ctO3ncRdnAoAA9y8dELHXMqwKE4HtlyzHY7Bxds/BDh373EVK
 697 rsdl+v9JAkEAx3xTmsOQvWa1tf/O30sdItVpGogKDvYqkLCNthUzPaL85BWB03E2
 698 xunHcVVlqAOE5tFuw0/UEyEkOaGlNTJTzwJAPIVel9FoCUiKYuYt/z1swy3KZRaw
 699 /tMmm4AZHvh5Y0jLcYHFy/OCQpRkhkOitqQHWunPyEXKW2PnnY5cTv68GQJAHG7H
 700 B88KCUTjb25nkQIGxBlA4swzCtDhXkAb4rEA3a8mdmfuWjHPyeg2ShwO4jSmM7P0
 701 Iph1NMjLff9hKcTjlwJARpItOFkYEdtSODC7FMm7KRKQnNB27gFAizsOYWD4D2b7
 702 w1FTEZ/kSA9wSNhyNGt7dgUo6zFhm2u973HBCUb3dg==
 703 -----END RSA PRIVATE KEY-----
 704 """, # 5
 705 """-----BEGIN CERTIFICATE-----
 706 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 707 aW5neTAeFw0wODA3MjUyMjQ3NThaFw0wOTA3MjUyMjQ3NThaMBcxFTATBgNVBAMU
 708 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAvhTRj1dA
 709 NOfse/UBeTfMekZKxZHsNPr+qBYaveWAHDded/BMyMgaMV2n6HQdiDaRjJkzjHCF
 710 3xBtpIJeEGUqfrF0ob8BIZXy3qk68eX/0CVUbgmjSBN44ahlo63NshyXmZtEAkRV
 711 VE/+cRKw3N2wtuTed5xwfNcL6dg4KTOEYEkCAwEAATANBgkqhkiG9w0BAQQFAAOB
 712 gQCN+CLuVwLeWjSdVbdizYyrOVckqtwiIHG9BbGMlcIdm0qpvD7V7/sN2csk5LaT
 713 BNiHi1t5628/4UHqqodYmFw8ri8ItFwB+MmTJi11CX6dIP9OUhS0qO8Z/BKtot7H
 714 j04oNwl+WqZZfHIYwTIEL0HBn60nOvCQPDtnWG2BhpUxMA==
 715 -----END CERTIFICATE-----
 716 -----BEGIN RSA PRIVATE KEY-----
 717 MIICXQIBAAKBgQC+FNGPV0A05+x79QF5N8x6RkrFkew0+v6oFhq95YAcN1538EzI
 718 yBoxXafodB2INpGMmTOMcIXfEG2kgl4QZSp+sXShvwEhlfLeqTrx5f/QJVRuCaNI
 719 E3jhqGWjrc2yHJeZm0QCRFVUT/5xErDc3bC25N53nHB81wvp2DgpM4RgSQIDAQAB
 720 AoGALl2BqIdN4Bnac3oV++2CcSkIQB0SEvJOf820hDGhCEDxSCxTbn5w9S21MVxx
 721 f7Jf2n3cNxuTbA/jzscGDtW+gXCs+WAbAr5aOqHLUPGEobhKQrQT2hrxQHyv3UFp
 722 0tIl9eXFknOyVAaUJ3athK5tyjSiCZQQHLGzeLaDSKVAPqECQQD1GK7DkTcLaSvw
 723 hoTJ3dBK3JoKT2HHLitfEE0QV58mkqFMjofpe+nyeKWvEb/oB4WBp/cfTvtf7DJK
 724 zl1OSf11AkEAxomWmJeub0xpqksCmnVI1Jt1mvmcE4xpIcXq8sxzLHRc2QOv0kTw
 725 IcFl4QcN6EQBmE+8kl7Tx8SPAVKfJMoZBQJAGsUFYYrczjxAdlba7glyFJsfn/yn
 726 m0+poQpwwFYxpc7iGzB+G7xTAw62WfbAVSFtLYog7aR8xC9SFuWPP1vJeQJBAILo
 727 xBj3ovgWTXIRJbVM8mnl28UFI0msgsHXK9VOw/6i93nMuYkPFbtcN14KdbwZ42dX
 728 5EIrLr+BNr4riW4LqDUCQQCbsEEpTmj3upKUOONPt+6CH/OOMjazUzYHZ/3ORHGp
 729 Q3Wt+I4IrR/OsiACSIQAhS4kBfk/LGggnj56DrWt+oBl
 730 -----END RSA PRIVATE KEY-----
 731 """, #6
 732 """-----BEGIN CERTIFICATE-----
 733 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 734 aW5neTAeFw0wODA3MjUyMjQ3NThaFw0wOTA3MjUyMjQ3NThaMBcxFTATBgNVBAMU
 735 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAtKhx6sEA
 736 jn6HWc6T2klwlPn0quyHtATIw8V3ezP46v6g2rRS7dTywo4GTP4vX58l+sC9z9Je
 737 qhQ1rWSwMK4FmnDMZCu7AVO7oMIXpXdSz7l0bgCnNjvbpkA2pOfbB1Z8oj8iebff
 738 J33ID5DdkmCzqYVtKpII1o/5z7Jo292JYy8CAwEAATANBgkqhkiG9w0BAQQFAAOB
 739 gQA0PYMA07wo9kEH4fv9TCfo+zz42Px6lUxrQBPxBvDiGYhk2kME/wX0IcoZPKTV
 740 WyBGmDAYWvFaHWbrbbTOfzlLWfYrDD913hCi9cO8iF8oBqRjIlkKcxAoe7vVg5Az
 741 ydVcrY+zqULJovWwyNmH1QNIQfMat0rj7fylwjiS1y/YsA==
 742 -----END CERTIFICATE-----
 743 -----BEGIN RSA PRIVATE KEY-----
 744 MIICXAIBAAKBgQC0qHHqwQCOfodZzpPaSXCU+fSq7Ie0BMjDxXd7M/jq/qDatFLt
 745 1PLCjgZM/i9fnyX6wL3P0l6qFDWtZLAwrgWacMxkK7sBU7ugwheld1LPuXRuAKc2
 746 O9umQDak59sHVnyiPyJ5t98nfcgPkN2SYLOphW0qkgjWj/nPsmjb3YljLwIDAQAB
 747 AoGAU4CYRv22mCZ7wVLunDLdyr5ODMMPZnHfqj2XoGbBYz0WdIBs5GlNXAfxeZzz
 748 oKsbDvAPzANcphh5RxAHMDj/dT8rZOez+eJrs1GEV+crl1T9p83iUkAuOJFtgUgf
 749 TtQBL9vHaj7DfvCEXcBPmN/teDFmAAOyUNbtuhTkRa3PbuECQQDwaqZ45Kr0natH
 750 V312dqlf9ms8I6e873pAu+RvA3BAWczk65eGcRjEBxVpTvNEcYKFrV8O5ZYtolrr
 751 VJl97AfdAkEAwF4w4KJ32fLPVoPnrYlgLw86NejMpAkixblm8cn51avPQmwbtahb
 752 BZUuca22IpgDpjeEk5SpEMixKe/UjzxMewJBALy4q2cY8U3F+u6sshLtAPYQZIs3
 753 3fNE9W2dUKsIQvRwyZMlkLN7UhqHCPq6e+HNTM0MlCMIfAPkf4Rdy4N6ZY0CQCKE
 754 BAMaQ6TwgzFDw5sIjiCDe+9WUPmRxhJyHL1/fvtOs4Z4fVRP290ZklbFU2vLmMQH
 755 LBuKzfb7+4XJyXrV1+cCQBqfPFQQZLr5UgccABYQ2jnWVbJPISJ5h2b0cwXt+pz/
 756 8ODEYLjqWr9K8dtbgwdpzwbkaGhQYpyvsguMvNPMohs=
 757 -----END RSA PRIVATE KEY-----
 758 """, #7
 759 """-----BEGIN CERTIFICATE-----
 760 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 761 aW5neTAeFw0wODA3MjUyMjQ3NThaFw0wOTA3MjUyMjQ3NThaMBcxFTATBgNVBAMU
 762 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAnBfNHycn
 763 5RnYzDN4EWTk2q1BBxA6ZYtlG1WPkj5iKeaYKzUk58zBL7mNOA0ucq+yTwh9C4IC
 764 EutWPaKBSKY5XI+Rdebh+Efq+urtOLgfJHlfcCraEx7hYN+tqqMVgEgnO/MqIsn1
 765 I1Fvnp89mSYbQ9tmvhSH4Hm+nbeK6iL2tIsCAwEAATANBgkqhkiG9w0BAQQFAAOB
 766 gQBt9zxfsKWoyyV764rRb6XThuTDMNSDaVofqePEWjudAbDu6tp0pHcrL0XpIrnT
 767 3iPgD47pdlwQNbGJ7xXwZu2QTOq+Lv62E6PCL8FljDVoYqR3WwJFFUigNvBT2Zzu
 768 Pxx7KUfOlm/M4XUSMu31sNJ0kQniBwpkW43YmHVNFb/R7g==
 769 -----END CERTIFICATE-----
 770 -----BEGIN RSA PRIVATE KEY-----
 771 MIICXQIBAAKBgQCcF80fJyflGdjMM3gRZOTarUEHEDpli2UbVY+SPmIp5pgrNSTn
 772 zMEvuY04DS5yr7JPCH0LggIS61Y9ooFIpjlcj5F15uH4R+r66u04uB8keV9wKtoT
 773 HuFg362qoxWASCc78yoiyfUjUW+enz2ZJhtD22a+FIfgeb6dt4rqIva0iwIDAQAB
 774 AoGBAIHstcnWd7iUeQYPWUNxLaRvTY8pjNH04yWLZEOgNWkXDVX5mExw++RTmB4t
 775 qpm/cLWkJSEtB7jjthb7ao0j/t2ljqfr6kAbClDv3zByAEDhOu8xB/5ne6Ioo+k2
 776 dygC+GcVcobhv8qRU+z0fpeXSP8yS1bQQHOaa17bSGsncvHRAkEAzwsn8jBTOqaW
 777 6Iymvr7Aql++LiwEBrqMMRVyBZlkux4hiKa2P7XXEL6/mOPR0aI2LuCqE2COrO7R
 778 0wAFZ54bjwJBAMEAe6cs0zI3p3STHwA3LoSZB81lzLhGUnYBvOq1yoDSlJCOYpld
 779 YM1y3eC0vwiOnEu3GG1bhkW+h6Kx0I/qyUUCQBiH9NqwORxI4rZ4+8S76y4EnA7y
 780 biOx9KxYIyNgslutTUHYpt1TmUDFqQPfclvJQWw6eExFc4Iv5bJ/XSSSyicCQGyY
 781 5PrwEfYTsrm5fpwUcKxTnzxHp6WYjBWybKZ0m/lYhBfCxmAdVrbDh21Exqj99Zv0
 782 7l26PhdIWfGFtCEGrzECQQCtPyXa3ostSceR7zEKxyn9QBCNXKARfNNTBja6+VRE
 783 qDC6jLqzu/SoOYaqa13QzCsttO2iZk8Ygfy3Yz0n37GE
 784 -----END RSA PRIVATE KEY-----
 785 """, #8
 786 """-----BEGIN CERTIFICATE-----
 787 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 788 aW5neTAeFw0wODA3MjUyMjQ3NThaFw0wOTA3MjUyMjQ3NThaMBcxFTATBgNVBAMU
 789 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA4mnLf+x0
 790 CWKDKP5PLZ87t2ReSDE/J5QoI5VhE0bXaahdhPrQTC2wvOpT+N9nzEpI9ASh/ejV
 791 kYGlc03nNKRL7zyVM1UyGduEwsRssFMqfyJhI1p+VmxDMWNplex7mIAheAdskPj3
 792 pwi2CP4VIMjOj368AXvXItPzeCfAhYhEVaMCAwEAATANBgkqhkiG9w0BAQQFAAOB
 793 gQAEzmwq5JFI5Z0dX20m9rq7NKgwRyAH3h5aE8bdjO8nEc69qscfDRx79Lws3kK8
 794 A0LG0DhxKB8cTNu3u+jy81tjcC4pLNQ5IKap9ksmP7RtIHfTA55G8M3fPl2ZgDYQ
 795 ZzsWAZvTNXd/eme0SgOzD10rfntA6ZIgJTWHx3E0RkdwKw==
 796 -----END CERTIFICATE-----
 797 -----BEGIN RSA PRIVATE KEY-----
 798 MIICXQIBAAKBgQDiact/7HQJYoMo/k8tnzu3ZF5IMT8nlCgjlWETRtdpqF2E+tBM
 799 LbC86lP432fMSkj0BKH96NWRgaVzTec0pEvvPJUzVTIZ24TCxGywUyp/ImEjWn5W
 800 bEMxY2mV7HuYgCF4B2yQ+PenCLYI/hUgyM6PfrwBe9ci0/N4J8CFiERVowIDAQAB
 801 AoGAQYTl+8XcKl8Un4dAOG6M5FwqIHAH25c3Klzu85obehrbvUCriG/sZi7VT/6u
 802 VeLlS6APlJ+NNgczbrOLhaNJyYzjICSt8BI96PldFUzCEkVlgE+29pO7RNoZmDYB
 803 dSGyIDrWdVYfdzpir6kC0KDcrpA16Sc+/bK6Q8ALLRpC7QECQQD7F7fhIQ03CKSk
 804 lS4mgDuBQrB/52jXgBumtjp71ANNeaWR6+06KDPTLysM+olsh97Q7YOGORbrBnBg
 805 Y2HPnOgjAkEA5taZaMfdFa8V1SPcX7mgCLykYIujqss0AmauZN/24oLdNE8HtTBF
 806 OLaxE6PnQ0JWfx9KGIy3E0V3aFk5FWb0gQJBAO4KFEaXgOG1jfCBhNj3JHJseMso
 807 5Nm4F366r0MJQYBHXNGzqphB2K/Svat2MKX1QSUspk2u/a0d05dtYCLki6UCQHWS
 808 sChyQ+UbfF9HGKOZBC3vBzo1ZXNEdIUUj5bJjBHq3YgbCK38nAU66A482TmkvDGb
 809 Wj4OzeB+7Ua0yyJfggECQQDVlAa8HqdAcrbEwI/YfPydFsavBJ0KtcIGK2owQ+dk
 810 dhlDnpXDud/AtX4Ft2LaquQ15fteRrYjjwI9SFGytjtp
 811 -----END RSA PRIVATE KEY-----
 812 """, #9
 813 """-----BEGIN CERTIFICATE-----
 814 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 815 aW5neTAeFw0wODA3MjUyMjQ3NThaFw0wOTA3MjUyMjQ3NThaMBcxFTATBgNVBAMU
 816 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAueLfowPT
 817 kXXtHeU2FZSz2mJhHmjqeyI1oMoyyggonccx65vMxaRfljnz2dOjVVYpCOn/LrdP
 818 wVxHO8KNDsmQeWPRjnnBa2dFqqOnp/8gEJFJBW7K/gI9se6o+xe9QIWBq6d/fKVR
 819 BURJe5TycLogzZuxQn1xHHILa3XleYuHAbMCAwEAATANBgkqhkiG9w0BAQQFAAOB
 820 gQBEC1lfC3XK0galQC96B7faLpnQmhn5lX2FUUoFIQQtBTetoE+gTqnLSOIZcOK4
 821 pkT3YvxUvgOV0LOLClryo2IknMMGWRSAcXtVUBBLRHVTSSuVUyyLr5kdRU7B4E+l
 822 OU0j8Md/dzlkm//K1bzLyUaPq204ofH8su2IEX4b3IGmAQ==
 823 -----END CERTIFICATE-----
 824 -----BEGIN RSA PRIVATE KEY-----
 825 MIICWwIBAAKBgQC54t+jA9ORde0d5TYVlLPaYmEeaOp7IjWgyjLKCCidxzHrm8zF
 826 pF+WOfPZ06NVVikI6f8ut0/BXEc7wo0OyZB5Y9GOecFrZ0Wqo6en/yAQkUkFbsr+
 827 Aj2x7qj7F71AhYGrp398pVEFREl7lPJwuiDNm7FCfXEccgtrdeV5i4cBswIDAQAB
 828 AoGAO4PnJHNaLs16AMNdgKVevEIZZDolMQ1v7C4w+ryH/JRFaHE2q+UH8bpWV9zK
 829 A82VT9RTrqpkb71S1VBiB2UDyz263XdAI/N2HcIVMmfKb72oV4gCI1KOv4DfFwZv
 830 tVVcIdVEDBOZ2TgqK4opGOgWMDqgIAl2z3PbsIoNylZHEJECQQDtQeJFhEJGH4Qz
 831 BGpdND0j2nnnJyhOFHJqikJNdul3uBwmxTK8FPEUUH/rtpyUan3VMOyDx3kX4OQg
 832 GDNSb32rAkEAyJIZIJ0EMRHVedyWsfqR0zTGKRQ+qsc3sCfyUhFksWms9jsSS0DT
 833 tVeTdC3F6EIAdpKOGhSyfBTU4jxwbFc0GQJADI4L9znEeAl66Wg2aLA2/Aq3oK/F
 834 xjv2wgSG9apxOFCZzMNqp+FD0Jth6YtEReZMuldYbLDFi6nu6HPfY2Fa+QJAdpm1
 835 lAxk6yMxiZK/5VRWoH6HYske2Vtd+aNVbePtF992ME/z3F3kEkpL3hom+dT1cyfs
 836 MU3l0Ot8ip7Ul6vlGQJAegNzpcfl2GFSdWQMxQ+nN3woKnPqpR1M3jgnqvo7L4Xe
 837 JW3vRxvfdrUuzdlvZ/Pbsu/vOd+cuIa4h0yD5q3N+g==
 838 -----END RSA PRIVATE KEY-----
 839 """, #10
 840 """-----BEGIN CERTIFICATE-----
 841 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 842 aW5neTAeFw0wODA3MjUyMjQ3NThaFw0wOTA3MjUyMjQ3NThaMBcxFTATBgNVBAMU
 843 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAruBhwk+J
 844 XdlwfKXXN8K+43JyEYCV7Fp7ZiES4t4AEJuQuBqJVMxpzeZzu2t/vVb59ThaxxtY
 845 NGD3Xy6Og5dTv//ztWng8P7HwwvfbrUICU6zo6JAhg7kfaNa116krCYOkC/cdJWt
 846 o5W+zsDmI1jUVGH0D73h29atc1gn6wLpAsMCAwEAATANBgkqhkiG9w0BAQQFAAOB
 847 gQAEJ/ITGJ9lK/rk0yHcenW8SHsaSTlZMuJ4yEiIgrJ2t71Rd6mtCC/ljx9USvvK
 848 bF500whTiZlnWgKi02boBEKa44z/DytF6pljeNPefBQSqZyUByGEb/8Mn58Idyls
 849 q4/d9iKXMPvbpQdcesOzgOffFZevLQSWyPRaIdYBOOiYUA==
 850 -----END CERTIFICATE-----
 851 -----BEGIN RSA PRIVATE KEY-----
 852 MIICXQIBAAKBgQCu4GHCT4ld2XB8pdc3wr7jcnIRgJXsWntmIRLi3gAQm5C4GolU
 853 zGnN5nO7a3+9Vvn1OFrHG1g0YPdfLo6Dl1O///O1aeDw/sfDC99utQgJTrOjokCG
 854 DuR9o1rXXqSsJg6QL9x0la2jlb7OwOYjWNRUYfQPveHb1q1zWCfrAukCwwIDAQAB
 855 AoGAcZAXC/dYrlBpIxkTRQu7qLqGZuVI9t7fabgqqpceFargdR4Odrn0L5jrKRer
 856 MYrM8bjyAoC4a/NYUUBLnhrkcCQWO9q5fSQuFKFVWHY53SM63Qdqk8Y9Fmy/h/4c
 857 UtwZ5BWkUWItvnTMgb9bFcvSiIhEcNQauypnMpgNknopu7kCQQDlSQT10LkX2IGT
 858 bTUhPcManx92gucaKsPONKq2mP+1sIciThevRTZWZsxyIuoBBY43NcKKi8NlZCtj
 859 hhSbtzYdAkEAw0B93CXfso8g2QIMj/HJJz/wNTLtg+rriXp6jh5HWe6lKWRVrce+
 860 1w8Qz6OI/ZP6xuQ9HNeZxJ/W6rZPW6BGXwJAHcTuRPA1p/fvUvHh7Q/0zfcNAbkb
 861 QlV9GL/TzmNtB+0EjpqvDo2g8XTlZIhN85YCEf8D5DMjSn3H+GMHN/SArQJBAJlW
 862 MIGPjNoh5V4Hae4xqBOW9wIQeM880rUo5s5toQNTk4mqLk9Hquwh/MXUXGUora08
 863 2XGpMC1midXSTwhaGmkCQQCdivptFEYl33PrVbxY9nzHynpp4Mi89vQF0cjCmaYY
 864 N8L+bvLd4BU9g6hRS8b59lQ6GNjryx2bUnCVtLcey4Jd
 865 -----END RSA PRIVATE KEY-----
 866 """, #11
 867 ]
 868
 869 # To disable the pre-computed tub certs, uncomment this line.
 870 #SYSTEM_TEST_CERTS = []
 871
 872 TEST_DATA="\x02"*(immutable.upload.Uploader.URI_LIT_SIZE_THRESHOLD+1)
 873
 874 class ShareManglingMixin(SystemTestMixin):
 875
 876     def setUp(self):
 877         # Set self.basedir to a temp dir which has the name of the current test method in its
 878         # name.
 879         self.basedir = self.mktemp()
 880
 881         d = defer.maybeDeferred(SystemTestMixin.setUp, self)
 882         d.addCallback(lambda x: self.set_up_nodes())
 883
 884         def _upload_a_file(ignored):
 885             cl0 = self.clients[0]
 886             # We need multiple segments to test crypttext hash trees that are non-trivial
 887             # (i.e. they have more than just one hash in them).
 888             cl0.DEFAULT_ENCODING_PARAMETERS['max_segment_size'] = 12
 889             d2 = cl0.upload(immutable.upload.Data(TEST_DATA, convergence=""))
 890             def _after_upload(u):
 891                 self.uri = IURI(u.uri)
 892                 return cl0.create_node_from_uri(self.uri)
 893             d2.addCallback(_after_upload)
 894             return d2
 895         d.addCallback(_upload_a_file)
 896
 897         def _stash_it(filenode):
 898             self.filenode = filenode
 899         d.addCallback(_stash_it)
 900         return d
 901
 902     def find_shares(self, unused=None):
 903         """Locate shares on disk. Returns a dict that maps
 904         (clientnum,sharenum) to a string that contains the share container
 905         (copied directly from the disk, containing leases etc). You can
 906         modify this dict and then call replace_shares() to modify the shares.
 907         """
 908         shares = {} # k: (i, sharenum), v: data
 909
 910         for i, c in enumerate(self.clients):
 911             sharedir = c.getServiceNamed("storage").sharedir
 912             for (dirp, dirns, fns) in os.walk(sharedir):
 913                 for fn in fns:
 914                     try:
 915                         sharenum = int(fn)
 916                     except TypeError:
 917                         # Whoops, I guess that's not a share file then.
 918                         pass
 919                     else:
 920                         data = open(os.path.join(sharedir, dirp, fn), "r").read()
 921                         shares[(i, sharenum)] = data
 922
 923         return shares
 924
 925     def replace_shares(self, newshares, storage_index):
 926         """Replace shares on disk. Takes a dictionary in the same form
 927         as find_shares() returns."""
 928
 929         for i, c in enumerate(self.clients):
 930             sharedir = c.getServiceNamed("storage").sharedir
 931             for (dirp, dirns, fns) in os.walk(sharedir):
 932                 for fn in fns:
 933                     try:
 934                         sharenum = int(fn)
 935                     except TypeError:
 936                         # Whoops, I guess that's not a share file then.
 937                         pass
 938                     else:
 939                         pathtosharefile = os.path.join(sharedir, dirp, fn)
 940                         os.unlink(pathtosharefile)
 941             for ((clientnum, sharenum), newdata) in newshares.iteritems():
 942                 if clientnum == i:
 943                     fullsharedirp=os.path.join(sharedir, storage_index_to_dir(storage_index))
 944                     fileutil.make_dirs(fullsharedirp)
 945                     wf = open(os.path.join(fullsharedirp, str(sharenum)), "w")
 946                     wf.write(newdata)
 947
 948     def _delete_a_share(self, unused=None, sharenum=None):
 949         """ Delete one share. """
 950
 951         shares = self.find_shares()
 952         ks = shares.keys()
 953         if sharenum is not None:
 954             k = [ key for key in shares.keys() if key[1] == sharenum ][0]
 955         else:
 956             k = random.choice(ks)
 957         del shares[k]
 958         self.replace_shares(shares, storage_index=self.uri.storage_index)
 959
 960         return unused
 961
 962     def _corrupt_a_share(self, unused, corruptor_func, sharenum):
 963         shares = self.find_shares()
 964         ks = [ key for key in shares.keys() if key[1] == sharenum ]
 965         assert ks, (shares.keys(), sharenum)
 966         k = ks[0]
 967         shares[k] = corruptor_func(shares[k])
 968         self.replace_shares(shares, storage_index=self.uri.storage_index)
 969         return corruptor_func
 970
 971     def _corrupt_all_shares(self, unused, corruptor_func):
 972         """ All shares on disk will be corrupted by corruptor_func. """
 973         shares = self.find_shares()
 974         for k in shares.keys():
 975             self._corrupt_a_share(unused, corruptor_func, k[1])
 976         return corruptor_func
 977
 978     def _corrupt_a_random_share(self, unused, corruptor_func):
 979         """ Exactly one share on disk will be corrupted by corruptor_func. """
 980         shares = self.find_shares()
 981         ks = shares.keys()
 982         k = random.choice(ks)
 983         self._corrupt_a_share(unused, corruptor_func, k[1])
 984         return corruptor_func
 985
 986     def _count_reads(self):
 987         sum_of_read_counts = 0
 988         for thisclient in self.clients:
 989             counters = thisclient.stats_provider.get_stats()['counters']
 990             sum_of_read_counts += counters.get('storage_server.read', 0)
 991         return sum_of_read_counts
 992
 993     def _count_allocates(self):
 994         sum_of_allocate_counts = 0
 995         for thisclient in self.clients:
 996             counters = thisclient.stats_provider.get_stats()['counters']
 997             sum_of_allocate_counts += counters.get('storage_server.allocate', 0)
 998         return sum_of_allocate_counts
 999
1000     def _count_writes(self):
1001         sum_of_write_counts = 0
1002         for thisclient in self.clients:
1003             counters = thisclient.stats_provider.get_stats()['counters']
1004             sum_of_write_counts += counters.get('storage_server.write', 0)
1005         return sum_of_write_counts
1006
1007     def _download_and_check_plaintext(self, unused=None):
1008         self.downloader = self.clients[1].getServiceNamed("downloader")
1009         d = self.downloader.download_to_data(self.uri)
1010
1011         def _after_download(result):
1012             self.failUnlessEqual(result, TEST_DATA)
1013         d.addCallback(_after_download)
1014         return d
1015
1016 class ShouldFailMixin:
1017     def shouldFail(self, expected_failure, which, substring,
1018                    callable, *args, **kwargs):
1019         """Assert that a function call raises some exception. This is a
1020         Deferred-friendly version of TestCase.assertRaises() .
1021
1022         Suppose you want to verify the following function:
1023
1024          def broken(a, b, c):
1025              if a < 0:
1026                  raise TypeError('a must not be negative')
1027              return defer.succeed(b+c)
1028
1029         You can use:
1030             d = self.shouldFail(TypeError, 'test name',
1031                                 'a must not be negative',
1032                                 broken, -4, 5, c=12)
1033         in your test method. The 'test name' string will be included in the
1034         error message, if any, because Deferred chains frequently make it
1035         difficult to tell which assertion was tripped.
1036
1037         The substring= argument, if not None, must appear inside the
1038         stringified Failure, or the test will fail.
1039         """
1040
1041         assert substring is None or isinstance(substring, str)
1042         d = defer.maybeDeferred(callable, *args, **kwargs)
1043         def done(res):
1044             if isinstance(res, failure.Failure):
1045                 res.trap(expected_failure)
1046                 if substring:
1047                     self.failUnless(substring in str(res),
1048                                     "substring '%s' not in '%s'"
1049                                     % (substring, str(res)))
1050             else:
1051                 self.fail("%s was supposed to raise %s, not get '%s'" %
1052                           (which, expected_failure, res))
1053         d.addBoth(done)
1054         return d
1055
1056 class WebErrorMixin:
1057     def explain_web_error(self, f):
1058         # an error on the server side causes the client-side getPage() to
1059         # return a failure(t.web.error.Error), and its str() doesn't show the
1060         # response body, which is where the useful information lives. Attach
1061         # this method as an errback handler, and it will reveal the hidden
1062         # message.
1063         f.trap(WebError)
1064         print "Web Error:", f.value, ":", f.value.response
1065         return f
1066 class ErrorMixin(WebErrorMixin):
1067     def explain_error(self, f):
1068         if f.check(defer.FirstError):
1069             print "First Error:", f.value.subFailure
1070         return f
1071
1072 class MemoryConsumer:
1073     implements(IConsumer)
1074     def __init__(self):
1075         self.chunks = []
1076         self.done = False
1077     def registerProducer(self, p, streaming):
1078         if streaming:
1079             # call resumeProducing once to start things off
1080             p.resumeProducing()
1081         else:
1082             while not self.done:
1083                 p.resumeProducing()
1084     def write(self, data):
1085         self.chunks.append(data)
1086     def unregisterProducer(self):
1087         self.done = True
1088
1089 def download_to_data(n, offset=0, size=None):
1090     d = n.read(MemoryConsumer(), offset, size)
1091     d.addCallback(lambda mc: "".join(mc.chunks))
1092     return d
1093
1094 def corrupt_field(data, offset, size, debug=False):
1095     if random.random() < 0.5:
1096         newdata = testutil.flip_one_bit(data, offset, size)
1097         if debug:
1098             log.msg("testing: corrupting offset %d, size %d flipping one bit orig: %r, newdata: %r" % (offset, size, data[offset:offset+size], newdata[offset:offset+size]))
1099         return newdata
1100     else:
1101         newval = testutil.insecurerandstr(size)
1102         if debug:
1103             log.msg("testing: corrupting offset %d, size %d randomizing field, orig: %r, newval: %r" % (offset, size, data[offset:offset+size], newval))
1104         return data[:offset]+newval+data[offset+size:]
1105
1106 def _corrupt_nothing(data):
1107     """ Leave the data pristine. """
1108     return data
1109
1110 def _corrupt_file_version_number(data):
1111     """ Scramble the file data -- the share file version number have one bit flipped or else
1112     will be changed to a random value."""
1113     return corrupt_field(data, 0x00, 4)
1114
1115 def _corrupt_size_of_file_data(data):
1116     """ Scramble the file data -- the field showing the size of the share data within the file
1117     will be set to one smaller. """
1118     return corrupt_field(data, 0x04, 4)
1119
1120 def _corrupt_sharedata_version_number(data):
1121     """ Scramble the file data -- the share data version number will have one bit flipped or
1122     else will be changed to a random value, but not 1 or 2."""
1123     return corrupt_field(data, 0x0c, 4)
1124     sharevernum = struct.unpack(">l", data[0x0c:0x0c+4])[0]
1125     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1126     newsharevernum = sharevernum
1127     while newsharevernum in (1, 2):
1128         newsharevernum = random.randrange(0, 2**32)
1129     newsharevernumbytes = struct.pack(">l", newsharevernum)
1130     return data[:0x0c] + newsharevernumbytes + data[0x0c+4:]
1131
1132 def _corrupt_sharedata_version_number_to_plausible_version(data):
1133     """ Scramble the file data -- the share data version number will
1134     be changed to 2 if it is 1 or else to 1 if it is 2."""
1135     sharevernum = struct.unpack(">l", data[0x0c:0x0c+4])[0]
1136     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1137     if sharevernum == 1:
1138         newsharevernum = 2
1139     else:
1140         newsharevernum = 1
1141     newsharevernumbytes = struct.pack(">l", newsharevernum)
1142     return data[:0x0c] + newsharevernumbytes + data[0x0c+4:]
1143
1144 def _corrupt_segment_size(data):
1145     """ Scramble the file data -- the field showing the size of the segment will have one
1146     bit flipped or else be changed to a random value. """
1147     sharevernum = struct.unpack(">l", data[0x0c:0x0c+4])[0]
1148     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1149     if sharevernum == 1:
1150         return corrupt_field(data, 0x0c+0x04, 4, debug=False)
1151     else:
1152         return corrupt_field(data, 0x0c+0x04, 8, debug=False)
1153
1154 def _corrupt_size_of_sharedata(data):
1155     """ Scramble the file data -- the field showing the size of the data within the share
1156     data will have one bit flipped or else will be changed to a random value. """
1157     sharevernum = struct.unpack(">l", data[0x0c:0x0c+4])[0]
1158     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1159     if sharevernum == 1:
1160         return corrupt_field(data, 0x0c+0x08, 4)
1161     else:
1162         return corrupt_field(data, 0x0c+0x0c, 8)
1163
1164 def _corrupt_offset_of_sharedata(data):
1165     """ Scramble the file data -- the field showing the offset of the data within the share
1166     data will have one bit flipped or else be changed to a random value. """
1167     sharevernum = struct.unpack(">l", data[0x0c:0x0c+4])[0]
1168     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1169     if sharevernum == 1:
1170         return corrupt_field(data, 0x0c+0x0c, 4)
1171     else:
1172         return corrupt_field(data, 0x0c+0x14, 8)
1173
1174 def _corrupt_offset_of_ciphertext_hash_tree(data):
1175     """ Scramble the file data -- the field showing the offset of the ciphertext hash tree
1176     within the share data will have one bit flipped or else be changed to a random value.
1177     """
1178     sharevernum = struct.unpack(">l", data[0x0c:0x0c+4])[0]
1179     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1180     if sharevernum == 1:
1181         return corrupt_field(data, 0x0c+0x14, 4, debug=False)
1182     else:
1183         return corrupt_field(data, 0x0c+0x24, 8, debug=False)
1184
1185 def _corrupt_offset_of_block_hashes(data):
1186     """ Scramble the file data -- the field showing the offset of the block hash tree within
1187     the share data will have one bit flipped or else will be changed to a random value. """
1188     sharevernum = struct.unpack(">l", data[0x0c:0x0c+4])[0]
1189     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1190     if sharevernum == 1:
1191         return corrupt_field(data, 0x0c+0x18, 4)
1192     else:
1193         return corrupt_field(data, 0x0c+0x2c, 8)
1194
1195 def _corrupt_offset_of_block_hashes_to_truncate_crypttext_hashes(data):
1196     """ Scramble the file data -- the field showing the offset of the block hash tree within the
1197     share data will have a multiple of hash size subtracted from it, thus causing the downloader
1198     to download an incomplete crypttext hash tree."""
1199     sharevernum = struct.unpack(">l", data[0x0c:0x0c+4])[0]
1200     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1201     if sharevernum == 1:
1202         curval = struct.unpack(">L", data[0x0c+0x18:0x0c+0x18+4])[0]
1203         newval = random.randrange(0, max(1, (curval/hashutil.CRYPTO_VAL_SIZE)/2))*hashutil.CRYPTO_VAL_SIZE
1204         newvalstr = struct.pack(">L", newval)
1205         return data[:0x0c+0x18]+newvalstr+data[0x0c+0x18+4:]
1206     else:
1207         curval = struct.unpack(">Q", data[0x0c+0x2c:0x0c+0x2c+8])[0]
1208         newval = random.randrange(0, max(1, (curval/hashutil.CRYPTO_VAL_SIZE)/2))*hashutil.CRYPTO_VAL_SIZE
1209         newvalstr = struct.pack(">Q", newval)
1210         return data[:0x0c+0x2c]+newvalstr+data[0x0c+0x2c+8:]
1211
1212 def _corrupt_offset_of_share_hashes(data):
1213     """ Scramble the file data -- the field showing the offset of the share hash tree within
1214     the share data will have one bit flipped or else will be changed to a random value. """
1215     sharevernum = struct.unpack(">l", data[0x0c:0x0c+4])[0]
1216     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1217     if sharevernum == 1:
1218         return corrupt_field(data, 0x0c+0x1c, 4)
1219     else:
1220         return corrupt_field(data, 0x0c+0x34, 8)
1221
1222 def _corrupt_offset_of_uri_extension(data):
1223     """ Scramble the file data -- the field showing the offset of the uri extension will
1224     have one bit flipped or else will be changed to a random value. """
1225     sharevernum = struct.unpack(">l", data[0x0c:0x0c+4])[0]
1226     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1227     if sharevernum == 1:
1228         return corrupt_field(data, 0x0c+0x20, 4)
1229     else:
1230         return corrupt_field(data, 0x0c+0x3c, 8)
1231
1232 def _corrupt_offset_of_uri_extension_to_force_short_read(data, debug=False):
1233     """ Scramble the file data -- the field showing the offset of the uri extension will be set
1234     to the size of the file minus 3.  This means when the client tries to read the length field
1235     from that location it will get a short read -- the result string will be only 3 bytes long,
1236     not the 4 or 8 bytes necessary to do a successful struct.unpack."""
1237     sharevernum = struct.unpack(">l", data[0x0c:0x0c+4])[0]
1238     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1239     # The "-0x0c" in here is to skip the server-side header in the share file, which the client doesn't see when seeking and reading.
1240     if sharevernum == 1:
1241         if debug:
1242             log.msg("testing: corrupting offset %d, size %d, changing %d to %d (len(data) == %d)" % (0x2c, 4, struct.unpack(">L", data[0x2c:0x2c+4])[0], len(data)-0x0c-3, len(data)))
1243         return data[:0x2c] + struct.pack(">L", len(data)-0x0c-3) + data[0x2c+4:]
1244     else:
1245         if debug:
1246             log.msg("testing: corrupting offset %d, size %d, changing %d to %d (len(data) == %d)" % (0x48, 8, struct.unpack(">Q", data[0x48:0x48+8])[0], len(data)-0x0c-3, len(data)))
1247         return data[:0x48] + struct.pack(">Q", len(data)-0x0c-3) + data[0x48+8:]
1248
1249 def _corrupt_share_data(data):
1250     """ Scramble the file data -- the field containing the share data itself will have one
1251     bit flipped or else will be changed to a random value. """
1252     sharevernum = struct.unpack(">l", data[0x0c:0x0c+4])[0]
1253     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1254     if sharevernum == 1:
1255         sharedatasize = struct.unpack(">L", data[0x0c+0x08:0x0c+0x08+4])[0]
1256
1257         return corrupt_field(data, 0x0c+0x24, sharedatasize)
1258     else:
1259         sharedatasize = struct.unpack(">Q", data[0x0c+0x08:0x0c+0x0c+8])[0]
1260
1261         return corrupt_field(data, 0x0c+0x44, sharedatasize)
1262
1263 def _corrupt_crypttext_hash_tree(data):
1264     """ Scramble the file data -- the field containing the crypttext hash tree will have one
1265     bit flipped or else will be changed to a random value.
1266     """
1267     sharevernum = struct.unpack(">l", data[0x0c:0x0c+4])[0]
1268     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1269     if sharevernum == 1:
1270         crypttexthashtreeoffset = struct.unpack(">L", data[0x0c+0x14:0x0c+0x14+4])[0]
1271         blockhashesoffset = struct.unpack(">L", data[0x0c+0x18:0x0c+0x18+4])[0]
1272     else:
1273         crypttexthashtreeoffset = struct.unpack(">Q", data[0x0c+0x24:0x0c+0x24+8])[0]
1274         blockhashesoffset = struct.unpack(">Q", data[0x0c+0x2c:0x0c+0x2c+8])[0]
1275
1276     return corrupt_field(data, crypttexthashtreeoffset, blockhashesoffset-crypttexthashtreeoffset)
1277
1278 def _corrupt_block_hashes(data):
1279     """ Scramble the file data -- the field containing the block hash tree will have one bit
1280     flipped or else will be changed to a random value.
1281     """
1282     sharevernum = struct.unpack(">l", data[0x0c:0x0c+4])[0]
1283     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1284     if sharevernum == 1:
1285         blockhashesoffset = struct.unpack(">L", data[0x0c+0x18:0x0c+0x18+4])[0]
1286         sharehashesoffset = struct.unpack(">L", data[0x0c+0x1c:0x0c+0x1c+4])[0]
1287     else:
1288         blockhashesoffset = struct.unpack(">Q", data[0x0c+0x2c:0x0c+0x2c+8])[0]
1289         sharehashesoffset = struct.unpack(">Q", data[0x0c+0x34:0x0c+0x34+8])[0]
1290
1291     return corrupt_field(data, blockhashesoffset, sharehashesoffset-blockhashesoffset)
1292
1293 def _corrupt_share_hashes(data):
1294     """ Scramble the file data -- the field containing the share hash chain will have one
1295     bit flipped or else will be changed to a random value.
1296     """
1297     sharevernum = struct.unpack(">l", data[0x0c:0x0c+4])[0]
1298     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1299     if sharevernum == 1:
1300         sharehashesoffset = struct.unpack(">L", data[0x0c+0x1c:0x0c+0x1c+4])[0]
1301         uriextoffset = struct.unpack(">L", data[0x0c+0x20:0x0c+0x20+4])[0]
1302     else:
1303         sharehashesoffset = struct.unpack(">Q", data[0x0c+0x34:0x0c+0x34+8])[0]
1304         uriextoffset = struct.unpack(">Q", data[0x0c+0x3c:0x0c+0x3c+8])[0]
1305
1306     return corrupt_field(data, sharehashesoffset, uriextoffset-sharehashesoffset)
1307
1308 def _corrupt_length_of_uri_extension(data):
1309     """ Scramble the file data -- the field showing the length of the uri extension will
1310     have one bit flipped or else will be changed to a random value. """
1311     sharevernum = struct.unpack(">l", data[0x0c:0x0c+4])[0]
1312     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1313     if sharevernum == 1:
1314         uriextoffset = struct.unpack(">L", data[0x0c+0x20:0x0c+0x20+4])[0]
1315         return corrupt_field(data, uriextoffset, 4)
1316     else:
1317         uriextoffset = struct.unpack(">Q", data[0x0c+0x3c:0x0c+0x3c+8])[0]
1318         return corrupt_field(data, uriextoffset, 8)
1319
1320 def _corrupt_uri_extension(data):
1321     """ Scramble the file data -- the field containing the uri extension will have one bit
1322     flipped or else will be changed to a random value. """
1323     sharevernum = struct.unpack(">l", data[0x0c:0x0c+4])[0]
1324     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1325     if sharevernum == 1:
1326         uriextoffset = struct.unpack(">L", data[0x0c+0x20:0x0c+0x20+4])[0]
1327         uriextlen = struct.unpack(">L", data[0x0c+uriextoffset:0x0c+uriextoffset+4])[0]
1328     else:
1329         uriextoffset = struct.unpack(">Q", data[0x0c+0x3c:0x0c+0x3c+8])[0]
1330         uriextlen = struct.unpack(">Q", data[0x0c+uriextoffset:0x0c+uriextoffset+8])[0]
1331
1332     return corrupt_field(data, uriextoffset, uriextlen)