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 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, )