first commit

Author: z2911

Controllers/FileController.cs

@@ -0,0 +1,162 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using SecureFileSharingApp.Helpers;
+using SecureFileSharingApp.Models;
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using SecureFileSharingApp.Services;
+using Microsoft.AspNetCore.Hosting;
+using System.Net.Sockets;
+using System.Net;
+
+
+namespace SecureFileSharingApp.Controllers
+{
+    [ApiController]
+    [Route("api/[controller]")]
+    public class FileController : ControllerBase
+    {
+        private readonly ILogger<FileController> _logger;
+        private readonly IWebHostEnvironment _env;
+        private readonly IConfiguration _configuration;
+        private readonly MailService _mailService;  // Inject MailService
+        private static readonly string[] allowedExtensions = { ".pdf", ".docx", ".xlsx", ".csv", ".txt" };
+
+        public FileController(ILogger<FileController> logger,
+                              IWebHostEnvironment env,
+                              IConfiguration configuration,
+                              MailService mailService)  // Add MailService to constructor
+        {
+            _logger = logger;
+            _env = env;
+            _configuration = configuration;
+            _mailService = mailService;  // Assign MailService instance
+        }
+
+        [HttpPost("upload")]
+        public async Task<IActionResult> UploadFile([FromForm] FileUploadRequest request, [FromForm] string folder = "default")
+        {
+            var file = request.File;
+
+            if (file == null || file.Length == 0)
+                return BadRequest("No file selected.");
+
+            var extension = Path.GetExtension(file.FileName).ToLowerInvariant();
+            if (!allowedExtensions.Contains(extension))
+                return BadRequest("Unsupported file type.");
+
+            var rootPath = Path.Combine(_env.ContentRootPath, "EncryptedFiles", folder);
+            Directory.CreateDirectory(rootPath);
+
+            // File versioning
+            string fileName = Path.GetFileNameWithoutExtension(file.FileName);
+            string ext = Path.GetExtension(file.FileName);
+            string fullPath = Path.Combine(rootPath, file.FileName);
+            int version = 1;
+
+            while (System.IO.File.Exists(fullPath))
+            {
+                fullPath = Path.Combine(rootPath, $"{fileName}_v{version}{ext}");
+                version++;
+            }
+
+            try
+            {
+                using (var stream = file.OpenReadStream())
+                {
+                    await FileEncryptionHelper.EncryptAndSaveFileAsync(stream, fullPath);
+                }
+
+                // Antivirus scan (if needed)
+                //var isClean = await ScanWithClamAV(fullPath);
+                //if (!isClean)
+                //{
+                //    System.IO.File.Delete(fullPath);
+                //    return BadRequest("File contains a virus.");
+                //}
+
+                // Use MailService to send email
+                //await _mailService.SendEmailAsync("File Uploaded",
+                                                  //$"File '{Path.GetFileName(fullPath)}' was uploaded to folder '{folder}'.");
+
+                _logger.LogInformation("File uploaded: {FileName}", file.FileName);
+                return Ok("File uploaded, encrypted, and scanned successfully.");
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Upload failed for file: {FileName}", file.FileName);
+                return StatusCode(500, "File upload failed.");
+            }
+        }
+
+        [HttpGet("download")]
+        public async Task<IActionResult> DownloadFile([FromQuery] string fileName, [FromQuery] string folder = "default")
+        {
+            string filePath = Path.Combine(_env.ContentRootPath, "EncryptedFiles", folder, fileName);
+
+            if (!System.IO.File.Exists(filePath))
+            {
+                _logger.LogWarning("File not found: {FileName}", fileName);
+                return NotFound("File not found.");
+            }
+
+            try
+            {
+                var memoryStream = new MemoryStream();
+                await FileEncryptionHelper.DecryptFileAsync(filePath, memoryStream);
+                memoryStream.Position = 0;
+
+                // Use MailService to send email on download
+                //await _mailService.SendEmailAsync("File Downloaded",
+                //                                  $"File '{fileName}' was downloaded from folder '{folder}'.");
+
+                _logger.LogInformation("File downloaded: {FileName}", fileName);
+                return File(memoryStream, "application/octet-stream", fileName);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Download failed for file: {FileName}", fileName);
+                return StatusCode(500, "File download failed.");
+            }
+        }
+
+        // Optional antivirus scan (if needed)
+        private async Task<bool> ScanWithClamAV(string filePath)
+        {
+            try
+            {
+                using (var client = new TcpClient("localhost", 3310))
+                using (var stream = client.GetStream())
+                {
+                    var writer = new StreamWriter(stream);
+                    var reader = new StreamReader(stream);
+                    writer.AutoFlush = true;
+
+                    await writer.WriteLineAsync("zINSTREAM");
+
+                    using var fileStream = System.IO.File.OpenRead(filePath);
+                    var buffer = new byte[2048];
+                    int bytesRead;
+
+                    while ((bytesRead = fileStream.Read(buffer, 0, buffer.Length)) > 0)
+                    {
+                        var size = BitConverter.GetBytes(IPAddress.HostToNetworkOrder(bytesRead));
+                        await stream.WriteAsync(size);
+                        await stream.WriteAsync(buffer, 0, bytesRead);
+                    }
+
+                    await stream.WriteAsync(BitConverter.GetBytes(0));
+                    var response = await reader.ReadLineAsync();
+
+                    return response != null && response.Contains("OK");
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "ClamAV scan error.");
+                return false;
+            }
+        }
+    }
+}

