UploadSignature.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.ExceptionServices;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Content.Xml;
using Waher.IoTGateway;
using Waher.Networking.HTTP;
using Waher.Networking.HTTP.HeaderFields;
using Waher.Persistence;
using Waher.Service.IoTBroker.Provisioning.SoftwareUpdates;
 
namespace Waher.Service.IoTBroker.WebServices
{
    public class UploadSignature : HttpSynchronousResource, IHttpPostMethod
    {
        private static readonly Dictionary<string, UploadPackage.UploadRec> signatureFilePerSession = new Dictionary<string, UploadPackage.UploadRec>();
        private static int expectedBlockSignature = 0;
 
        public UploadSignature()
            : base("/UploadSignature")
        {
        }
 
        public override bool HandlesSubPaths => false;
        public override bool UserSessions => true;
        public bool AllowsPOST => true;
 
        public async Task POST(HttpRequest Request, HttpResponse Response)
        {
            KeyValuePair<bool, int> P = await UploadPackage.Upload(Request, Response, expectedBlockSignature, signatureFilePerSession, "signature", false);
            expectedBlockSignature = P.Value;
 
            if (P.Key)
            {
                UploadPackage.UploadRec PackageRec;
                UploadPackage.UploadRec SignatureRec;
                string TabID;
                string HttpSessionID;
 
                if (!Request.Header.TryGetHeaderField("X-TabID", out HttpField F) || string.IsNullOrEmpty(TabID = F.Value) ||
                    string.IsNullOrEmpty(HttpSessionID = GetSessionId(Request, Response)))
                {
                    throw new BadRequestException();
                }
 
                PackageRec = GetAndRemoveFile(HttpSessionID, UploadPackage.packageFilePerSession);
                SignatureRec = GetAndRemoveFile(HttpSessionID, signatureFilePerSession);
 
                CopyPackage(PackageRec, SignatureRec, TabID, Request.Session["packageFileName"]?.ToString(), Request.RemoteEndPoint);
            }
        }
 
        private static UploadPackage.UploadRec GetAndRemoveFile(string SessionID, Dictionary<string, UploadPackage.UploadRec> Files)
        {
            lock (Files)
            {
                if (Files.TryGetValue(SessionID, out UploadPackage.UploadRec Rec))
                {
                    Files.Remove(SessionID);
                    return Rec;
                }
                else
                    return null;
            }
        }
 
        private static async void CopyPackage(UploadPackage.UploadRec PackageRec, UploadPackage.UploadRec SignatureRec, string TabID,
            string PackageFileName, string RemoteEndpoint)
        {
            try
            {
                if (PackageRec.File.Length > int.MaxValue)
                    throw new Exception("Package file too large.");
 
                XmlDocument Doc = new XmlDocument()
                {
                    PreserveWhitespace = true
                };
                SignatureRec.File.Position = 0;
                Doc.Load(SignatureRec.File);
 
                if (Doc.DocumentElement is null ||
                    Doc.DocumentElement.LocalName != "Signatures" ||
                    Doc.DocumentElement.NamespaceURI != "http://waher.se/Schema/Signatures.xsd")
                {
                    throw new Exception("Invalid signature file.");
                }
 
                byte[] Signature = null;
 
                foreach (XmlNode N in Doc.DocumentElement.ChildNodes)
                {
                    if (N is XmlElement E && E.LocalName == "Signature" && XML.Attribute(E, "fileName") == PackageFileName)
                    {
                        try
                        {
                            Signature = Convert.FromBase64String(E.InnerText);
                        }
                        catch (Exception)
                        {
                            throw new Exception("Invalid signature.");
                        }
                        break;
                    }
                }
 
                if (Signature is null)
                    throw new Exception("Signature for corresponding package file not included in uploaded signature file.");
 
                await CopyPackage(PackageRec, Signature, TabID, PackageFileName, RemoteEndpoint);
            }
            catch (Exception ex)
            {
                await ClientEvents.PushEvent(new string[] { TabID }, "UploadFailed",
                    "{\"fileName\":\"" + CommonTypes.JsonStringEncode(PackageFileName) +
                    "\", \"message\": \"" + CommonTypes.JsonStringEncode(ex.Message) + "\", \"remove\": true}", true, "User");
            }
            finally
            {
                PackageRec.File.Dispose();
                SignatureRec.File.Dispose();
            }
        }
 
