AipGateway/Aip.Service/Services/ApiAuthService.cs

using Aip.Service.Entities;
using Aip.Service.Repositories;
using Aip.Service.Services.Interfaces;
using System.Collections;

namespace Aip.Service.Services;

public class ApiAuthService : IApiAuthService
{
    private readonly ILogger<ApiAuthService> _log;
    private readonly IAipDbRepository _repo;


    private Hashtable _apiKeyMap = new Hashtable();
    private Hashtable _decryptKeyMap = new Hashtable();

    public ApiAuthService(ILogger<ApiAuthService> log, IAipDbRepository repo)
    {
        _log = log;
        _repo = repo;

        Inititialize();
    }

    private void Inititialize()
    {
        LoadLinkedApiKeys();
        LoadLinkedDecryptKeys();
    }
    private bool CheckApiRights(LinkedApiKey keyInfo, int apiId)
    {
        if (keyInfo == null) return false;

        // 레이블 조회 및 템플릿 조회 API 허용 여부
        // 파일 정보 조회 API 허용 여부
        // 레이블 적용 API 허용 여부
        // 레이블 해제 API 허용 여부
        // 파일 암호화 API 허용 여부
        // 파일 복호화 API 허용 여부
        if (apiId >= GlobalConstants.API_DB_RELOAD && apiId <= GlobalConstants.API_DB_LINKED_DECRYPT_KEYS)
        {
            return keyInfo.policyLookupYn;
        }
        if (apiId == GlobalConstants.API_AIP_DOWNLOAD ||
            apiId == GlobalConstants.API_AIP_LABELS ||
            apiId == GlobalConstants.API_AIP_POLICIES ||
            apiId == GlobalConstants.API_AIP_PROTECTIONS ||
            apiId == GlobalConstants.API_FILE_INFO ||
            apiId == GlobalConstants.API_STREAM_INFO)
        {
            return keyInfo.fileInfoLookupYn;
        }
        if (apiId == GlobalConstants.API_FILE_SET_LABEL ||
            apiId == GlobalConstants.API_FILE_SET_LABELS ||
            apiId == GlobalConstants.API_STREAM_SET_LABEL ||
            apiId == GlobalConstants.API_STREAM_SET_LABELS)
        {
            return keyInfo.applyLabelYn;
        }
        if (apiId == GlobalConstants.API_FILE_DELETE_LABEL ||
            apiId == GlobalConstants.API_FILE_DELETE_LABELS ||
            apiId == GlobalConstants.API_STREAM_DELETE_LABEL ||
            apiId == GlobalConstants.API_STREAM_DELETE_LABELS)
        {
            return keyInfo.releaseLabelYn;
        }
        if (apiId == GlobalConstants.API_FILE_SET_PROTECTION ||
            apiId == GlobalConstants.API_STREAM_SET_PROTECTION ||
            apiId == GlobalConstants.API_FILE_ENCRYPT ||
            apiId == GlobalConstants.API_STREAM_ENCRYPT)
        {
            return keyInfo.encryptionFileYn;
        }

        if (apiId == GlobalConstants.API_FILE_DELETE_PROTECTIN ||
            apiId == GlobalConstants.API_STREAM_DELETE_PROTECTIN ||
            apiId == GlobalConstants.API_FILE_DECRYPT ||
            apiId == GlobalConstants.API_STREAM_DECRYPT)
        {
            return keyInfo.decryptionFileYn;
        }
        if (apiId == GlobalConstants.API_FILE_SET_LABEL_PROTECTION ||
            apiId == GlobalConstants.API_STREAM_SET_LABEL_PROTECTION)
        {
            return keyInfo.applyLabelYn && keyInfo.encryptionFileYn;
        }
        if (apiId == GlobalConstants.API_FILE_DELETE_LABEL_PROTECTION ||
            apiId == GlobalConstants.API_STREAM_DELETE_LABEL_PROTECTION)
        {
            return keyInfo.releaseLabelYn && keyInfo.decryptionFileYn;
        }

        if (apiId == GlobalConstants.API_DUMMY)
        {
            return true;
        }
        return false;
    }