EncryptedFiles/default/new.txt

@@ -0,0 +1 @@
+�)�/W���:}�\�

Helpers/AESHelper.cs

@@ -0,0 +1,13 @@
+using System.Security.Cryptography;
+
+public static class AESHelper
+{
+    public static (byte[] Key, byte[] IV) GenerateAESKeyAndIV()
+    {
+        using var aes = Aes.Create();
+        aes.KeySize = 256;  // AES-256
+        aes.GenerateKey();
+        aes.GenerateIV();
+        return (aes.Key, aes.IV);
+    }
+}

Helpers/FileEncryptionHelper.cs

@@ -0,0 +1,45 @@
+using System.Security.Cryptography;
+using System.Text;
+
+namespace SecureFileSharingApp.Helpers
+{
+    public static class FileEncryptionHelper
+    {
+        // AES-256 key (32 bytes) and IV (16 bytes)
+        private static readonly byte[] Key = Encoding.UTF8.GetBytes("12345678901234567890123456789012"); // 32 chars
+        private static readonly byte[] IV = Encoding.UTF8.GetBytes("1234567890123456"); // 16 chars
+
+        public static string GetSecureUploadPath(string fileName)
+        {
+            string folder = Path.Combine(Directory.GetCurrentDirectory(), "UploadedFiles");
+            if (!Directory.Exists(folder))
+                Directory.CreateDirectory(folder);
+            return Path.Combine(folder, fileName);
+        }
+        public static async Task EncryptAndSaveFileAsync(Stream inputStream, string outputPath)
+        {
+            using var aes = Aes.Create();
+            aes.Key = Key;
+            aes.IV = IV;
+
+            using var fileStream = new FileStream(outputPath, FileMode.Create);
+            using var cryptoStream = new CryptoStream(fileStream, aes.CreateEncryptor(), CryptoStreamMode.Write);
+
+            inputStream.Position = 0;
+            await inputStream.CopyToAsync(cryptoStream);
+            await cryptoStream.FlushAsync();
+        }
+
+        public static async Task DecryptFileAsync(string encryptedFilePath, Stream outputStream)
+        {
+            using var aes = Aes.Create();
+            aes.Key = Key;
+            aes.IV = IV;
+
+            using var fileStream = new FileStream(encryptedFilePath, FileMode.Open);
+            using var cryptoStream = new CryptoStream(fileStream, aes.CreateDecryptor(), CryptoStreamMode.Read);
+
+            await cryptoStream.CopyToAsync(outputStream);
+        }
+    }
+}