        internal static async Task CopyPackage(UploadPackage.UploadRec PackageRec, byte[] Signature, string TabID,
            string PackageFileName, string RemoteEndpoint)
        {
            DateTime Now = DateTime.UtcNow;
            Package Package = await Provisioning.ProvisioningComponent.GetPackage(PackageFileName);
            long Size = PackageRec.File.Length;
            bool PrevDownloadable;
            bool Downloadable = PackageRec.MakeDownloadable;
 
            if (Package is null)
            {
                PrevDownloadable = false;
 
                Package = new Package()
                {
                    FileName = PackageFileName,
                    Signature = Signature,
                    RemoteEndpoint = RemoteEndpoint,
                    Published = Now,
                    Supersedes = DateTime.MinValue,
                    Created = Now,
                    Bytes = Size,
                    AesKey = null,
                    Installed = DateTime.MinValue,
                    PublicKey = null,
                    Downloadable = false
                };
 
                await Database.Insert(Package);
            }
            else
            {
                PrevDownloadable = Package.Downloadable;
 
                Package.Signature = Signature;
                Package.RemoteEndpoint = RemoteEndpoint;
                Package.Supersedes = Package.Published;
                Package.Published = Now;
                Package.Bytes = Size;
                Package.Downloadable = Downloadable;
 
                if (!(Package.AesKey is null))
                    Package.ContentOnly = XmppServerModule.IsContentPackage(Package);
 
                await Database.Update(Package);
            }
 
            bool NewSoftware = string.Compare(PackageFileName, BrokerPackage.FileName, true) == 0;
            bool InstallPackage = Package.Installed > DateTime.MinValue;
 
            try
            {
                if (NewSoftware)
                {
                    PackageRec.File.Position = 0;
                    if (!XmppServerModule.ValidateIoTBrokerPackage(PackageRec.File, Signature))
                        throw new Exception("Invalid IoT Broker package. Signature invalid.");
                }
 
                using (FileStream f = File.Create(Path.Combine(XmppServerModule.PackagesFolder, PackageFileName)))
                {
                    PackageRec.File.Position = 0;
                    await PackageRec.File.CopyToAsync(f);
                }
 
                if (PackageRec.MakeDownloadable)
                {
                    string DownloadsFolder = XmppServerModule.DownloadsFolder;
 
                    if (!Directory.Exists(DownloadsFolder))
                        Directory.CreateDirectory(DownloadsFolder);
 
                    using (FileStream f = File.Create(Path.Combine(DownloadsFolder, PackageFileName)))
                    {
                        PackageRec.File.Position = 0;
                        await PackageRec.File.CopyToAsync(f);
                    }
                }
            }
            catch (Exception ex)
            {
                await Database.Delete(Package);
                ExceptionDispatchInfo.Capture(ex).Throw();
            }
 
            if (PrevDownloadable && !Downloadable)
            {
                string FullPath = Path.Combine(XmppServerModule.DownloadsFolder, Package.FileName);
 
                if (File.Exists(FullPath))
                    File.Delete(FullPath);
            }
 
            string s = Convert.ToBase64String(Package.Signature);
            await ClientEvents.PushEvent(new string[] { TabID }, "UploadDone",
                "{\"fileName\":\"" + CommonTypes.JsonStringEncode(PackageFileName) +
                "\", \"relativeUrl\": \"" + CommonTypes.JsonStringEncode(Package.RelativeUrl) +
                "\", \"bytes\": \"" + Export.FormatBytes(Package.Bytes) +
                "\", \"created\": \"" + Package.Created.ToString() +
                "\", \"supersedes\": \"" + (Package.Supersedes == DateTime.MinValue ? string.Empty : Package.Supersedes.ToString()) +
                "\", \"published\": \"" + Package.Published.ToString() +
                "\", \"remoteEndpoint\": \"" + CommonTypes.JsonStringEncode(Package.RemoteEndpoint.ToString()) +
                "\", \"signature\": \"<a href='javascript:window.alert(\\\"" + s + "\\\")'>" + s.Substring(0, 10) + "...</a>" +
                "\", \"button\": \"<button class='negButtonSm' onclick='DeletePackage(\\\"" + Package.FileName.Replace("\"", "\\\"") + "\\\")'>Delete</button>" +
                "\", \"message\": \"Package successfully uploaded.\"}", true, "User");
 
            await XmppServerModule.Provisioning.NewPackage(Package);
 
            if (NewSoftware || InstallPackage)
                await XmppServerModule.Instance.NewSoftwareAvailable(Package, RemoteEndpoint);
        }
 
    }
}