SignContract.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Content.Xml;
using Waher.Events;
using Waher.IoTGateway;
using Waher.Networking.HTTP;
using Waher.Networking.XMPP;
using Waher.Networking.XMPP.P2P.E2E;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Runtime.Inventory;
using Waher.Runtime.IO;
using Waher.Script;
using Waher.Script.Abstraction.Elements;
using Waher.Security;
using Waher.Service.IoTBroker.DataStorage;
using Waher.Service.IoTBroker.Legal;
using Waher.Service.IoTBroker.Legal.Identity;
using Waher.Service.IoTBroker.WebServices.Agent.Crypto;
 
namespace Waher.Service.IoTBroker.WebServices.Agent.Legal
{
    public class SignContract : AgentPostResource
    {
        public SignContract()
            : base("Legal/SignContract",
                new KeyValuePair<Type, Expression>(typeof(Dictionary<string, object>), new Expression(jsonPattern)),
                new KeyValuePair<Type, Expression>(typeof(XmlDocument), new Expression(xmlPattern)))
        {
        }
 
        private static readonly string jsonPattern = Resources.LoadResourceAsText(typeof(SignContract).Namespace + ".JSON.SignContract.req");
        private static readonly string xmlPattern = Resources.LoadResourceAsText(typeof(SignContract).Namespace + ".XML.SignContract.req");
 
        public override bool Synchronous => false;
 
