Testing more garbage encryption

SVSim.EmulatedEntrypoint/Security/Encryption.cs

@@ -58,27 +58,29 @@ public static class Encryption
     /// <returns>the decrypted bytes</returns>
     public static byte[] Decrypt(byte[] encryptedData, string udId)
     {
-        using (var rj = Aes.Create())
+        using (var rj = new RijndaelManaged())
         {
             rj.KeySize = EncryptionKeySize;
             rj.Mode = EncryptionMode;
             rj.BlockSize = EncryptionBlockSize;
+            //rj.Padding = PaddingMode.None;
             byte[] rgbIv = Encoding.UTF8.GetBytes(udId.Replace("-", string.Empty).Substring(0, UdIdKeySize));
             byte[] keyBytes = new byte[KeyStringSize];
             byte[] encryptedValueBytes = new byte[encryptedData.Length - KeyStringSize];
             Array.Copy(encryptedData, encryptedData.Length - keyBytes.Length, keyBytes, 0, keyBytes.Length);
             Array.Copy(encryptedData, 0, encryptedValueBytes, 0, encryptedValueBytes.Length);
             ICryptoTransform transform = rj.CreateDecryptor(keyBytes, rgbIv);
+            byte[] decryptedValueBytes = new byte[encryptedValueBytes.Length];
             using (MemoryStream ms = new MemoryStream(encryptedValueBytes))
             {
                 using (CryptoStream cs = new CryptoStream(ms, transform, CryptoStreamMode.Read))
                 {
-                    byte[] decryptedValueBytes = new byte[encryptedValueBytes.Length];
-                    cs.Read(decryptedValueBytes, 0, encryptedValueBytes.Length);
-                    cs.FlushFinalBlock();
-                    return decryptedValueBytes;
+                    cs.CopyTo(decryptedValueBytes);
+                    cs.Flush();
+                    ms.Flush();
                 }
             }
+            return decryptedValueBytes;
         }
     }
 

SVSim.EmulatedEntrypoint/Security/SteamSessionAuthentication/SteamAuthenticationConstants.cs

@@ -0,0 +1,7 @@
+namespace SVSim.EmulatedEntrypoint.Security.SteamSessionAuthentication;
+
+public static class SteamAuthenticationConstants
+{
+    public const string SchemeName = "SteamAuthentication";
+    public const string SteamIdClaim = "SteamId";
+}

SVSim.EmulatedEntrypoint/Security/SteamSessionAuthentication/SteamSessionAuthenticationHandler.cs

@@ -1,21 +1,74 @@
+using System.Security.Claims;
+using System.Text;
 using System.Text.Encodings.Web;
 using Microsoft.AspNetCore.Authentication;
 using Microsoft.Extensions.Options;
+using Newtonsoft.Json;
+using SVSim.Database.Enums;
+using SVSim.Database.Models;
+using SVSim.Database.Repositories.Viewer;
+using SVSim.EmulatedEntrypoint.Constants;
+using SVSim.EmulatedEntrypoint.Models.Dtos.Requests;
+using SVSim.EmulatedEntrypoint.Services;
 
 namespace SVSim.EmulatedEntrypoint.Security.SteamSessionAuthentication;
 
 public class SteamSessionAuthenticationHandler : AuthenticationHandler<SteamAuthenticationHandlerOptions>
 {
-    public SteamSessionAuthenticationHandler(IOptionsMonitor<SteamAuthenticationHandlerOptions> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock) : base(options, logger, encoder, clock)
-    {
-    }
-
-    public SteamSessionAuthenticationHandler(IOptionsMonitor<SteamAuthenticationHandlerOptions> options, ILoggerFactory logger, UrlEncoder encoder) : base(options, logger, encoder)
+    private readonly SteamSessionService _sessionService;
+    private readonly IViewerRepository _viewerRepository;
+    public SteamSessionAuthenticationHandler(IOptionsMonitor<SteamAuthenticationHandlerOptions> options, ILoggerFactory logger, UrlEncoder encoder, SteamSessionService sessionService, IViewerRepository viewerRepository) : base(options, logger, encoder)
     {
+        _sessionService = sessionService;
+        _viewerRepository = viewerRepository;
     }
 
     protected async override Task<AuthenticateResult> HandleAuthenticateAsync()
     {
-        return AuthenticateResult.Fail("Not implemented");
+        byte[] requestBytes;
+        using (var requestBytesStream = new MemoryStream())
+        {
+            await Request.Body.CopyToAsync(requestBytesStream);
+            requestBytes = requestBytesStream.ToArray();
+        }
+
+        // Convert bytes to json
+        string requestString = Encoding.UTF8.GetString(requestBytes);
+        BaseRequest? requestJson = JsonConvert.DeserializeObject<BaseRequest>(requestString);
+        
+        // Reset request stream
+        Request.Body.Seek(0, SeekOrigin.Begin);
+
+        if (requestJson is null)
+        {
+            return AuthenticateResult.Fail("Invalid request body.");
+        }
+        
+        // Check steam session validity
+        bool sessionIsValid = _sessionService.IsTicketValidForUser(requestJson.SteamSessionTicket, requestJson.SteamId);
+        if (!sessionIsValid)
+        {
+            return AuthenticateResult.Fail("Invalid ticket.");
+        }
+
+        Viewer? viewer =
+            await _viewerRepository.GetViewerBySocialConnection(SocialAccountType.Steam, requestJson.SteamId);
+
+        if (viewer is null)
+        {
+            return AuthenticateResult.Fail("User not found.");
+        }
+
+        // Build identity
+        ClaimsIdentity identity = new ClaimsIdentity();
+        identity.AddClaim(new Claim(ClaimTypes.Name, viewer.DisplayName));
+        identity.AddClaim(new Claim(ShadowverseClaimTypes.ShortUdidClaim, viewer.ShortUdid.ToString()));
+        identity.AddClaim(new Claim(ShadowverseClaimTypes.ViewerIdClaim, viewer.Id.ToString()));
+        identity.AddClaim(new Claim(SteamAuthenticationConstants.SteamIdClaim, requestJson.SteamId.ToString()));
+        
+        // Build and return final ticket
+        AuthenticationTicket ticket =
+            new AuthenticationTicket(new ClaimsPrincipal(), SteamAuthenticationConstants.SchemeName);
+        return AuthenticateResult.Success(ticket);
     }
 }