share_type = "unknown"
f.seek(m.DATA_OFFSET)
- if f.read(1) == "\x00":
+ version = f.read(1)
+ if version == "\x00":
# this slot contains an SMDF share
share_type = "SDMF"
+ elif version == "\x01":
+ share_type = "MDMF"
f.close()
print >>out
if share_type == "SDMF":
dump_SDMF_share(m, data_length, options)
+ elif share_type == "MDMF":
+ dump_MDMF_share(m, data_length, options)
return 0
print >>out
+def dump_MDMF_share(m, length, options):
+ from allmydata.mutable.layout import MDMFSlotReadProxy
+ from allmydata.util import base32, hashutil
+ from allmydata.uri import MDMFVerifierURI
+ from allmydata.util.encodingutil import quote_output, to_str
+
+ offset = m.DATA_OFFSET
+ out = options.stdout
+
+ f = open(options['filename'], "rb")
+ storage_index = None; shnum = 0
+
+ class ShareDumper(MDMFSlotReadProxy):
+ def _read(self, readvs, force_remote=False, queue=False):
+ data = []
+ for (where,length) in readvs:
+ f.seek(offset+where)
+ data.append(f.read(length))
+ return defer.succeed({shnum: data})
+
+ p = ShareDumper(None, storage_index, shnum)
+ def extract(func):
+ stash = []
+ # these methods return Deferreds, but we happen to know that they run
+ # synchronously when not actually talking to a remote server
+ d = func()
+ d.addCallback(stash.append)
+ return stash[0]
+
+ verinfo = extract(p.get_verinfo)
+ encprivkey = extract(p.get_encprivkey)
+ signature = extract(p.get_signature)
+ pubkey = extract(p.get_verification_key)
+ block_hash_tree = extract(p.get_blockhashes)
+ share_hash_chain = extract(p.get_sharehashes)
+ f.close()
+
+ (seqnum, root_hash, salt_to_use, segsize, datalen, k, N, prefix,
+ offsets) = verinfo
+
+ print >>out, " MDMF contents:"
+ print >>out, " seqnum: %d" % seqnum
+ print >>out, " root_hash: %s" % base32.b2a(root_hash)
+ #print >>out, " IV: %s" % base32.b2a(IV)
+ print >>out, " required_shares: %d" % k
+ print >>out, " total_shares: %d" % N
+ print >>out, " segsize: %d" % segsize
+ print >>out, " datalen: %d" % datalen
+ print >>out, " enc_privkey: %d bytes" % len(encprivkey)
+ print >>out, " pubkey: %d bytes" % len(pubkey)
+ print >>out, " signature: %d bytes" % len(signature)
+ share_hash_ids = ",".join([str(hid)
+ for hid in sorted(share_hash_chain.keys())])
+ print >>out, " share_hash_chain: %s" % share_hash_ids
+ print >>out, " block_hash_tree: %d nodes" % len(block_hash_tree)
+
+ # the storage index isn't stored in the share itself, so we depend upon
+ # knowing the parent directory name to get it
+ pieces = options['filename'].split(os.sep)
+ if len(pieces) >= 2:
+ piece = to_str(pieces[-2])
+ if base32.could_be_base32_encoded(piece):
+ storage_index = base32.a2b(piece)
+ fingerprint = hashutil.ssk_pubkey_fingerprint_hash(pubkey)
+ u = MDMFVerifierURI(storage_index, fingerprint)
+ verify_cap = u.to_string()
+ print >>out, " verify-cap:", quote_output(verify_cap, quotemarks=False)
+
+ if options['offsets']:
+ # NOTE: this offset-calculation code is fragile, and needs to be
+ # merged with MutableShareFile's internals.
+
+ print >>out
+ print >>out, " Section Offsets:"
+ def printoffset(name, value, shift=0):
+ print >>out, "%s%.20s: %s (0x%x)" % (" "*shift, name, value, value)
+ printoffset("first lease", m.HEADER_SIZE, 2)
+ printoffset("share data", m.DATA_OFFSET, 2)
+ o_seqnum = m.DATA_OFFSET + struct.calcsize(">B")
+ printoffset("seqnum", o_seqnum, 4)
+ o_root_hash = m.DATA_OFFSET + struct.calcsize(">BQ")
+ printoffset("root_hash", o_root_hash, 4)
+ for k in ["enc_privkey", "share_hash_chain", "signature",
+ "verification_key", "verification_key_end",
+ "share_data", "block_hash_tree", "EOF"]:
+ name = {"share_data": "block data",
+ "verification_key": "pubkey",
+ "verification_key_end": "end of pubkey",
+ "EOF": "end of share data"}.get(k,k)
+ offset = m.DATA_OFFSET + offsets[k]
+ printoffset(name, offset, 4)
+ f = open(options['filename'], "rb")
+ printoffset("extra leases", m._read_extra_lease_offset(f) + 4, 2)
+ f.close()
+
+ print >>out
+
class DumpCapOptions(usage.Options):
print >>out, "Literal File URI:"
print >>out, " data:", quote_output(u.data)
- elif isinstance(u, uri.WriteableSSKFileURI):
+ elif isinstance(u, uri.WriteableSSKFileURI): # SDMF
if show_header:
- print >>out, "SSK Writeable URI:"
+ print >>out, "SDMF Writeable URI:"
print >>out, " writekey:", base32.b2a(u.writekey)
print >>out, " readkey:", base32.b2a(u.readkey)
print >>out, " storage index:", si_b2a(u.get_storage_index())
print >>out, " write_enabler:", base32.b2a(we)
print >>out
_dump_secrets(u.get_storage_index(), secret, nodeid, out)
-
elif isinstance(u, uri.ReadonlySSKFileURI):
if show_header:
- print >>out, "SSK Read-only URI:"
+ print >>out, "SDMF Read-only URI:"
print >>out, " readkey:", base32.b2a(u.readkey)
print >>out, " storage index:", si_b2a(u.get_storage_index())
print >>out, " fingerprint:", base32.b2a(u.fingerprint)
elif isinstance(u, uri.SSKVerifierURI):
if show_header:
- print >>out, "SSK Verifier URI:"
+ print >>out, "SDMF Verifier URI:"
+ print >>out, " storage index:", si_b2a(u.get_storage_index())
+ print >>out, " fingerprint:", base32.b2a(u.fingerprint)
+
+ elif isinstance(u, uri.WriteableMDMFFileURI): # MDMF
+ if show_header:
+ print >>out, "MDMF Writeable URI:"
+ print >>out, " writekey:", base32.b2a(u.writekey)
+ print >>out, " readkey:", base32.b2a(u.readkey)
+ print >>out, " storage index:", si_b2a(u.get_storage_index())
+ print >>out, " fingerprint:", base32.b2a(u.fingerprint)
+ print >>out
+ if nodeid:
+ we = hashutil.ssk_write_enabler_hash(u.writekey, nodeid)
+ print >>out, " write_enabler:", base32.b2a(we)
+ print >>out
+ _dump_secrets(u.get_storage_index(), secret, nodeid, out)
+ elif isinstance(u, uri.ReadonlyMDMFFileURI):
+ if show_header:
+ print >>out, "MDMF Read-only URI:"
+ print >>out, " readkey:", base32.b2a(u.readkey)
+ print >>out, " storage index:", si_b2a(u.get_storage_index())
+ print >>out, " fingerprint:", base32.b2a(u.fingerprint)
+ elif isinstance(u, uri.MDMFVerifierURI):
+ if show_header:
+ print >>out, "MDMF Verifier URI:"
print >>out, " storage index:", si_b2a(u.get_storage_index())
print >>out, " fingerprint:", base32.b2a(u.fingerprint)
- elif isinstance(u, uri.DirectoryURI):
+
+ elif isinstance(u, uri.ImmutableDirectoryURI): # CHK-based directory
+ if show_header:
+ print >>out, "CHK Directory URI:"
+ dump_uri_instance(u._filenode_uri, nodeid, secret, out, False)
+ elif isinstance(u, uri.ImmutableDirectoryURIVerifier):
+ if show_header:
+ print >>out, "CHK Directory Verifier URI:"
+ dump_uri_instance(u._filenode_uri, nodeid, secret, out, False)
+
+ elif isinstance(u, uri.DirectoryURI): # SDMF-based directory
if show_header:
print >>out, "Directory Writeable URI:"
dump_uri_instance(u._filenode_uri, nodeid, secret, out, False)
if show_header:
print >>out, "Directory Verifier URI:"
dump_uri_instance(u._filenode_uri, nodeid, secret, out, False)
+
+ elif isinstance(u, uri.MDMFDirectoryURI): # MDMF-based directory
+ if show_header:
+ print >>out, "Directory Writeable URI:"
+ dump_uri_instance(u._filenode_uri, nodeid, secret, out, False)
+ elif isinstance(u, uri.ReadonlyMDMFDirectoryURI):
+ if show_header:
+ print >>out, "Directory Read-only URI:"
+ dump_uri_instance(u._filenode_uri, nodeid, secret, out, False)
+ elif isinstance(u, uri.MDMFDirectoryURIVerifier):
+ if show_header:
+ print >>out, "Directory Verifier URI:"
+ dump_uri_instance(u._filenode_uri, nodeid, secret, out, False)
+
else:
print >>out, "unknown cap type"
share_type = "unknown"
f.seek(m.DATA_OFFSET)
- if f.read(1) == "\x00":
+ version = f.read(1)
+ if version == "\x00":
# this slot contains an SMDF share
share_type = "SDMF"
+ elif version == "\x01":
+ share_type = "MDMF"
if share_type == "SDMF":
f.seek(m.DATA_OFFSET)
(si_s, k, N, datalen,
seqnum, base32.b2a(root_hash),
expiration, quote_output(abs_sharefile))
+ elif share_type == "MDMF":
+ from allmydata.mutable.layout import MDMFSlotReadProxy
+ fake_shnum = 0
+ # TODO: factor this out with dump_MDMF_share()
+ class ShareDumper(MDMFSlotReadProxy):
+ def _read(self, readvs, force_remote=False, queue=False):
+ data = []
+ for (where,length) in readvs:
+ f.seek(m.DATA_OFFSET+where)
+ data.append(f.read(length))
+ return defer.succeed({fake_shnum: data})
+
+ p = ShareDumper(None, "fake-si", fake_shnum)
+ def extract(func):
+ stash = []
+ # these methods return Deferreds, but we happen to know that
+ # they run synchronously when not actually talking to a
+ # remote server
+ d = func()
+ d.addCallback(stash.append)
+ return stash[0]
+
+ verinfo = extract(p.get_verinfo)
+ (seqnum, root_hash, salt_to_use, segsize, datalen, k, N, prefix,
+ offsets) = verinfo
+ print >>out, "MDMF %s %d/%d %d #%d:%s %d %s" % \
+ (si_s, k, N, datalen,
+ seqnum, base32.b2a(root_hash),
+ expiration, quote_output(abs_sharefile))
else:
print >>out, "UNKNOWN mutable %s" % quote_output(abs_sharefile)