JWT/key.txt

@@ -0,0 +1 @@
+Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IlRlc3QgVXNlciIsImlhdCI6MTcxMzU5MzYwMCwiZXhwIjoxOTIwMDAwMDAwLCJpc3MiOiJ5b3VyZG9tYWluLmNvbSIsImF1ZCI6InlvdXJkb21haW4uY29tIn0.bSGu4PtN3aObB9lAydI3LKrN4MCHHZdOBlX_3bISJYA

JWT/new.txt

@@ -0,0 +1 @@
+123456789

Models/FileUploadModel.cs

@@ -0,0 +1,7 @@
+namespace SecureFileSharingApp.Models
+{
+    public class FileUploadModel
+    {
+        public IFormFile File { get; set; }
+    }
+}

Models/FileUploadRequest.cs

@@ -0,0 +1,10 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace SecureFileSharingApp.Models
+{
+    public class FileUploadRequest
+    {
+        [Required]
+        public IFormFile File { get; set; }
+    }
+}

Program.cs

@@ -0,0 +1,83 @@
+using Microsoft.AspNetCore.Authentication.JwtBearer;
+using Microsoft.IdentityModel.Tokens;
+using Microsoft.OpenApi.Models;
+using SecureFileSharingApp.Swagger;
+using System.Text;
+using SecureFileSharingApp.Services;
+
+var builder = WebApplication.CreateBuilder(args);
+
+// Add services
+builder.Services.AddControllers();
+builder.Services.AddEndpointsApiExplorer();
+builder.Services.AddScoped<MailService>();
+
+builder.Services.AddSwaggerGen(c =>
+{
+    c.SwaggerDoc("v1", new OpenApiInfo
+    {
+        Title = "Secure File Sharing API",
+        Version = "v1"
+    });
+
+
+    c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
+    {
+        Name = "Authorization",
+        Type = SecuritySchemeType.ApiKey,
+        Scheme = "Bearer",
+        BearerFormat = "JWT",
+        In = ParameterLocation.Header,
+        Description = "Enter JWT token"
+    });
+
+    c.AddSecurityRequirement(new OpenApiSecurityRequirement {
+        {
+            new OpenApiSecurityScheme {
+                Reference = new OpenApiReference {
+                    Type = ReferenceType.SecurityScheme,
+                    Id = "Bearer"
+                }
+            },
+            Array.Empty<string>()
+        }
+    });
+
+    
+    c.OperationFilter<FileUploadOperationFilter>();
+});
+
+// JWT Authentication
+builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
+    .AddJwtBearer(options =>
+    {
+        options.TokenValidationParameters = new TokenValidationParameters
+        {
+            ValidateIssuer = true,
+            ValidateAudience = true,
+            ValidateLifetime = true,
+            ValidateIssuerSigningKey = true,
+            ValidIssuer = "yourdomain.com",
+            ValidAudience = "yourdomain.com",
+            IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("ThisIsASuperSecretJWTKey123!"))
+        };
+    });
+
+builder.Services.AddAuthorization();
+
+var app = builder.Build();
+
+// Middleware
+if (app.Environment.IsDevelopment())
+{
+    app.UseDeveloperExceptionPage();
+    app.UseSwagger();
+    app.UseSwaggerUI();
+}
+
+app.UseHttpsRedirection();
+app.UseAuthentication();
+app.UseAuthorization();
+
+app.MapControllers();
+app.Run();

Properties/launchSettings.json

@@ -0,0 +1,41 @@
+{
+  "$schema": "http://json.schemastore.org/launchsettings.json",
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:62395",
+      "sslPort": 44346
+    }
+  },
+  "profiles": {
+    "http": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "applicationUrl": "http://localhost:5199",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "https": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "applicationUrl": "https://localhost:7014;http://localhost:5199",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}