        public override async Task POST(HttpRequest Request, HttpResponse Response, Dictionary<string, IElement> Parameters)
        {
            AccountUser User = AssertUserAuthenticated(Request);
 
            string KeyId = (string)Parameters["PKeyId"].AssociatedObjectValue;
            CaseInsensitiveString LegalId = (string)Parameters["PLegalId"].AssociatedObjectValue;
            CaseInsensitiveString ContractId = (string)Parameters["PContractId"].AssociatedObjectValue;
            string Role = (string)Parameters["PRole"].AssociatedObjectValue;
            string Nonce = (string)Parameters["PNonce"].AssociatedObjectValue;
            string KeySignature = (string)Parameters["PKeySignature"].AssociatedObjectValue;
            string RequestSignature = (string)Parameters["PRequestSignature"].AssociatedObjectValue;
 
            if (string.IsNullOrEmpty(KeyId))
                throw new BadRequestException("Key ID cannot be empty.");
 
            if (string.IsNullOrEmpty(Nonce) || Nonce.Length < 32)
                throw new ForbiddenException(Request, "Nonce too short.");
 
            LegalIdentity Identity = await LegalComponent.GetLocalLegalIdentity(LegalId)
                ?? throw new NotFoundException("Legal identity not found.");
 
            if (Identity.Account != User.UserName)
                throw new ForbiddenException(Request, "Only allowed to add attachments to your own legal identities.");
 
            if (Identity.State != IoTBroker.Legal.Identity.IdentityState.Approved)
                throw new ForbiddenException(Request, "Legal Identity not approved.");
 
            AgentKey AgentKey = await Database.FindFirstDeleteRest<AgentKey>(new FilterAnd(
                new FilterFieldEqualTo("Account", User.UserName),
                new FilterFieldEqualTo("Id", KeyId)))
                ?? throw new NotFoundException("Key not found.");
 
            StringBuilder sb = new StringBuilder();
 
            sb.Append(User.UserName);
            sb.Append(':');
            sb.Append(Request.Header.Host.Value);
            sb.Append(':');
            sb.Append(AgentKey.LocalName);
            sb.Append(':');
            sb.Append(AgentKey.Namespace);
            sb.Append(':');
            sb.Append(KeyId);
 
            //string s1 = sb.ToString();
 
            sb.Append(':');
            sb.Append(KeySignature);
 
            string s2 = sb.ToString();
 
            sb.Append(':');
            sb.Append(Nonce);
            sb.Append(':');
            sb.Append(LegalId);
            sb.Append(':');
            sb.Append(ContractId);
            sb.Append(':');
            sb.Append(Role);
 
            string s3 = sb.ToString();
 
            string s = Convert.ToBase64String(
                Hashes.ComputeHMACSHA256Hash(
                    Encoding.UTF8.GetBytes(User.Account.Password),
                    Encoding.UTF8.GetBytes(s3)));
 
            if (s != RequestSignature)
            {
                string Msg = "Request Signature invalid.";
                throw new ForbiddenException(Request, Msg);
            }
 
            if (await Gateway.HasNonceBeenUsed(Nonce))
            {
                string Msg = "Nonce value has already been used.";
                throw new ForbiddenException(Request, Msg);
            }
 
            await Gateway.RegisterNonceValue(Nonce);
 
            EllipticCurveEndpoint KeyEndpoint = ApplyId.GetEndpoint(Request, AgentKey, s2);
            int i = ContractId.IndexOf('@');
            if (i < 0)
                throw new BadRequestException("Invalid Contract ID.");
 
            string LegalDomain = ContractId.Substring(i + 1);
 
            if (XmppServerModule.Server is null)
            {
                XmppClient Client = Gateway.XmppClient;
 
                if (Client is null)
                {
                    if (Types.TryGetModuleParameter("XMPP", out XmppClient Client2))
                        Client = Client2;
                }
 
                if (Client is null)
                    throw new ServiceUnavailableException("XMPP Client not available.");
 
                await Client.SendIqGet(LegalDomain, "<getContract id=\"" + XML.Encode(ContractId) + "\" xmlns=\"" +
                    LegalComponent.NamespaceSmartContracts(NamespaceSet.Current) + "\"/>", async (Sender, e) =>
                    {
                        try
                        {
                            XmlElement E;
 
                            if (e.Ok && !((E = e.FirstElement) is null) && E.LocalName == "contract")
                            {
                                Networking.XMPP.Contracts.ParsedContract Contract;
 
                                try
                                {
                                    Contract = await Networking.XMPP.Contracts.Contract.Parse(E, Gateway.ContractsClient, true);
                                    if (Contract?.Contract is null)
                                    {
                                        await Response.SendResponse(new InternalServerErrorException("Unable to parse contract."));
                                        return;
                                    }
                                }
                                catch (Exception ex)
                                {
                                    await Response.SendResponse(new InternalServerErrorException("Unable to parse contract: " + Log.UnnestException(ex).Message));
                                    return;
                                }
 
                                StringBuilder Xml = new StringBuilder();
                                Contract.Contract.Serialize(Xml, false, false, false, false, false, false, false);
                                byte[] Data = Encoding.UTF8.GetBytes(Xml.ToString());
 
                                byte[] Signature = KeyEndpoint.Sign(Data);
 
                                await Client.SendIqSet(LegalDomain, "<signContract id=\"" + XML.Encode(ContractId) +
                                    "\" role=\"" + XML.Encode(Role) + "\" s=\"" +
                                    Convert.ToBase64String(Signature) + "\" xmlns=\"" +
                                    LegalComponent.NamespaceSmartContracts(NamespaceSet.Current) + "\"/>", async (sender2, e2) =>
                                    {
                                        try
                                        {
                                            if (e2.Ok && !((E = e2.FirstElement) is null) && E.LocalName == "contract")
                                            {
                                                await Response.Return(new NamedDictionary<string, object>("ContractResponse", AgentNamespace)
                                                {
                                                    { "Contract", E }
                                                });
                                            }
                                            else
                                                await Response.SendResponse(ToHttpException(Request, XmppClient.GetExceptionObject(e2.ErrorElement)) ?? new ServiceUnavailableException("Unable to get contract."));
                                        }
                                        catch (Exception ex2)
                                        {
                                            await Response.SendResponse(ex2);
                                        }
 
                                    }, null);
                            }
                            else
                                await Response.SendResponse(ToHttpException(Request, e.StanzaError) ?? new ServiceUnavailableException("Unable to get contract."));
                        }
                        catch (Exception ex)
                        {
                            await Response.SendResponse(ex);
                        }
                    }, null);
            }
            else
            {
                await XmppServerModule.Server.SendIqRequest("get",
                    User.UserName + "@" + (Gateway.Domain?.Value ?? string.Empty),
                    LegalDomain, string.Empty, "<getContract id=\"" + XML.Encode(ContractId) + "\" xmlns=\"" +
                    LegalComponent.NamespaceSmartContracts(NamespaceSet.Current) + "\"/>", true, async (Sender, e) =>
                    {
                        try
                        {
                            XmlElement E;
 
                            if (e.Ok && !((E = e.FirstElement) is null) && E.LocalName == "contract")
                            {
                                IoTBroker.Legal.Contracts.ParsedContract Contract = await IoTBroker.Legal.Contracts.Contract.Parse(E, XmppServerModule.Legal);
 
                                if (Contract?.Contract is null)
                                {
                                    await Response.SendResponse(new InternalServerErrorException("Unable to parse contract."));
                                    return;
                                }
 
                                StringBuilder Xml = new StringBuilder();
                                await Contract.Contract.Serialize(Xml, false, false, false, false, false, false, false, null, XmppServerModule.Legal);
                                byte[] Data = Encoding.UTF8.GetBytes(Xml.ToString());
 
                                byte[] Signature = KeyEndpoint.Sign(Data);
 
                                await XmppServerModule.Server.SendIqRequest("set",
                                    User.UserName + "@" + (Gateway.Domain?.Value ?? string.Empty),
                                    LegalDomain, string.Empty, "<signContract id=\"" + XML.Encode(ContractId) +
                                    "\" role=\"" + XML.Encode(Role) + "\" s=\"" +
                                    Convert.ToBase64String(Signature) + "\" xmlns=\"" +
                                    LegalComponent.NamespaceSmartContracts(Contract.Contract.Version) + "\"/>", false, async (sender2, e2) =>
                                    {
                                        try
                                        {
                                            if (e2.Ok && !((E = e2.FirstElement) is null) && E.LocalName == "contract")
                                            {
                                                await Response.Return(new NamedDictionary<string, object>("ContractResponse", AgentNamespace)
                                                {
                                                    { "Contract", E }
                                                });
                                            }
                                            else
                                                await Response.SendResponse(ToHttpException(Request, XmppClient.GetExceptionObject(e2.ErrorElement)) ?? new ServiceUnavailableException("Unable to get contract."));
                                        }
                                        catch (Exception ex2)
                                        {
                                            await Response.SendResponse(ex2);
                                        }
 
                                    }, null);
                            }
                            else
                                await Response.SendResponse(ToHttpException(Request, XmppClient.GetExceptionObject(e.ErrorElement)) ?? new ServiceUnavailableException("Unable to get contract."));
 
                        }
                        catch (Exception ex)
                        {
                            await Response.SendResponse(ex);
                        }
                    }, null);
            }
        }
 
    }
}