irc-netcore-api/IRaCIS.Core.Application/Service/MinimalApiService/HIRActivateService.cs

using IRaCIS.Application.Contracts;
using IRaCIS.Core.Infrastructure.Encryption;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Options;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;

namespace IRaCIS.Core.Application.Service;

public class HIRActivateService : ServiceBase
{

    /// <summary>
    /// 获取授权码明文信息
    /// </summary>
    /// <param name="authorizationCode"></param>
    /// <param name="_hospitalOption"></param>
    /// <returns></returns>
    [AllowAnonymous]
    public async Task<IResponseOutput> GetAuthorizationCodeInfo(string authorizationCode, [FromServices] IOptionsMonitor<SystemHospitalOption> _hospitalOption)
    {
        // 解密 Base64 编码后的数据
        byte[] base64DecodedBytes = Convert.FromBase64String(authorizationCode);
        string decodedText = System.Text.Encoding.UTF8.GetString(base64DecodedBytes);


        var authInfo = JsonConvert.DeserializeObject<TrialAuthorizationInfo>(decodedText);

        if (authInfo == null)
        {
            return ResponseOutput.NotOk("不能解析该项目授权码");
        }

        return ResponseOutput.Ok(decodedText);
    }

    /// <summary>
    /// 获取项目激活码
    /// </summary>
    /// <param name="decodedText"></param>
    /// <param name="_basicSystemConfigConfig"></param>
    /// <returns></returns>
    [AllowAnonymous]
    [RoutePattern(HttpMethod = "get")]
    public async Task<IResponseOutput> GetTrialActivationCode(string decodedText, [FromServices] IOptionsMonitor<ServiceVerifyConfigOption> _basicSystemConfigConfig)
    {

        var authorizationInfo = JsonConvert.DeserializeObject<TrialAuthorizationInfo>(decodedText);

        if (authorizationInfo != null)
        {
            //一周内激活
            authorizationInfo.ActiveDeadLineDate = DateTime.Now.Date.AddDays(8).AddSeconds(-1);
            var info = Cryptography.EncryptString($"{JsonConvert.SerializeObject(authorizationInfo)}", "HIR_System_AES_Key_Info", "Trial_AuthorizationEncrypt");

            Console.WriteLine("HIR_System_AES_Key_Info".PadRight(32, '0').Substring(0, 32)+"    "+ "Trial_AuthorizationEncrypt".PadRight(16, '0').Substring(0, 16));
            var enCrept = AesEncryption.Encrypt($"{JsonConvert.SerializeObject(authorizationInfo)}", "HIR_System_AES_Key_Info", "Trial_AuthorizationEncrypt");

            var dd= AesEncryption.Decrypt(enCrept, "HIR_System_AES_Key_Info", "Trial_AuthorizationEncrypt");

            return ResponseOutput.Ok(info);
        }
        else
        {
            return ResponseOutput.NotOk("激活码解密文本信息有误");
        }

       

    }
}

public class TrialAuthorizationInfo
{
    public Guid TrialId { get; set; }
    public Guid CreateUserId { get; set; }
    public string TrialCode { get; set; }

    public string HospitalName { get; set; }

    public string HospitalCode { get; set; }

    public int PurchaseDuration { get; set; }



    public List<CriterionType> CriterionTypeList { get; set; }

    public DateTime? AuthorizationDeadLineDate { get; set; }

    public DateTime? ActiveDeadLineDate { get; set; }

    public DateTime? ActiveTime { get; set; }

}

public class Cryptography
{
    public static string EncryptString(string plainText, string key, string iv)
    {
        using (Aes aesAlg = Aes.Create())
        {
            aesAlg.Key = GetKeyBytes(key, aesAlg.KeySize / 8);
            aesAlg.IV = GetKeyBytes(iv, 16);

            ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

            using (MemoryStream msEncrypt = new MemoryStream())
            {
                using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                {
                    byte[] plainBytes = Encoding.UTF8.GetBytes(plainText);
                    csEncrypt.Write(plainBytes, 0, plainBytes.Length);
                    csEncrypt.FlushFinalBlock();
                }
                return Convert.ToBase64String(msEncrypt.ToArray());
            }
        }
    }

    public static string DecryptString(string cipherText, string key, string iv)
    {
        byte[] cipherBytes = Convert.FromBase64String(cipherText);
        using (Aes aesAlg = Aes.Create())
        {
            aesAlg.Key = GetKeyBytes(key, aesAlg.KeySize / 8);
            aesAlg.IV = GetKeyBytes(iv, 16);

            ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);

            using (MemoryStream msDecrypt = new MemoryStream(cipherBytes))
            {
                using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
                {
                    using (StreamReader srDecrypt = new StreamReader(csDecrypt))
                    {
                        return srDecrypt.ReadToEnd();
                    }
                }
            }
        }
    }

    private static byte[] GetKeyBytes(string key, int keySize)
    {


        using (var deriveBytes = new PasswordDeriveBytes(key, null))
        {
            return deriveBytes.GetBytes(keySize);
        }
    }
}