    public int CheckApiKeyValidation(HttpContext httpContext, string apiKey, int apiId)
    {
        string errMsg;
        string? ipAddress = httpContext.Connection.RemoteIpAddress?.ToString();
        ipAddress = string.IsNullOrEmpty(ipAddress) ? "xx.xx.xx.xx" : ipAddress;
        try
        {
            if (_apiKeyMap.ContainsKey(apiKey))
            {
                LinkedApiKey? apiKeyData = _apiKeyMap[apiKey] as LinkedApiKey;
                if (apiKeyData == null)
                {
                    return 1;   // 등록되어 있지 않은 키 정보입니다.
                }

                if (!CheckApiRights(apiKeyData, apiId))
                {
                    return 4;   // API 사용 권한이 없습니다.
                }

                LinkedApiKey? server = apiKeyData.serverMap[ipAddress] as LinkedApiKey;
                if (server == null)
                {
                    return 2;   // 등록되어 있지 않은 IP Address에서 호출된 API KEY 입니다.
                }
                if (DateTime.Compare(server.ExpiredAt, DateTime.Now) < 0)
                {
                    return 3;   // API KEY 유효기간이 지났습니다.
                }

                return 0;   // OK
            }
            else
            {
                errMsg = "등록되어 있지 않은 API KEY 입니다.";
                return 1;   // 등록되어 있지 않은 키 정보입니다.
            }
        }
        catch (Exception ex)
        {
            errMsg = ex.Message;
            return 4;
        }
    }

    public int LoadAuthInformation()
    {
        LoadLinkedApiKeys();
        LoadLinkedDecryptKeys();
        return _apiKeyMap.Count + _decryptKeyMap.Count; 
    }
    public void LoadLinkedApiKeys()
    {
        Hashtable keyMap = new Hashtable();

        List<LinkedApiKey> result = _repo.LoadLinkedApiKeys().Result;
        if (result != null)
        {
            foreach (LinkedApiKey key in result)
            {
                LinkedApiKey? apiKey = keyMap[key.ApiKey] as LinkedApiKey;
                if (apiKey == null)
                {
                    // SERVER 추가
                    key.serverMap = new Hashtable();
                    key.serverMap.Add(key.ServerIpAddr, key);

                    // API KEY 추가
                    keyMap.Add(key.ApiKey, key);
                }
                else
                {
                    LinkedApiKey? server = apiKey.serverMap[key.ServerIpAddr] as LinkedApiKey;
                    if (server == null)
                    {
                        apiKey.serverMap.Add(key.ServerIpAddr, key);
                    }
                }
            }
        }

        _apiKeyMap = keyMap;

        foreach (string key in _apiKeyMap.Keys)
        {
            LinkedApiKey? apiKey = _apiKeyMap[key] as LinkedApiKey;
            if (apiKey != null)
            {
                _log.LogInformation("       API KEY: {0}", apiKey.ApiKey);
                foreach (string serverIp in apiKey.serverMap.Keys)
                {
                    LinkedApiKey? server = apiKey.serverMap[serverIp] as LinkedApiKey;
                    if (server != null)
                    {
                        _log.LogInformation("API KEY SERVER: {0}, {1}", server.ApiKey, server.ServerIpAddr);
                    }
                }
            }
        }
    }
    public void LoadLinkedDecryptKeys()
    {
        Hashtable keyMap = new Hashtable();

        List<LinkedDecryptKey> result = _repo.LoadLinkedDecryptKeys().Result;
        if (result != null)
        {
            foreach (LinkedDecryptKey key in result)
            {
                LinkedDecryptKey? apiKey = keyMap[key.DecryptKey] as LinkedDecryptKey;
                if (apiKey == null)
                {
                    // SERVER 추가
                    key.serverMap = new Hashtable();
                    key.serverMap.Add(key.ServerIpAddr, key);

                    // DESCRYPT KEY 추가
                    keyMap.Add(key.DecryptKey, key);
                }
                else
                {
                    LinkedDecryptKey? server = apiKey.serverMap[key.ServerIpAddr] as LinkedDecryptKey;
                    if (server == null)
                    {
                        apiKey.serverMap.Add(key.ServerIpAddr, key);
                    }
                }
            }
        }

        _decryptKeyMap = keyMap;

        foreach (string key in _decryptKeyMap.Keys)
        {
            LinkedDecryptKey? apiKey = _decryptKeyMap[key] as LinkedDecryptKey;
            if (apiKey != null)
            {
                _log.LogInformation("       DESCRYPT KEY: {0}", apiKey.DecryptKey);
                foreach (string serverIp in apiKey.serverMap.Keys)
                {
                    LinkedDecryptKey? server = apiKey.serverMap[serverIp] as LinkedDecryptKey;
                    if (server != null)
                    {
                        _log.LogInformation("DESCRYPT KEY SERVER: {0}, {1}", server.DecryptKey, server.ServerIpAddr);
                    }
                }
            }
        }
    }
}