ApiHeaders.cs

Go to the documentation of this file.

using Microsoft.AspNetCore.Http.Headers;
using Microsoft.Extensions.Primitives;
using Microsoft.Net.Http.Headers;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Headers;
using System.Net.Mime;
using System.Reflection;
using System.Text;

namespace Tgstation.Server.Api
{
    public sealed class ApiHeaders
    {
        public const string ApiVersionHeader = "Api";

        public const string InstanceIdHeader = "Instance";

        public const string JwtAuthenticationScheme = "bearer";

        public const string BasicAuthenticationScheme = "basic";

        static readonly AssemblyName AssemblyName = Assembly.GetExecutingAssembly().GetName();

        public static readonly Version Version = AssemblyName.Version.Semver();

        public long? InstanceId { get; set; }

        public ProductHeaderValue? UserAgent => ProductInfoHeaderValue.TryParse(RawUserAgent, out var userAgent) ? userAgent.Product : null;

        public string? RawUserAgent { get; }

        public Version ApiVersion { get; }

        public string? Token { get; }

        public string? Username { get; }

        public string? Password { get; }

        public bool IsTokenAuthentication => Token != null;

        public static bool CheckCompatibility(Version otherVersion) => Version.Major == (otherVersion?.Major ?? throw new ArgumentNullException(nameof(otherVersion)));

        public ApiHeaders(ProductHeaderValue userAgent, string token) : this(userAgent, token, null, null)
        {
            if (userAgent == null)
                throw new ArgumentNullException(nameof(userAgent));
            if (token == null)
                throw new ArgumentNullException(nameof(token));
        }

        public ApiHeaders(ProductHeaderValue userAgent, string username, string password) : this(userAgent, null, username, password)
        {
            if (userAgent == null)
                throw new ArgumentNullException(nameof(userAgent));
            if (username == null)
                throw new ArgumentNullException(nameof(username));
            if (password == null)
                throw new ArgumentNullException(nameof(password));
        }

