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.Globalization;
using System.Linq;
using System.Net.Http.Headers;
using System.Reflection;
using System.Text;

namespace Tgstation.Server.Api
{
    public sealed class ApiHeaders
    {
        public const string ApplicationJson = "application/json";

        public const string ApiVersionHeader = "api";

        public const string InstanceIdHeader = "instance";

        public const string JwtAuthenticationScheme = "bearer";

        public const string BasicAuthenticationScheme = "basic";

        const string UsernameHeader = "username";

        const string PasswordAuthenticationScheme = "password";

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

        public static Version Version => AssemblyName.Version;

        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))) || Version.Minor > otherVersion.Minor);

        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 jsonAccept = new Microsoft.Net.Http.Headers.MediaTypeHeaderValue(ApplicationJson);
            if (!requestHeaders.Accept.Any(x => x.MediaType == jsonAccept.MediaType))
                throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, "Client does not accept {0}!", ApplicationJson));

            if (!requestHeaders.Headers.TryGetValue(HeaderNames.UserAgent, out var userAgentValues) || userAgentValues.Count == 0)
                throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, "Missing {0} headers!", HeaderNames.UserAgent));

            RawUserAgent = userAgentValues.First();
            if (String.IsNullOrWhiteSpace(RawUserAgent))
                throw new InvalidOperationException("Malformed client User-Agent!");

            // make sure the api header matches ours
            if (!requestHeaders.Headers.TryGetValue(ApiVersionHeader, out var apiUserAgentHeaderValues) || !ProductInfoHeaderValue.TryParse(apiUserAgentHeaderValues.FirstOrDefault(), out var apiUserAgent) || apiUserAgent.Product.Name != AssemblyName.Name)
                throw new InvalidOperationException("Missing API version!");

            if (!Version.TryParse(apiUserAgent.Product.Version, out var apiVersion))
                throw new InvalidOperationException("Malformed API version!");

            ApiVersion = apiVersion;

            if (!requestHeaders.Headers.TryGetValue(HeaderNames.Authorization, out StringValues authorization))
                throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, "Missing {0} header!", HeaderNames.Authorization));
            var auth = authorization.First();
            var splits = new List<string>(auth.Split(' '));
            var scheme = splits.First();
            if (String.IsNullOrWhiteSpace(scheme))
                throw new InvalidOperationException("Missing authentication scheme!");

            splits.RemoveAt(0);
            var parameter = String.Concat(splits);
            if (String.IsNullOrEmpty(parameter))
                throw new InvalidOperationException("Missing authentication parameter!");

            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 PasswordAuthenticationScheme:
                    Password = parameter;
                    var fail = !requestHeaders.Headers.TryGetValue(UsernameHeader, out var values);
                    if (!fail)
                    {
                        Username = values.FirstOrDefault();
                        fail = String.IsNullOrWhiteSpace(Username);
                    }

                    if (fail)
                        throw new InvalidOperationException("Missing Username header!");
                    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:
                    throw new InvalidOperationException("Invalid authentication scheme!");
            }
        }

        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 instance ID in constructor and SetRequestHeaders!");

            headers.Clear();
            headers.Accept.Add(new MediaTypeWithQualityHeaderValue(ApplicationJson));
            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 ?? InstanceId;
            if (instanceId.HasValue)
                headers.Add(InstanceIdHeader, instanceId.ToString());
        }
    }
}