BackendSpoofingDetected/UbloxSC20/Controllers/NavigationModelsController.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Http.HttpResults;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using NuGet.Packaging.Signing;
using UbloxSC20.Data;
using UbloxSC20.Model;
using UbloxSC20.UBXDecoder;
using Serilog;
using System.CodeDom;
using System.Security.Cryptography;
using System.Text;
using System.Security.Cryptography.Xml;

namespace UbloxSC20.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class NavigationModelsController : ControllerBase
    {
        private readonly UbloxSC20Context _context;
        string privateKey = "MIIEowIBAAKCAQEAuqvwyKfMPcEkSElMM59pBNFLJLIAqJYWdHe6w7oaHf9sPNTQ3g+/E9dUuZH8TWqimPr5Wq/2pD" +
            "mD8D4wnXeNe09ldsPFxGMrLxdHEscin56+SAVoX1O0bumSUIKiODHLTNkxAIibZkUbPSJZDySRLAoQ+21e9JL6/ocRMN21W37CF/HVPBB5JPLIO" +
            "go2zqg3VX9DUIKQG72Wh8b6TGMwDE4FIQQXcsTA1UuCVEC41B0FQnygA6IdK11TTart5WMFRhWufcI/yZL7MF+/4myob5m5ESa4oQWHT7twHOjpf" +
            "o7uJRF9PaB7lRMWQH5sEnQqBdjNUicFpTPR0D7XxKmLDQIDAQABAoIBAFAKi8suD+hm2azZKQB1mO1E5MiOPrQK7wPvlrh4Ity7+eg3hHvDGrZiPW" +
            "T4kMuNLr0T2Dmne8U9GDK6J9RNP/Agwivjk/g6YXjmrUYC9vikc4ikMPW3CYYJRwCYkwAvcbG460cETEXU2fIjuTZCArF0e4WjhvSt1UuwFJH0buA" +
            "UxKdrvenpLh054UaPhR4NzpElggqtq0Xpi5Yp80+M7iMcLh1JzuOdouLFd0B92HhvC0aAAIPi7ikvfLDpJPn6hhaXFtkmsaBqwUiSSiuoShNKelAP2" +
            "+a9ATXFqUqVAYRsKFePyTvVHs7yGzxi+BfiuhIEgiT6IGmXplOYgN7PSw0CgYEAxVsLJ62qKLmYO3c9+Y32dso1ih39hoSWEDIxnetjaB/dEPq/j4k" +
            "XKqefMb2WGZXXtfcDd7FWXsLvnDEQy+sjr5rYp4BCIIjAnEn6Qi3a8rD1bszmuJIL9BEpIwtBJYyFTMB1n88axJd5YpWKrl3Yw/fqzHO6d0G7MQu4qQ" +
            "wn7B8CgYEA8iQoxuvwtDA2L/G7/8OdYrh9uLjQEV12Yqvb/IAwiAjqivO8Obxu3BgK8wB/FfGmpxeNiVNikFsYQWqDI98MrGB2QJcuYU8MUCE0kpz/V" +
            "5HCyO1UeIFjYQ86Xuwek7tAyNUuDhB6AwD7Ia9JXuGAsplTWcJ/21M1lEQ6yK+YY1MCgYBg/vgijjX9QgpR3680AdPKWmOp+EdsX6mpWCIOrWvz9wUd" +
            "nT+c+hHKwwt41Ob6uCyGoFqx7xS2CjTdnTfWIUEuw3oMCPt3Jf8UUT+QWx0q/lICHO6gdBcv42dGc/eWztOM/2JQIufTC2d7TmgUfsdUuXpK9e4FQuc" +
            "PmeUuIG1WnQKBgA2gS0sma903+VSpXdL+xxSPHUQP4mWXxNm4oiCLdi+xkMFRBf6ZxANOtw8FsCEkACTXBnf74UgOWEcWH1sdajEpHH52A34mXKMFu1" +
            "ekzhm3ciasdFxzq4wCt14wG2hk2Th0Bqtz8enJXFiA7LgSKJPkXPRoJZnKDPHTBRvWBdVRAoGBAJd7evuesoSfjHQP84lqZvIz6vx2BSaxVp5fzrd8gB" +
            "bTfMTaVND8XPEiijePx2qvdByIhEAUwzSCWJVuTf1L5c1WZVN35la+lS8VbJdFXs5vh7e3YSXxzAnD9WbLXZYzffScysw4s/3FA4qgHTHKfZKp87fbXQXxyt65iyrun4gF";

        string publicKey = "MIIBCgKCAQEAuqvwyKfMPcEkSElMM59pBNFLJLIAqJYWdHe6w7oaHf9sPNTQ3g+/E9dUuZH8TWqimPr5Wq/2pDmD8D4wnXeNe0" +
            "9ldsPFxGMrLxdHEscin56+SAVoX1O0bumSUIKiODHLTNkxAIibZkUbPSJZDySRLAoQ+21e9JL6/ocRMN21W37CF/HVPBB5JPLIOgo2zqg3VX9DUIKQG72Wh8b" +
            "6TGMwDE4FIQQXcsTA1UuCVEC41B0FQnygA6IdK11TTart5WMFRhWufcI/yZL7MF+/4myob5m5ESa4oQWHT7twHOjpfo7uJRF9PaB7lRMWQH5sEnQqBdjNUicF" +
            "pTPR0D7XxKmLDQIDAQAB";
     
        public NavigationModelsController(UbloxSC20Context context)
        {
            _context = context;
        }

        private string SignData(string data, string privateKey)
        {
            byte[] privateKeyBytes = Convert.FromBase64String(privateKey);
            using (var rsa = new RSACryptoServiceProvider())
            {
                rsa.ImportRSAPrivateKey(privateKeyBytes, out _);
                byte[] dataBytes = Encoding.UTF8.GetBytes(data);
                byte[] signedBytes = rsa.SignData(dataBytes, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
                return Convert.ToBase64String(signedBytes); 
            }
        }

        [HttpGet]
        public async Task<ActionResult<IEnumerable<NavigationModel>>> GetNavigationModel()
        {
            return await _context.NavigationModel.ToListAsync();
        }
        // GET: api/NavigationModels/5
        [HttpGet("{svId}/{week}/{tow}")]
        public async Task<ActionResult<NavigationModel>> GetNavigationMessage(int svId, int week, int tow)
        {
            var navigationModel = await _context.NavigationModel
                .FirstOrDefaultAsync(n => n.SvId == svId );


            if (navigationModel == null)
            {
                return NotFound();
            }

            return navigationModel;
        }

      

        // PUT: api/NavigationModels/5
        // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
        [HttpPut("{id}")]
        public async Task<IActionResult> PutNavigationModel(int id, NavigationModel navigationModel)
        {
            if (id != navigationModel.Id)
            {
                return BadRequest();
            }

            _context.Entry(navigationModel).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!NavigationModelExists(id))
                {
                    return NotFound();
                }
                else
                {
                    throw;
                }
            }

            return NoContent();
        }

        // POST: api/NavigationModels
        // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
        [HttpPost]
        public async Task<ActionResult<NavigationModel>> PostNavigationModel(NavigationModel navigationModel)
        {
            
            _context.NavigationModel.Add(navigationModel);
            await _context.SaveChangesAsync();

            return CreatedAtAction("GetNavigationModel", new { id = navigationModel.Id }, navigationModel);
        }

        [HttpPost("check")]
        public async Task<ActionResult<NavigationModel>> PostCheckNavigationModel([FromBody] String navigaionHexString)
        {
            byte[] ubxSfrbxPacket = UbxDecoder.HexStringToByteArray(navigaionHexString);

            //Parsed data
            UbxDecoder decoder = new UbxDecoder();
            UbxDecoder.UbxSfrbxResult result = decoder.DecodeUbxSfrbx(ubxSfrbxPacket);
            if(result == null)
            {
                string notification = "Not Found HexString";
                string signatureDecoder = SignData(notification, privateKey);

                return Ok(new
                {
                    Message = notification,
                    Signature = signatureDecoder
                });
            }

            //Create Timestamp
            DateTimeOffset serverDateTime = DateTimeOffset.UtcNow;
            double timestamp = serverDateTime.ToUnixTimeSeconds();

            byte[] payloadBytes = new byte[result.LastPayload.Length * sizeof(uint)];
            Buffer.BlockCopy(result.LastPayload, 0, payloadBytes, 0, payloadBytes.Length);

            //NavigationMessage
            string navMessage;
            navMessage = BitConverter.ToString(payloadBytes).Replace("-", "");

            string responseMessage = "";

            try
            {
                var navigationModelCheck = await _context.NavigationModel
                   .FirstOrDefaultAsync(n => n.SvId == result.SvId && n.SigId == result.SigId && n.GnssId == result.GnssId && n.FreqId == result.FreqId);

                if (navigationModelCheck == null)
                {
                    responseMessage = $"{navMessage}-{result.GnssId}-NotFoundGNSSSystem";
                }
                else
                {
                    var navigationModelCheckNavMess = await _context.NavigationModel.FirstOrDefaultAsync(n => n.NavigationMessage.Equals(navMessage));
                    if (navigationModelCheckNavMess == null)
                    {
                        responseMessage = $"{navMessage}-{result.GnssId}-NotFound";
                    }
                    else
                    {
                        double timeStampCheck = 0;
                        try
                        {
                            timeStampCheck = Convert.ToDouble(navigationModelCheck.Timestamp);
                        }
                        catch (Exception ex)
                        {
                            Log.Information(ex.ToString());
                        }
                        if (Math.Abs(timestamp - timeStampCheck) <= 20)
                        {
                            Console.WriteLine(timeStampCheck);
                            responseMessage = $"{navMessage}-{result.GnssId}-Ok";
                        }
                        else
                        {
                            responseMessage = $"{navMessage}-{result.GnssId}-Ok-LimitedTime-{Math.Abs(timestamp - timeStampCheck)}s";
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Information(ex.ToString());
            }

            string signature = SignData(responseMessage, privateKey);

            return Ok(new
            {
                Message = responseMessage,
                Signature = signature
            });
        }

        // DELETE: api/NavigationModels/5
        [HttpDelete("{id}")]
        public async Task<IActionResult> DeleteNavigationModel(int id)
        {
            var navigationModel = await _context.NavigationModel.FindAsync(id);
            if (navigationModel == null)
            {
                return NotFound();
            }

            _context.NavigationModel.Remove(navigationModel);
            await _context.SaveChangesAsync();

            return NoContent();
        }

        private bool NavigationModelExists(int id)
        {
            return _context.NavigationModel.Any(e => e.Id == id);
        }
    }
}