ProtectedResourceMetaData.cs

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using Waher.Networking.HTTP.OAuth.MetaData;
 
namespace Waher.Networking.HTTP.OAuth
{
    public class ProtectedResourceMetaData : OAuthResource, IHttpGetMethod
    {
        public const string WellKnowResourcePath = "/.well-known/oauth-protected-resource";
 
        public ProtectedResourceMetaData(OAuth2Environment Environment)
            : base(Environment, WellKnowResourcePath)
        {
            Environment.Register(this);
        }
 
        public override bool HandlesSubPaths => true;
 
        public bool AllowsGET => true;
 
        public async Task GET(HttpRequest Request, HttpResponse Response)
        {
            string ResourceName = Request.SubPath;
 
            if (string.IsNullOrEmpty(ResourceName))
            {
                await BadRequest(Response, "invalid_request", "No resource subpath provided.");
                return;
            }
            
            if (!(Request.Server?.TryGetResource(ref ResourceName, false, 
                out HttpResource Resource, out string SubPath) ?? false) ||
                !string.IsNullOrEmpty(SubPath))
            {
                await NotFound(Response, "invalid_request", "Resource not found: " + ResourceName);
                return;
            }
 
            StringBuilder sb = GenerateServerUrl(Request, out int Port);
            string ServerUrl = sb.ToString();
 
            sb.Append(ResourceName);
            string ResourceUrl = sb.ToString();
 
            ClientCertificates ClientCertificatesConfig;
 
            if (Request.Server is null)
                ClientCertificatesConfig = ClientCertificates.NotUsed;
            else
                Request.Server.GetMTlsSettings(Port, out ClientCertificatesConfig, out _);
 
            Dictionary<string, object> MetaData = new Dictionary<string, object>()
            {
                { "resource", ResourceUrl },
                { "authorization_servers", new string[] { ServerUrl } },
                { "bearer_methods_supported", new string[] { "header", "body" } },
                { "tls_client_certificate_bound_access_tokens", ClientCertificatesConfig != ClientCertificates.NotUsed }
            };
 
            OAuthMetaDataAttribute[] OAuthMetaDAtaAttributes = Resource.GetType().GetCustomAttributes<OAuthMetaDataAttribute>(true) as OAuthMetaDataAttribute[] ?? Array.Empty<OAuthMetaDataAttribute>();
 
            foreach (OAuthMetaDataAttribute Attribute in OAuthMetaDAtaAttributes)
                await Attribute.AddMetaData(Resource, MetaData);
 
            await Response.Return(MetaData);
        }
 
        public static StringBuilder GenerateServerUrl(HttpRequest Request, out int Port)
        {
            return GenerateServerUrl(Request.Server, Request.Encrypted, Request.Host, out Port);
        }
 
        public StringBuilder GenerateServerUrl(bool Encrypted, string? Host, out int Port)
        {
            return GenerateServerUrl(this.FirstServer, Encrypted, Host, out Port);
        }
 
        public static StringBuilder GenerateServerUrl(HttpServer Server, bool Encrypted, 
            string? Host, out int Port)
        { 
            StringBuilder sb = new StringBuilder();
            bool DefaultPort;
 
            sb.Append("http");
            if (Encrypted)
            {
                int[]? Ports = Server?.OpenHttpsPorts;
 
                if ((Ports?.Length ?? 0) > 0)
                {
                    sb.Append('s');
                    Port = GetPort(Server?.OpenHttpsPorts, HttpServer.DefaultHttpsPort);
                    DefaultPort = Port == HttpServer.DefaultHttpsPort;
                }
                else
                {
                    Port = GetPort(Server?.OpenHttpPorts, HttpServer.DefaultHttpPort);
                    DefaultPort = Port == HttpServer.DefaultHttpPort;
                }
            }
            else
            {
                Port = GetPort(Server?.OpenHttpPorts, HttpServer.DefaultHttpPort);
                DefaultPort = Port == HttpServer.DefaultHttpPort;
            }
 
            sb.Append("://");
            sb.Append(Host ?? "localhost"); // TODO: Public IP, if available, instead of localhost.
 
            if (!DefaultPort)
            {
                sb.Append(':');
                sb.Append(Port.ToString());
            }
 
            return sb;
        }
 
        private static int GetPort(int[]? Ports, int DefaultPort)
        {
            if (Ports is null || Ports.Length == 0)
                return DefaultPort;
            else
                return Ports[0];
        }
 
        public string GetResourceMetaDataUri(bool Encrypted, string? Domain, string ResourceName)
        {
            StringBuilder sb = this.GenerateServerUrl(Encrypted, Domain, out _);
            sb.Append(this.ResourceName);
            sb.Append(ResourceName);
            return sb.ToString();
        }
    }
}