def simulated_set(ss, vv, key, value):
state = schema_pb2.ImmutableState()
state.ParseFromString(base64.b64decode(ss))
verifiableTx = schema_pb2.VerifiableTx()
verifiableTx.ParseFromString(base64.b64decode(vv))
tx = schema.TxFromProto(verifiableTx.tx)
entrySpecDigest = store.EntrySpecDigestFor(tx.header.version)
inclusionProof = tx.Proof(database.EncodeKey(key))
md = tx.entries[0].metadata()
if md != None and md.Deleted():
raise ErrCorruptedData
e = database.EncodeEntrySpec(key, md, value)
verifies = store.VerifyInclusion(inclusionProof, entrySpecDigest(e),
tx.header.eh)
assert verifies
assert tx.header.eh == schema.DigestFromProto(
verifiableTx.dualProof.targetTxHeader.eH)
sourceID = state.txId
sourceAlh = schema.DigestFromProto(state.txHash)
targetID = tx.header.iD
targetAlh = tx.header.Alh()
if state.txId > 0:
assert store.VerifyDualProof(
schema.DualProofFromProto(verifiableTx.dualProof),
sourceID,
targetID,
sourceAlh,
targetAlh,
)
def call(service: schema_pb2_grpc.ImmuServiceStub,
rs: RootService,
zset: bytes,
score: float,
key: bytes,
atTx: int = 0,
verifying_key=None):
state = rs.get()
request = schema_pb2.VerifiableZAddRequest(
zAddRequest=schema_pb2.ZAddRequest(
set=zset,
score=score,
key=key,
atTx=atTx,
),
proveSinceTx=state.txId)
vtx = service.VerifiableZAdd(request)
if vtx.tx.header.nentries != 1:
raise ErrCorruptedData
tx = schema.TxFromProto(vtx.tx)
entrySpecDigest = store.EntrySpecDigestFor(tx.header.version)
ekv = database.EncodeZAdd(zset, score, key, atTx)
inclusionProof = tx.Proof(ekv.key)
verifies = store.VerifyInclusion(inclusionProof, entrySpecDigest(ekv),
tx.header.eh)
if not verifies:
raise ErrCorruptedData
if tx.header.eh != schema.DigestFromProto(vtx.dualProof.targetTxHeader.eH):
raise ErrCorruptedData
sourceID = state.txId
sourceAlh = schema.DigestFromProto(state.txHash)
targetID = tx.header.iD
targetAlh = tx.header.Alh()
if state.txId > 0:
verifies = store.VerifyDualProof(
schema.DualProofFromProto(vtx.dualProof),
sourceID,
targetID,
sourceAlh,
targetAlh,
)
if not verifies:
raise ErrCorruptedData
newstate = State(
db=state.db,
txId=targetID,
txHash=targetAlh,
publicKey=vtx.signature.publicKey,
signature=vtx.signature.signature,
)
if verifying_key != None:
newstate.Verify(verifying_key)
rs.set(newstate)
return datatypes.SetResponse(
id=vtx.tx.header.id,
verified=True,
)
def test_dualproof_fails():
assert not store.VerifyDualProof(None, None, None, None, None)
proof = FakeProof()
proof.sourceTxHeader = FakeMetadata()
proof.targetTxHeader = FakeMetadata()
proof.sourceTxHeader.iD = 0
proof.targetTxHeader.iD = 0
assert not store.VerifyDualProof(proof, 0, 0, b'', b'')
proof.sourceTxHeader.iD = 5
proof.targetTxHeader.iD = 5
assert not store.VerifyDualProof(proof, 5, 5, b'', b'')
assert not store.VerifyDualProof(proof, 5, 5, b'42', b'1')
proof.inclusionProof = b''
proof.consistencyProof = b''
proof.linearProof = b''
proof.lastInclusionProof = b''
proof.sourceTxHeader.blTxID = 6
proof.targetTxHeader.blTxID = 6
proof.sourceTxHeader.blRoot = b''
proof.targetTxHeader.blRoot = b''
assert not store.VerifyDualProof(proof, 5, 5, b'42', b'42')
proof.targetTxHeader.blTxID = 0
assert not store.VerifyDualProof(proof, 5, 5, b'42', b'42')
proof.targetTxHeader.blTxID = 4
proof.sourceTxHeader.blTxID = 4
proof.targetBlTxAlh = b'42'
assert not store.VerifyDualProof(proof, 5, 5, b'42', b'42')
def call(service: schema_pb2_grpc.ImmuServiceStub,
rs: RootService,
refkey: bytes,
key: bytes,
atTx=0,
verifying_key=None):
state = rs.get()
req = schema_pb2_grpc.schema__pb2.ReferenceRequest(referencedKey=refkey,
key=key,
atTx=atTx,
boundRef=atTx > 0)
vreq = schema_pb2_grpc.schema__pb2.VerifiableReferenceRequest(
referenceRequest=req, proveSinceTx=state.txId)
vtx = service.VerifiableSetReference(vreq)
if vtx.tx.header.nentries != 1:
raise ErrCorruptedData
tx = schema.TxFromProto(vtx.tx)
entrySpecDigest = store.EntrySpecDigestFor(tx.header.version)
inclusionProof = tx.Proof(database.EncodeKey(key))
e = database.EncodeReference(key, None, refkey, atTx)
verifies = store.VerifyInclusion(inclusionProof, entrySpecDigest(e),
tx.header.eh)
if not verifies:
raise ErrCorruptedData
sourceID = state.txId
sourceAlh = schema.DigestFromProto(state.txHash)
targetID = tx.header.iD
targetAlh = tx.header.Alh()
if state.txId > 0:
verifies = store.VerifyDualProof(
schema.DualProofFromProto(vtx.dualProof),
sourceID,
targetID,
sourceAlh,
targetAlh,
)
if not verifies:
raise ErrCorruptedData
newstate = State(
db=state.db,
txId=targetID,
txHash=targetAlh,
publicKey=vtx.signature.publicKey,
signature=vtx.signature.signature,
)
if verifying_key != None:
newstate.Verify(verifying_key)
rs.set(newstate)
return datatypes.SetResponse(
id=vtx.tx.header.id,
verified=True,
)
def call(service: schema_pb2_grpc.ImmuServiceStub,
rs: RootService,
tx: int,
verifying_key=None):
state = rs.get()
request = schema_pb2.VerifiableTxRequest(tx=tx, proveSinceTx=state.txId)
try:
vtx = service.VerifiableTxById(request)
except Exception as e:
if hasattr(e, 'details') and e.details() == 'tx not found':
return None
raise e
dualProof = schema.DualProofFromProto(vtx.dualProof)
if state.txId <= vtx.tx.header.id:
sourceid = state.txId
sourcealh = schema.DigestFromProto(state.txHash)
targetid = vtx.tx.header.id
targetalh = dualProof.targetTxHeader.Alh()
else:
sourceid = vtx.tx.header.id
sourcealh = dualProof.sourceTxHeader.Alh()
targetid = state.txId
targetalh = schema.DigestFromProto(state.txHash)
verifies = store.VerifyDualProof(dualProof, sourceid, targetid, sourcealh,
targetalh)
if not verifies:
raise exceptions.ErrCorruptedData
newstate = State(
db=state.db,
txId=targetid,
txHash=targetalh,
publicKey=vtx.signature.publicKey,
signature=vtx.signature.signature,
)
if verifying_key != None:
newstate.Verify(verifying_key)
rs.set(newstate)
ret = []
for t in vtx.tx.entries:
ret.append(t.key[1:])
return ret
def call(service: schema_pb2_grpc.ImmuServiceStub,
rs: RootService,
requestkey: bytes,
atTx: int = None,
verifying_key=None,
sinceTx: int = None):
state = rs.get()
req = schema_pb2.VerifiableGetRequest(keyRequest=schema_pb2.KeyRequest(
key=requestkey, atTx=atTx, sinceTx=sinceTx),
proveSinceTx=state.txId)
ventry = service.VerifiableGet(req)
entrySpecDigest = store.EntrySpecDigestFor(
int(ventry.verifiableTx.tx.header.version))
inclusionProof = schema.InclusionProofFromProto(ventry.inclusionProof)
dualProof = schema.DualProofFromProto(ventry.verifiableTx.dualProof)
if not ventry.entry.HasField("referencedBy"):
vTx = ventry.entry.tx
e = database.EncodeEntrySpec(
requestkey, schema.KVMetadataFromProto(ventry.entry.metadata),
ventry.entry.value)
else:
ref = ventry.entry.referencedBy
vTx = ref.tx
e = database.EncodeReference(ref.key,
schema.KVMetadataFromProto(ref.metadata),
ventry.entry.key, ref.atTx)
if state.txId <= vTx:
eh = schema.DigestFromProto(
ventry.verifiableTx.dualProof.targetTxHeader.eH)
sourceid = state.txId
sourcealh = schema.DigestFromProto(state.txHash)
targetid = vTx
targetalh = dualProof.targetTxHeader.Alh()
else:
eh = schema.DigestFromProto(
ventry.verifiableTx.dualProof.sourceTxHeader.eH)
sourceid = vTx
sourcealh = dualProof.sourceTxHeader.Alh()
targetid = state.txId
targetalh = schema.DigestFromProto(state.txHash)
verifies = store.VerifyInclusion(inclusionProof, entrySpecDigest(e), eh)
if not verifies:
raise ErrCorruptedData
if state.txId > 0:
verifies = store.VerifyDualProof(dualProof, sourceid, targetid,
sourcealh, targetalh)
if not verifies:
raise ErrCorruptedData
newstate = State(
db=state.db,
txId=targetid,
txHash=targetalh,
publicKey=ventry.verifiableTx.signature.publicKey,
signature=ventry.verifiableTx.signature.signature,
)
if verifying_key != None:
newstate.Verify(verifying_key)
rs.set(newstate)
if ventry.entry.HasField("referencedBy"):
refkey = ventry.entry.referencedBy.key
else:
refkey = None
return datatypes.SafeGetResponse(
id=vTx,
key=ventry.entry.key,
value=ventry.entry.value,
timestamp=ventry.verifiableTx.tx.header.ts,
verified=verifies,
refkey=refkey)
def call(service: schema_pb2_grpc.ImmuServiceStub,
rs: RootService,
key: bytes,
value: bytes,
verifying_key=None,
metadata=None):
schemaMetadata = MetadataToProto(metadata)
state = rs.get()
# print(base64.b64encode(state.SerializeToString()))
kv = schema_pb2.KeyValue(key=key, value=value, metadata=schemaMetadata)
rawRequest = schema_pb2.VerifiableSetRequest(
setRequest=schema_pb2.SetRequest(KVs=[kv]),
proveSinceTx=state.txId,
)
verifiableTx = service.VerifiableSet(rawRequest)
# print(base64.b64encode(verifiableTx.SerializeToString()))
if verifiableTx.tx.header.nentries != 1 or len(
verifiableTx.tx.entries) != 1:
raise ErrCorruptedData
tx = schema.TxFromProto(verifiableTx.tx)
entrySpecDigest = store.EntrySpecDigestFor(tx.header.version)
inclusionProof = tx.Proof(database.EncodeKey(key))
md = tx.entries[0].metadata()
if md != None and md.Deleted():
raise ErrCorruptedData
e = database.EncodeEntrySpec(key, md, value)
verifies = store.VerifyInclusion(inclusionProof, entrySpecDigest(e),
tx.header.eh)
if not verifies:
raise ErrCorruptedData
if tx.header.eh != schema.DigestFromProto(
verifiableTx.dualProof.targetTxHeader.eH):
raise ErrCorruptedData
sourceID = state.txId
sourceAlh = schema.DigestFromProto(state.txHash)
targetID = tx.header.iD
targetAlh = tx.header.Alh()
if state.txId > 0:
verifies = store.VerifyDualProof(
schema.DualProofFromProto(verifiableTx.dualProof),
sourceID,
targetID,
sourceAlh,
targetAlh,
)
if not verifies:
raise ErrCorruptedData
newstate = State(
db=state.db,
txId=targetID,
txHash=targetAlh,
publicKey=verifiableTx.signature.publicKey,
signature=verifiableTx.signature.signature,
)
if verifying_key != None:
newstate.Verify(verifying_key)
rs.set(newstate)
return datatypes.SetResponse(
id=verifiableTx.tx.header.id,
verified=verifies,
)