ApiHeaders.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Headers;
using System.Net.Mime;
using System.Reflection;
using System.Text;
 
using Microsoft.AspNetCore.Http.Headers;
using Microsoft.Extensions.Primitives;
using Microsoft.Net.Http.Headers;
 
using Tgstation.Server.Api.Models;
using Tgstation.Server.Api.Properties;
 
namespace Tgstation.Server.Api
{
    public sealed class ApiHeaders
    {
        public const string ApiVersionHeader = "Api";
 
        public const string InstanceIdHeader = "Instance";
 
        public const string OAuthProviderHeader = "OAuthProvider";
 
        public const string BearerAuthenticationScheme = "Bearer";
 
        public const string BasicAuthenticationScheme = "Basic";
 
        public const string OAuthAuthenticationScheme = "OAuth";
 
        public const string ApplicationJsonMime = "application/json";
 
        public static readonly Version Version = Version.Parse(ApiVersionAttribute.Instance.RawApiVersion);
 
        static readonly AssemblyName AssemblyName = Assembly.GetExecutingAssembly().GetName();
 
        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 OAuthProvider? OAuthProvider { get; }
 
        public bool IsTokenAuthentication => Token != null && !OAuthProvider.HasValue;
 
        public static bool CheckCompatibility(Version otherVersion) => Version.Major == (otherVersion?.Major ?? throw new ArgumentNullException(nameof(otherVersion)));
 
        public ApiHeaders(ProductHeaderValue userAgent, string token, OAuthProvider? oauthProvider = null) : this(userAgent, token, null, null)
        {
            if (userAgent == null)
                throw new ArgumentNullException(nameof(userAgent));
            if (token == null)
                throw new ArgumentNullException(nameof(token));
 
            OAuthProvider = oauthProvider;
        }
 
        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));
        }
 
#pragma warning disable CA1502
        public ApiHeaders(RequestHeaders requestHeaders, bool ignoreMissingAuth = false)
        {
            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.AppendLine();
                badHeaders |= headerType;
                errorBuilder.Append(message);
            }
 
            var jsonAccept = new Microsoft.Net.Http.Headers.MediaTypeHeaderValue(ApplicationJsonMime);
            if (!requestHeaders.Accept.Any(x => jsonAccept.IsSubsetOf(x)))
                AddError(HeaderTypes.Accept, $"Client does not accept {ApplicationJsonMime}!");
 
            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))
            {
                if (!ignoreMissingAuth)
                    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;
                        }
 
                        switch (scheme)
                        {
                            case OAuthAuthenticationScheme:
                                if (requestHeaders.Headers.TryGetValue(OAuthProviderHeader, out StringValues oauthProviderValues))
                                {
                                    var oauthProviderString = oauthProviderValues.First();
                                    if (Enum.TryParse<OAuthProvider>(oauthProviderString, out var oauthProvider))
                                        OAuthProvider = oauthProvider;
                                    else
                                        AddError(HeaderTypes.OAuthProvider, "Invalid OAuth provider!");
                                }
                                else
                                    AddError(HeaderTypes.OAuthProvider, $"Missing {OAuthProviderHeader} header!");
 
                                goto case BearerAuthenticationScheme;
                            case BearerAuthenticationScheme:
                                Token = parameter;
                                break;
                            case BasicAuthenticationScheme:
                                string badBasicAuthHeaderMessage = $"Invalid basic {HeaderNames.Authorization} header!";
                                string joinedString;
                                try
                                {
                                    var base64Bytes = Convert.FromBase64String(parameter);
                                    joinedString = Encoding.UTF8.GetString(base64Bytes);
                                }
                                catch
                                {
                                    AddError(HeaderTypes.Authorization, badBasicAuthHeaderMessage);
                                    break;
                                }
 
                                var basicAuthSplits = joinedString.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
                                if (basicAuthSplits.Length < 2)
                                {
                                    AddError(HeaderTypes.Authorization, badBasicAuthHeaderMessage);
                                    break;
                                }
 
                                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();
        }
#pragma warning restore CA1502
 
        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(ApplicationJsonMime));
            headers.UserAgent.Add(new ProductInfoHeaderValue(UserAgent));
            headers.Add(ApiVersionHeader, new ProductHeaderValue(AssemblyName.Name, ApiVersion.ToString()).ToString());
            if (OAuthProvider.HasValue)
            {
                headers.Authorization = new AuthenticationHeaderValue(OAuthAuthenticationScheme, Token);
                headers.Add(OAuthProviderHeader, OAuthProvider.ToString());
            }
            else if (!IsTokenAuthentication)
                headers.Authorization = new AuthenticationHeaderValue(
                    BasicAuthenticationScheme,
                    Convert.ToBase64String(Encoding.UTF8.GetBytes($"{Username}:{Password}")));
            else
                headers.Authorization = new AuthenticationHeaderValue(BearerAuthenticationScheme, Token);
 
            instanceId ??= InstanceId;
            if (instanceId.HasValue)
                headers.Add(InstanceIdHeader, instanceId.ToString());
        }
    }
}