Пример #1
0
        public async Task SendProofRequestThrowsConnectionNotFound()
        {
            var ex = await Assert.ThrowsAsync <AriesFrameworkException>(async() => await _proofService.CreateRequestAsync(_issuerWallet, new ProofRequest
            {
                Name  = "Test",
                Nonce = await AnonCreds.GenerateNonceAsync()
            }, "bad-proof-id"));

            Assert.True(ex.ErrorCode == ErrorCode.RecordNotFound);
        }
        public async Task <CreateProofRequestResponse> Handle
        (
            CreateProofRequestRequest aCreateProofRequestRequest,
            CancellationToken aCancellationToken
        )
        {
            IAgentContext agentContext = await AgentProvider.GetContextAsync();

            ConnectionRecord connectionRecord = await ConnectionService.GetAsync(agentContext, aCreateProofRequestRequest.ConnectionId);

            aCreateProofRequestRequest.ProofRequest.Nonce = await AnonCreds.GenerateNonceAsync();

            (RequestPresentationMessage requestPresentationMessage, ProofRecord proofRecord) =
                await ProofService.CreateRequestAsync(agentContext, aCreateProofRequestRequest.ProofRequest, aCreateProofRequestRequest.ConnectionId);

            await MessageService.SendAsync(agentContext, requestPresentationMessage, connectionRecord);

            //(requestPresentationMessage, proofRecord) =
            //  await ProofService.CreateRequestAsync(agentContext, aSendRequestForProofRequest.ProofRequest);

            //string endpointUri = (await ProvisioningService.GetProvisioningAsync(agentContext.Wallet)).Endpoint.Uri;
            //string encodedRequestPresentationMessage = requestPresentationMessage.ToJson().ToBase64();
            //string proofRequestUrl = $"{endpointUri}?c_i={encodedRequestPresentationMessage}";

            var response = new CreateProofRequestResponse(requestPresentationMessage, aCreateProofRequestRequest.CorrelationId);

            return(await Task.Run(() => response));
        }
Пример #3
0
        public static async Task <(ProofRecord holderProofRecord, ProofRecord RequestorProofRecord)> ProofProtocolAsync(
            IProofService proofService,
            IProducerConsumerCollection <AgentMessage> messages,
            ConnectionRecord holderConnection, ConnectionRecord requestorConnection,
            IAgentContext holderContext,
            IAgentContext requestorContext, ProofRequest proofRequestObject)
        {
            //Requestor sends a proof request
            var(message, requestorProofRecord) = await proofService.CreateRequestAsync(requestorContext, proofRequestObject, requestorConnection.Id);

            messages.TryAdd(message);

            // Holder accepts the proof requests and builds a proof
            var proofRequest = FindContentMessage <RequestPresentationMessage>(messages);

            Assert.NotNull(proofRequest);

            //Holder stores the proof request
            var holderProofRequestRecord = await proofService.ProcessRequestAsync(holderContext, proofRequest, holderConnection);

            var holderProofRecord = await proofService.GetAsync(holderContext, holderProofRequestRecord.Id);

            var holderProofRequest = JsonConvert.DeserializeObject <ProofRequest>(holderProofRecord.RequestJson);

            // Auto satify the proof with which ever credentials in the wallet are capable
            var requestedCredentials =
                await ProofServiceUtils.GetAutoRequestedCredentialsForProofCredentials(holderContext, proofService,
                                                                                       holderProofRequest);

            //Holder accepts the proof request and sends a proof
            (var proofMessage, _) = await proofService.CreatePresentationAsync(
                holderContext,
                holderProofRequestRecord.Id,
                requestedCredentials);

            messages.TryAdd(proofMessage);

            //Requestor retrives proof message from their cloud agent
            var proof = FindContentMessage <PresentationMessage>(messages);

            Assert.NotNull(proof);

            //Requestor stores proof
            requestorProofRecord = await proofService.ProcessPresentationAsync(requestorContext, proof);

            //Requestor verifies proof
            var requestorVerifyResult = await proofService.VerifyProofAsync(requestorContext, requestorProofRecord.Id);

            //Verify the proof is valid
            Assert.True(requestorVerifyResult);

            var requestorProofRecordResult = await proofService.GetAsync(requestorContext, requestorProofRecord.Id);

            var holderProofRecordResult = await proofService.GetAsync(holderContext, holderProofRecord.Id);

            return(holderProofRecordResult, requestorProofRecordResult);
        }
