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