        public ApiHeaders(RequestHeaders requestHeaders)
        {
            if (requestHeaders == null)
                throw new ArgumentNullException(nameof(requestHeaders));

            var badHeaders = HeaderTypes.None;
            var errorBuilder = new StringBuilder();

            void AddError(HeaderTypes headerType, string message)
            {
                if (badHeaders != HeaderTypes.None)
                    errorBuilder.Append(Environment.NewLine);
                badHeaders |= headerType;
                errorBuilder.Append(message);
            }

            var jsonAccept = new Microsoft.Net.Http.Headers.MediaTypeHeaderValue(MediaTypeNames.Application.Json);
            if (!requestHeaders.Accept.Any(x => jsonAccept.IsSubsetOf(x)))
                AddError(HeaderTypes.Accept, $"Client does not accept {MediaTypeNames.Application.Json}!");

            if (!requestHeaders.Headers.TryGetValue(HeaderNames.UserAgent, out var userAgentValues) || userAgentValues.Count == 0)
                AddError(HeaderTypes.UserAgent, $"Missing {HeaderNames.UserAgent} header!");
            else
            {
                RawUserAgent = userAgentValues.First();
                if (String.IsNullOrWhiteSpace(RawUserAgent))
                    AddError(HeaderTypes.UserAgent, $"Malformed {HeaderNames.UserAgent} header!");
            }

            // make sure the api header matches ours
            Version? apiVersion = null;
            if (!requestHeaders.Headers.TryGetValue(ApiVersionHeader, out var apiUserAgentHeaderValues) || !ProductInfoHeaderValue.TryParse(apiUserAgentHeaderValues.FirstOrDefault(), out var apiUserAgent) || apiUserAgent.Product.Name != AssemblyName.Name)
                AddError(HeaderTypes.Api, $"Missing {ApiVersionHeader} header!");
            else if (!Version.TryParse(apiUserAgent.Product.Version, out apiVersion))
                AddError(HeaderTypes.Api, $"Malformed {ApiVersionHeader} header!");

            if (!requestHeaders.Headers.TryGetValue(HeaderNames.Authorization, out StringValues authorization))
                AddError(HeaderTypes.Authorization, $"Missing {HeaderNames.Authorization} header!");
            else
            {
                var auth = authorization.First();
                var splits = new List<string>(auth.Split(' '));
                var scheme = splits.First();
                if (String.IsNullOrWhiteSpace(scheme))
                    AddError(HeaderTypes.Authorization, "Missing authentication scheme!");
                else
                {
                    splits.RemoveAt(0);
                    var parameter = String.Concat(splits);
                    if (String.IsNullOrEmpty(parameter))
                        AddError(HeaderTypes.Authorization, "Missing authentication parameter!");
                    else
                    {
                        if (requestHeaders.Headers.TryGetValue(InstanceIdHeader, out var instanceIdValues))
                        {
                            var instanceIdString = instanceIdValues.FirstOrDefault();
                            if (instanceIdString != default && Int64.TryParse(instanceIdString, out var instanceId))
                                InstanceId = instanceId;
                        }

#pragma warning disable CA1308 // Normalize strings to uppercase
                        switch (scheme.ToLowerInvariant())
#pragma warning restore CA1308 // Normalize strings to uppercase
                        {
                            case JwtAuthenticationScheme:
                                Token = parameter;
                                break;
                            case BasicAuthenticationScheme:
                                string joinedString;
                                try
                                {
                                    var base64Bytes = Convert.FromBase64String(parameter);
                                    joinedString = Encoding.UTF8.GetString(base64Bytes);
                                }
                                catch
                                {
                                    throw new InvalidOperationException("Invalid basic Authorization header!");
                                }

                                var basicAuthSplits = joinedString.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
                                if (basicAuthSplits.Length < 2)
                                    throw new InvalidOperationException("Invalid basic Authorization header!");

                                Username = basicAuthSplits.First();
                                Password = String.Concat(basicAuthSplits.Skip(1));
                                break;
                            default:
                                AddError(HeaderTypes.Authorization, "Invalid authentication scheme!");
                                break;
                        }
                    }
                }
            }

            if (badHeaders != HeaderTypes.None)
                throw new HeadersException(badHeaders, errorBuilder.ToString());

            ApiVersion = apiVersion!.Semver();
        }

        ApiHeaders(ProductHeaderValue userAgent, string? token, string? username, string? password)
        {
            RawUserAgent = userAgent?.ToString();
            Token = token;
            Username = username;
            Password = password;
            ApiVersion = Version;
        }

        public bool Compatible() => CheckCompatibility(ApiVersion);

        public void SetRequestHeaders(HttpRequestHeaders headers, long? instanceId = null)
        {
            if (headers == null)
                throw new ArgumentNullException(nameof(headers));
            if (instanceId.HasValue && InstanceId.HasValue && instanceId != InstanceId)
                throw new InvalidOperationException("Specified different instance IDs in constructor and SetRequestHeaders!");

            headers.Clear();
            headers.Accept.Add(new MediaTypeWithQualityHeaderValue(MediaTypeNames.Application.Json));
            if (IsTokenAuthentication)
                headers.Authorization = new AuthenticationHeaderValue(JwtAuthenticationScheme, Token);
            else
                headers.Authorization = new AuthenticationHeaderValue(
                    BasicAuthenticationScheme,
                    Convert.ToBase64String(Encoding.UTF8.GetBytes($"{Username}:{Password}")));

            headers.UserAgent.Add(new ProductInfoHeaderValue(UserAgent));
            headers.Add(ApiVersionHeader, new ProductHeaderValue(AssemblyName.Name, ApiVersion.ToString()).ToString());
            instanceId ??= InstanceId;
            if (instanceId.HasValue)
                headers.Add(InstanceIdHeader, instanceId.ToString());
        }
    }
}