Пример #4
0
        /// <inheritdoc />
        public virtual async Task ProcessTransactionAsync(IAgentContext agentContext, TransactionResponseMessage connectionTransactionMessage, ConnectionRecord connection)
        {
            Logger.LogInformation(CustomLoggingEvents.ProcessTransaction, "To {1}", connection.TheirDid);

            var transactionRecord = await RecordService.GetAsync <TransactionRecord>(agentContext.Wallet, connectionTransactionMessage.Transaction);

            if (!transactionRecord.Used)
            {
                transactionRecord.ConnectionRecord = connection;

                if (transactionRecord.ProofRequest != null)
                {
                    var(message, record) = await ProofService.CreateRequestAsync(agentContext, transactionRecord.ProofRequest);

                    transactionRecord.ProofRecordId = record.Id;
                    var deleteId = Guid.NewGuid().ToString();
                    message.AddDecorator(deleteId, "delete_id");
                    record.SetTag("delete_id", deleteId);
                    record.ConnectionId = connection.Id;

                    message.Comment = transactionRecord.ProofComment;

                    await RecordService.UpdateAsync(agentContext.Wallet, record);

                    await MessageService.SendAsync(agentContext.Wallet, message, connection);
                }

                if (transactionRecord.OfferConfiguration != null)
                {
                    var(credentialOfferMessage, credentialRecord) = await CredentialService.CreateOfferAsync(agentContext, transactionRecord.OfferConfiguration, connection.Id);

                    transactionRecord.CredentialRecordId = credentialRecord.Id;

                    credentialOfferMessage.Comment = transactionRecord.CredentialComment;

                    await MessageService.SendAsync(agentContext.Wallet, credentialOfferMessage, connection);
                }

                transactionRecord.Used = true;

                await RecordService.UpdateAsync(agentContext.Wallet, transactionRecord);
            }
            else
            {
                var message = new TransactionErrorMessage()
                {
                    Transaction = transactionRecord.Id
                };

                await MessageService.SendAsync(agentContext.Wallet, message, connection);
            }
        }
Пример #5
0
        public async Task <RequestPresentationMessage> CreateProofNameMessage(ConnectionRecord connectionRecord)
        {
            var agentContext = await _agentProvider.GetContextAsync();

            var name         = connectionRecord.Alias?.Name ?? connectionRecord.Id;
            var proofRequest = new ProofRequest
            {
                Name                = "ProofReq",
                Version             = "1.0",
                Nonce               = await AnonCreds.GenerateNonceAsync(),
                RequestedAttributes = new Dictionary <string, ProofAttributeInfo>
                {
                    { "firstname-required", new ProofAttributeInfo {
                          Name = "firstname"
                      } }
                }
            };

            (var msg, _) = await _proofService.CreateRequestAsync(agentContext, proofRequest);

            return(msg);
        }
Пример #6
0
        public static async Task <(ProofRecord holderProofRecord, ProofRecord requestorProofRecord)> RequestorInitiatedProofProtocolAsync(
            IProofService proofService,
            IProducerConsumerCollection <AgentMessage> messages,
            ConnectionRecord holderConnection, ConnectionRecord requestorConnection,
            IAgentContext holderContext,
            IAgentContext requestorContext, ProofRequest proofRequestObject)
        {
            //Requestor sends a proof request
            var(message, requestorProofRecord) = await proofService.CreateRequestAsync(requestorContext, proofRequestObject, requestorConnection.Id);

            messages.TryAdd(message);

            return(await ProofProtocolAsync(proofService, messages, holderConnection, requestorConnection, holderContext, requestorContext, requestorProofRecord));
        }
