def call(service: schema_pb2_grpc.ImmuServiceStub, rs: RootService,
request: schema_pb2.SafeSetOptions):
root = rs.get()
index = schema_pb2.Index(index=root.index)
content = schema_pb2.Content(timestamp=int(time()),
payload=request.kv.value)
skv = schema_pb2.StructuredKeyValue(key=request.kv.key, value=content)
rawRequest = schema_pb2.SafeSetSVOptions(skv=skv, rootIndex=index)
msg = service.SafeSetSV(rawRequest)
digest = item.digest(msg.index, rawRequest.skv.key,
rawRequest.skv.value.SerializeToString())
if bytes(msg.leaf) != digest:
raise VerificationException("Proof does not match the given item.")
verified = proofs.verify(msg, bytes(msg.leaf), root)
if verified:
toCache = schema_pb2.Root(index=msg.index, root=msg.root)
try:
rs.set(toCache)
except Exception as e:
raise e
return SafeSetResponse(index=msg.index,
leaf=msg.leaf,
root=msg.root,
at=msg.at,
inclusionPath=msg.inclusionPath,
consistencyPath=msg.consistencyPath,
verified=verified)
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, request: schema_pb2.Database):
root = rs.get()
msg = service.CreateDatabase(request)
return dbCreateResponse(
reply = msg
)
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,
request: schema_pb2.SafeGetOptions):
root = rs.get()
index = schema_pb2.Index(index=root.index)
rawRequest = schema_pb2.SafeGetOptions(key=request.key, rootIndex=index)
msg = service.SafeGetSV(rawRequest)
verified = proofs.verify(
msg.proof,
item.digest(msg.item.index, msg.item.key,
msg.item.value.SerializeToString()), root)
if verified:
toCache = schema_pb2.Root(index=msg.proof.at, root=msg.proof.root)
try:
rs.set(toCache)
except:
raise VerificationException("Failed to verify")
i = msg.item
return SafeGetResponse(index=i.index,
key=i.key,
timestamp=i.value.timestamp,
value=i.value.payload.decode("utf-8"),
verified=verified)
def call(service: schema_pb2_grpc.ImmuServiceStub, rs: RootService, key: bytes,
offset: int, limit: int, desc: bool):
state = rs.get()
request = schema_pb2_grpc.schema__pb2.HistoryRequest(key=key,
offset=offset,
limit=limit,
desc=desc,
sinceTx=state.txId)
histo = service.History(request)
histolist = []
for i in histo.entries:
histolist.append(
datatypes.historyResponseItem(key=i.key, value=i.value, tx=i.tx))
return histolist
def call(service: schema_pb2_grpc.ImmuServiceStub, rs: RootService, key: bytes,
prefix: bytes, desc: bool, limit: int, sinceTx: int):
if sinceTx == None:
state = rs.get()
sinceTx = state.txId
request = schema_pb2_grpc.schema__pb2.ScanRequest(seekKey=key,
prefix=prefix,
desc=desc,
limit=limit,
sinceTx=sinceTx,
noWait=False)
msg = service.Scan(request)
ret = {}
for i in msg.entries:
ret[i.key] = i.value
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,
request: None):
root = rs.get()
return CurrentRootResponse(index=root.index, root=root.root)
def call(service: schema_pb2_grpc.ImmuServiceStub, rs: RootService,
request: None):
immudbstate = service.CurrentState(g_empty.Empty())
state = State.FromGrpc(immudbstate)
rs.set(state)
return state
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,
)