Vault.cs

using System;
using System.Text;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Networking.HTTP;
using Waher.Networking.XMPP.P2P.E2E;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Runtime.Threading;
using Waher.Service.IoTBroker.WebServices.Agent.Crypto;
using Waher.Service.IoTBroker.WebServices.Agent.Legal;
using Waher.Service.IoTBroker.WebServices.Agent.Storage;
 
namespace Waher.Service.IoTBroker.WebServices
{
    public class Vault : HttpSynchronousResource, IHttpGetMethod
    {
        public Vault()
            : base("/Vault")
        {
        }
 
        public bool AllowsGET => true;
 
        public override bool HandlesSubPaths => true;
 
        public override bool UserSessions => false;
 
        public async Task GET(HttpRequest Request, HttpResponse Response)
        {
            string[] Parts = Request.SubPath.Split('/', StringSplitOptions.None);
            if (Parts.Length != 3 || !string.IsNullOrEmpty(Parts[0]))
            {
                await Response.SendResponse(new BadRequestException("Invalid Vault URL."));
                return;
            }
 
            string ReferenceId = Parts[1];
            using Semaphore Semaphore = await Semaphores.BeginWrite("vaultreference:" + ReferenceId);
            byte[] Signature;
 
            try
            {
                Signature = Base64Url.Decode(Parts[2]);
            }
            catch (Exception)
            {
                await Response.SendResponse(new BadRequestException("Invalid Signature."));
                return;
            }
 
            VaultItemReference Ref;
 
            try
            {
                Ref = await Database.TryLoadObject<VaultItemReference>(ReferenceId);
            }
            catch (Exception)
            {
                await Response.SendResponse(new BadRequestException("Invalid Vault Reference."));
                return;
            }
 
            if (Ref is null)
            {
                await Response.SendResponse(new NotFoundException("Vault Reference not found."));
                return;
            }
 
            if (DateTime.UtcNow > Ref.Expires)
            {
                await Database.Delete(Ref);
                await Response.SendResponse(new NotFoundException("Vault Reference expired."));
                return;
            }
 
            VaultItem Item = await Database.FindFirstIgnoreRest<VaultItem>(
                new FilterFieldEqualTo("VaultId", Ref.VaultId));
 
            if (Item is null)
            {
                await Database.Delete(Ref);
                await Response.SendResponse(new NotFoundException("Vault Item not found."));
                return;
            }
 
            AgentKey AgentKey = await Database.FindFirstDeleteRest<AgentKey>(new FilterAnd(
                new FilterFieldEqualTo("Account", Item.Account),
                new FilterFieldEqualTo("Id", Ref.KeyId)));
 
            if (AgentKey is null)
            {
                await Database.Delete(Ref);
                await Response.SendResponse(new NotFoundException("Vault Reference signature key not found."));
                return;
            }
 
            EllipticCurveEndpoint KeyEndpoint = ApplyId.GetEndpoint(Request, AgentKey, Ref.Seed);
            string PreSign = "/Vault/" + ReferenceId + '/';
 
            if (!KeyEndpoint.Verify(Encoding.UTF8.GetBytes(PreSign), Signature))
            {
                await Response.SendResponse(new ForbiddenException("Invalid Signature."));
                return;
            }
 
            if (Ref.UseCount > 0)
            {
                Ref.UseCount--;
 
                if (Ref.UseCount == 0)
                    await Database.Delete(Ref);
                else
                    await Database.Update(Ref);
            }
 
            await Response.Return(GetFromVault.EncodeVaultItem(Item, Ref.Masked));
        }
    }
}