Пример #7
0
        public async Task <IActionResult> SendPresentationRequestAsync(OperationBody body)
        {
            // NOTE: AATH can only start from presentation request, not respond to previous message
            var context = await _agentContextProvider.GetContextAsync();

            var presentationRequest        = body.Data;
            var connectionId               = (string)presentationRequest["connection_id"];
            var presentationRequestMessage = presentationRequest["presentation_proposal"]["request_presentations~attach"]["data"];

            var proofRequest = new ProofRequest
            {
                Name                = (string)presentationRequestMessage["name"] ?? "test proof",
                Version             = (string)presentationRequestMessage["version"] ?? "1.0",
                Nonce               = await AnonCreds.GenerateNonceAsync(),
                RequestedAttributes = presentationRequestMessage["requested_attributes"]?.ToObject <Dictionary <string, ProofAttributeInfo> >() ?? new Dictionary <string, ProofAttributeInfo>
                {
                },
                RequestedPredicates = presentationRequestMessage["requested_predicates"]?.ToObject <Dictionary <string, ProofPredicateInfo> >() ?? new Dictionary <string, ProofPredicateInfo> {
                }
            };

            _logger.LogInformation("SendPresentationRequest {proofRequest}", proofRequest.ToJson());


            var(requestPresentationMessage, proofRecord) = await _proofService.CreateRequestAsync(context, proofRequest, connectionId);

            var connection = await _connectionService.GetAsync(context, connectionId);

            var THPresentationExchange = new TestHarnessPresentationExchange
            {
                RecordId = proofRecord.Id,
                ThreadId = proofRecord.GetTag(TagConstants.LastThreadId),
                State    = TestHarnessPresentationExchangeState.RequestSent
            };

            _proofCache.Set(THPresentationExchange.ThreadId, THPresentationExchange);

            UpdateStateOnMessage(THPresentationExchange, TestHarnessPresentationExchangeState.PresentationReceived, _ => _.MessageType == MessageTypes.PresentProofNames.Presentation && _.ThreadId == THPresentationExchange.ThreadId);

            _logger.LogDebug("Send Presentation Request {requestPresentationMessage}", requestPresentationMessage.ToJson());

            await _messageService.SendAsync(context, requestPresentationMessage, connection);

            return(Ok(THPresentationExchange));
        }
Пример #8
0
        public async Task RequestIdentityProof()
        {
            var context = await _agentContextProvider.GetContextAsync();

            //var connection = await _connectionService.GetAsync(context, _connectionRecord.Id);

            if (SelectedDefinition == null || SelectedSchema == null)
            {
                return;
            }

            var identityAttributes = new ProofAttributeInfo
            {
                Names        = new string[] { "fist_name", "last_name" },
                Restrictions = new List <AttributeFilter>
                {
                    new AttributeFilter
                    {
                        SchemaId = SelectedSchema.Id,
                        CredentialDefinitionId = SelectedDefinition.Id
                    }
                }
            };


            var proofRequestObject = new ProofRequest
            {
                Name                = "Identity Proof Request",
                Version             = "3.0",
                Nonce               = new BigInteger(Guid.NewGuid().ToByteArray()).ToString(),
                RequestedAttributes = new Dictionary <string, ProofAttributeInfo>
                {
                    { $"identity_attrs_requirement", identityAttributes }
                },
                RequestedPredicates = null
            };

            var(request, _) = await _proofService.CreateRequestAsync(context, proofRequestObject, _connectionRecord.Id);

            await _messageService.SendAsync(context, request, _connectionRecord);
        }
Пример #9
0
        public async Task ProcessProofInvalidState()
        {
            //Setup a connection and issue the credentials to the holder
            var(issuerConnection, holderConnection) = await Scenarios.EstablishConnectionAsync(
                _connectionService, _messages, _issuerWallet, _holderWallet);

            await Scenarios.IssueCredentialAsync(
                _schemaService, _credentialService, _messages, issuerConnection,
                holderConnection, _issuerWallet, _holderWallet, await _holderWallet.Pool, TestConstants.DefaultMasterSecret, true, new List <CredentialPreviewAttribute>
            {
                new CredentialPreviewAttribute("first_name", "Test"),
                new CredentialPreviewAttribute("last_name", "Holder")
            });

            _messages.Clear();

            //Requestor initialize a connection with the holder
            var(_, requestorConnection) = await Scenarios.EstablishConnectionAsync(
                _connectionService, _messages, _holderWallet, _requestorWallet);

            // Verifier sends a proof request to prover
            {
                var proofRequestObject = new ProofRequest
                {
                    Name                = "ProofReq",
                    Version             = "1.0",
                    Nonce               = await AnonCreds.GenerateNonceAsync(),
                    RequestedAttributes = new Dictionary <string, ProofAttributeInfo>
                    {
                        { "first-name-requirement", new ProofAttributeInfo {
                              Name = "first_name"
                          } }
                    }
                };

                //Requestor sends a proof request
                var(message, _) = await _proofService.CreateRequestAsync(_requestorWallet, proofRequestObject, requestorConnection.Id);

                _messages.Add(message);
            }

            // Holder accepts the proof requests and builds a proof
            {
                // Holder retrieves proof request message from their cloud agent
                var proofRequest = FindContentMessage <RequestPresentationMessage>();
                Assert.NotNull(proofRequest);

                // Holder stores the proof request
                var holderProofRequestId = await _proofService.ProcessRequestAsync(_holderWallet, proofRequest, holderConnection);

                var holderProofRecord = await _proofService.GetAsync(_holderWallet, holderProofRequestId.Id);

                var holderProofObject =
                    JsonConvert.DeserializeObject <ProofRequest>(holderProofRecord.RequestJson);

                var requestedCredentials = new RequestedCredentials();
                foreach (var requestedAttribute in holderProofObject.RequestedAttributes)
                {
                    var credentials =
                        await _proofService.ListCredentialsForProofRequestAsync(_holderWallet, holderProofObject,
                                                                                requestedAttribute.Key);

                    requestedCredentials.RequestedAttributes.Add(requestedAttribute.Key,
                                                                 new RequestedAttribute
                    {
                        CredentialId = credentials.First().CredentialInfo.Referent,
                        Revealed     = true
                    });
                }

                foreach (var requestedAttribute in holderProofObject.RequestedPredicates)
                {
                    var credentials =
                        await _proofService.ListCredentialsForProofRequestAsync(_holderWallet, holderProofObject,
                                                                                requestedAttribute.Key);

                    requestedCredentials.RequestedPredicates.Add(requestedAttribute.Key,
                                                                 new RequestedAttribute
                    {
                        CredentialId = credentials.First().CredentialInfo.Referent,
                        Revealed     = true
                    });
                }

                //Holder accepts the proof request and sends a proof
                (var proofMessage, var _) = await _proofService.CreatePresentationAsync(_holderWallet, holderProofRequestId.Id,
                                                                                        requestedCredentials);

                _messages.Add(proofMessage);
            }

            //Requestor retrives proof message from their cloud agent
            var proof = FindContentMessage <PresentationMessage>();

            Assert.NotNull(proof);

            //Requestor stores proof
            await _proofService.ProcessPresentationAsync(_requestorWallet, proof);

            var ex = await Assert.ThrowsAsync <AriesFrameworkException>(async() => await _proofService.ProcessPresentationAsync(_requestorWallet, proof));

            Assert.True(ex.ErrorCode == ErrorCode.RecordInInvalidState);
        }