Added readme file.

- Bumped version to 1.5.
- Copying only the jar file now.
- No longer creating temp directory for downloading files. Fixed that in this version 0.0.2 of backend.
- Changed port to 8080.
- Updated CMD accn to new jar file.

.gitignore

@@ -1,3 +1,5 @@
+src/main/resources/application.properties.bak
+wiki/
 HELP.md
 target/
 !.mvn/wrapper/maven-wrapper.jar

Dockerfile

@@ -5,7 +5,7 @@ FROM debian:12-slim
 
 # Metadata
 LABEL maintainer="kshitijka"
-LABEL version=1.0
+LABEL version=1.5
 LABEL description="Skycrate is a web based file management system that uses Hadoop as filesystem."
 
 # Update & upgrade & install & rm
@@ -19,16 +19,13 @@ RUN useradd -s /bin/bash skycrateBack
 # Create work dir
 RUN mkdir /app
 RUN chown -R skycrateBack:skycrateBack /app
-COPY ./target/ /app
+COPY ./target/skycrateBackend-0.0.2.jar /app
 WORKDIR /app
 
-# Create temp download directory
-RUN mkdir -p /Skycrate/downloaded/
-RUN chown -R skycrateBack:skycrateBack /Skycrate /Skycrate/downloaded/
-
 # Switch user
 USER skycrateBack
 
-EXPOSE 8081
+# Expose port for backend
+EXPOSE 8080
 
-CMD ["java", "-jar", "/app/skycrateBackend-0.0.1-SNAPSHOT.jar"]
+CMD ["java", "-jar", "skycrateBackend-0.0.2.jar"]

README.md

@@ -0,0 +1,7 @@
+# Skycrate-Backend
+
+---
+
+This repository holds code for [Skycrate](https://git.kska.io/notkshitij/Skycrate) backend.
+
+---

pom.xml

@@ -13,7 +13,7 @@
 
     <groupId>com.skycrate.backend</groupId>
     <artifactId>skycrateBackend</artifactId>
-    <version>0.0.1-SNAPSHOT</version>
+    <version>0.0.2</version>
     <name>skycrateBackend</name>
     <description>Cloud Storage App using HDFS</description>
 
@@ -121,6 +121,17 @@
             <artifactId>spring-boot-starter-test</artifactId>
             <scope>test</scope>
         </dependency>
+
+        <!-- Caching -->
+        <dependency>
+            <groupId>com.github.ben-manes.caffeine</groupId>
+            <artifactId>caffeine</artifactId>
+            <version>3.0.5</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-cache</artifactId>
+        </dependency>
     </dependencies>
 
     <build>

src/main/java/com/skycrate/backend/skycrateBackend/config/CacheConfig.java

@@ -0,0 +1,24 @@
+package com.skycrate.backend.skycrateBackend.config;
+
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import com.github.benmanes.caffeine.cache.Caffeine;
+import org.springframework.cache.caffeine.CaffeineCacheManager;
+
+import java.util.concurrent.TimeUnit;
+
+@Configuration
+@EnableCaching
+public class CacheConfig {
+
+    @Bean
+    public CaffeineCacheManager cacheManager() {
+        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
+        cacheManager.setCaffeine(Caffeine.newBuilder()
+                .expireAfterWrite(30, TimeUnit.MINUTES) // Cache expiry time
+                .maximumSize(100)); // Maximum cache size
+        return cacheManager;
+    }
+}
+

src/main/java/com/skycrate/backend/skycrateBackend/config/SecurityConfig.java

@@ -29,7 +29,7 @@ public class SecurityConfig {
                 .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
                 .authenticationProvider(authenticationProvider)
                 .authorizeHttpRequests(auth -> auth
-                        .requestMatchers("/api/auth/login", "/api/auth/register", "/actuator/**").permitAll()
+                        .requestMatchers("/api/auth/logout","/api/auth/login", "/api/auth/register", "/actuator/**").permitAll()
                         .requestMatchers(HttpMethod.GET, "/public/**").permitAll()
                         .anyRequest().authenticated()
                 )

src/main/java/com/skycrate/backend/skycrateBackend/controller/AuthController.java

@@ -9,11 +9,10 @@ import com.skycrate.backend.skycrateBackend.entity.RefreshToken;
 import com.skycrate.backend.skycrateBackend.entity.User;
 import com.skycrate.backend.skycrateBackend.repository.UserRepository;
 import com.skycrate.backend.skycrateBackend.security.TokenBlacklistService;
-import com.skycrate.backend.skycrateBackend.services.AuthenticationService;
-import com.skycrate.backend.skycrateBackend.services.JwtService;
-import com.skycrate.backend.skycrateBackend.services.RateLimiterService;
-import com.skycrate.backend.skycrateBackend.services.RefreshTokenService;
+import com.skycrate.backend.skycrateBackend.services.*;
 import jakarta.servlet.http.HttpServletRequest;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.http.ResponseEntity;
 import org.springframework.security.authentication.AuthenticationManager;
 import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
@@ -23,6 +22,7 @@ import org.springframework.web.bind.annotation.*;
 @RequestMapping("/api/auth")
 public class AuthController {
 
+    private static final Logger log = LoggerFactory.getLogger(FileService.class);
     private final AuthenticationManager authManager;
     private final JwtService jwtService;
     private final UserRepository userRepository;
@@ -92,29 +92,43 @@ public class AuthController {
         }
 
         String token = authHeader.substring(7);
+        String username = jwtService.extractUsername(token);
+
+        userRepository.findByUsername(username).ifPresent(user -> {
+            // Clear the cached decrypted private key for the user
+            authenticationService.clearDecryptedPrivateKeyCache(user.getId().toString());
+
+            // Delete the refresh token associated with the user
+            refreshTokenService.logout(user); // This should delete the token
+        });
 
         tokenBlacklistService.blacklistToken(token);
 
-        String email = jwtService.extractUsername(token);
-        userRepository.findByEmail(email).ifPresent(refreshTokenService::deleteByUser);
-
         return ResponseEntity.ok("Logged out successfully");
     }
 
     @PostMapping("/refresh")
     public ResponseEntity<?> refresh(@RequestBody TokenRefreshRequest request) {
         String requestToken = request.getRefreshToken();
+        log.error("Received refresh token: " + requestToken);
 
         return refreshTokenService.findByToken(requestToken)
                 .map(token -> {
                     if (refreshTokenService.isExpired(token)) {
+                        log.error("Refresh token expired for user: " + token.getUser().getUsername());
+                        // Clear the cached key on token expiry
+                        authenticationService.clearDecryptedPrivateKeyCache(token.getUser().getId().toString());
                         return ResponseEntity.status(403).body("Refresh token expired");
                     }
 
                     User user = token.getUser();
                     String newAccessToken = jwtService.generateToken(user);
+                    log.info("Generated new access token for user: " + user.getUsername());
                     return ResponseEntity.ok(new TokenRefreshResponse(newAccessToken, requestToken));
                 })
-                .orElseGet(() -> ResponseEntity.status(403).body("Invalid refresh token"));
+                .orElseGet(() -> {
+                    log.error("Invalid refresh token: " + requestToken);
+                    return ResponseEntity.status(403).body("Invalid refresh token");
+                });
     }
 }

src/main/java/com/skycrate/backend/skycrateBackend/controller/FileController.java

@@ -1,5 +1,6 @@
 package com.skycrate.backend.skycrateBackend.controller;
 
+import com.skycrate.backend.skycrateBackend.dto.FileDownloadRequest;
 import com.skycrate.backend.skycrateBackend.services.FileService;
 import com.skycrate.backend.skycrateBackend.services.JwtService;
 import jakarta.servlet.http.HttpServletRequest;
@@ -39,20 +40,20 @@ public class FileController {
         }
     }
 
-    @GetMapping("/download/{filename}")
+    @GetMapping("/download")
     public ResponseEntity<?> downloadFile(
-            @PathVariable String filename,
-            @RequestParam("password") String password,
+            @RequestBody FileDownloadRequest fileDownloadRequest,
             HttpServletRequest request
     ) {
         try {
             String token = extractToken(request);
             String username = jwtService.extractUsername(token);
 
-            byte[] decryptedData = fileService.downloadDecryptedFile(username, password, filename);
+            // Use the password and filename from the FileDownloadRequest DTO
+            byte[] decryptedData = fileService.downloadDecryptedFile(username, fileDownloadRequest.getPassword(), fileDownloadRequest.getFilename());
 
             return ResponseEntity.ok()
-                    .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + filename + "\"")
+                    .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + fileDownloadRequest.getFilename() + "\"")
                     .contentLength(decryptedData.length)
                     .contentType(MediaType.APPLICATION_OCTET_STREAM)
                     .body(decryptedData);

src/main/java/com/skycrate/backend/skycrateBackend/controller/HDFScontroller.java

@@ -62,71 +62,71 @@ public class HDFScontroller {
         }
     }
 
-    @PostMapping("/uploadFile")
-    public ResponseDTO uploadFile(
-            @RequestParam("file") MultipartFile file,
-            @RequestParam String hdfsPath,
-            @RequestParam String uploadedFileName,
-            @RequestParam String username) {
-        try {
-            // Retrieve the user from the database using the username
-            User user = userRepository.findByUsername(username).orElseThrow(() -> new RuntimeException("User not found"));
+//    @PostMapping("/uploadFile")
+//    public ResponseDTO uploadFile(
+//            @RequestParam("file") MultipartFile file,
+//            @RequestParam String hdfsPath,
+//            @RequestParam String uploadedFileName,
+//            @RequestParam String username) {
+//        try {
+//            // Retrieve the user from the database using the username
+//            User user = userRepository.findByUsername(username).orElseThrow(() -> new RuntimeException("User not found"));
+//
+//            // Get the public key from the user entity
+//            byte[] publicKeyBytes = user.getPublicKey();
+//            PublicKey publicKey = RSAKeyUtil.getPublicKeyFromBytes(publicKeyBytes);
+//
+//            // Encrypt the file content using the public key
+//            byte[] encryptedData = encryptFile(file, publicKey);
+//
+//            // Upload the encrypted file to HDFS
+//            hdfsOperations.uploadFile(encryptedData, hdfsPath, uploadedFileName, username);
+//
+//            return new ResponseDTO("File uploaded successfully", true);
+//        } catch (IOException e) {
+//            e.printStackTrace();
+//            return new ResponseDTO("Failed to upload file locally: " + e.getMessage(), false);
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//            return new ResponseDTO("Failed to upload file to HDFS: " + e.getMessage(), false);
+//        }
+//    }
+//
+//    // Helper method to encrypt the file content using RSA encryption
+//    private byte[] encryptFile(MultipartFile file, PublicKey publicKey) throws Exception {
+//        // Step 1: Generate a random AES key
+//        SecretKey aesKey = generateAESKey();
+//
+//        // Step 2: Encrypt the file data using AES
+//        Cipher aesCipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
+//        aesCipher.init(Cipher.ENCRYPT_MODE, aesKey);
+//        byte[] fileData = file.getBytes();
+//        byte[] encryptedData = aesCipher.doFinal(fileData);
+//
+//        // Step 3: Encrypt the AES key with RSA
+//        Cipher rsaCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
+//        rsaCipher.init(Cipher.ENCRYPT_MODE, publicKey);
+//        byte[] encryptedAesKey = rsaCipher.doFinal(aesKey.getEncoded());
+//
+//        // Step 4: Combine the encrypted AES key and the encrypted data
+//        byte[] combined = new byte[4 + encryptedAesKey.length + encryptedData.length];
+//        combined[0] = (byte) (encryptedAesKey.length >> 24);
+//        combined[1] = (byte) (encryptedAesKey.length >> 16);
+//        combined[2] = (byte) (encryptedAesKey.length >> 8);
+//        combined[3] = (byte) encryptedAesKey.length;
+//
+//        System.arraycopy(encryptedAesKey, 0, combined, 4, encryptedAesKey.length);
+//        System.arraycopy(encryptedData, 0, combined, 4 + encryptedAesKey.length, encryptedData.length);
+//
+//        return combined;
+//    }
 
-            // Get the public key from the user entity
-            byte[] publicKeyBytes = user.getPublicKey();
-            PublicKey publicKey = RSAKeyUtil.getPublicKeyFromBytes(publicKeyBytes);
-
-            // Encrypt the file content using the public key
-            byte[] encryptedData = encryptFile(file, publicKey);
-
-            // Upload the encrypted file to HDFS
-            hdfsOperations.uploadFile(encryptedData, hdfsPath, uploadedFileName, username);
-
-            return new ResponseDTO("File uploaded successfully", true);
-        } catch (IOException e) {
-            e.printStackTrace();
-            return new ResponseDTO("Failed to upload file locally: " + e.getMessage(), false);
-        } catch (Exception e) {
-            e.printStackTrace();
-            return new ResponseDTO("Failed to upload file to HDFS: " + e.getMessage(), false);
-        }
-    }
-
-    // Helper method to encrypt the file content using RSA encryption
-    private byte[] encryptFile(MultipartFile file, PublicKey publicKey) throws Exception {
-        // Step 1: Generate a random AES key
-        SecretKey aesKey = generateAESKey();
-
-        // Step 2: Encrypt the file data using AES
-        Cipher aesCipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
-        aesCipher.init(Cipher.ENCRYPT_MODE, aesKey);
-        byte[] fileData = file.getBytes();
-        byte[] encryptedData = aesCipher.doFinal(fileData);
-
-        // Step 3: Encrypt the AES key with RSA
-        Cipher rsaCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
-        rsaCipher.init(Cipher.ENCRYPT_MODE, publicKey);
-        byte[] encryptedAesKey = rsaCipher.doFinal(aesKey.getEncoded());
-
-        // Step 4: Combine the encrypted AES key and the encrypted data
-        byte[] combined = new byte[4 + encryptedAesKey.length + encryptedData.length];
-        combined[0] = (byte) (encryptedAesKey.length >> 24);
-        combined[1] = (byte) (encryptedAesKey.length >> 16);
-        combined[2] = (byte) (encryptedAesKey.length >> 8);
-        combined[3] = (byte) encryptedAesKey.length;
-
-        System.arraycopy(encryptedAesKey, 0, combined, 4, encryptedAesKey.length);
-        System.arraycopy(encryptedData, 0, combined, 4 + encryptedAesKey.length, encryptedData.length);
-
-        return combined;
-    }
-
-    // Generate a random AES key
-    private SecretKey generateAESKey() throws NoSuchAlgorithmException {
-        KeyGenerator keyGen = KeyGenerator.getInstance("AES");
-        keyGen.init(256); // Use 256 bits for AES
-        return keyGen.generateKey();
-    }
+//    // Generate a random AES key
+//    private SecretKey generateAESKey() throws NoSuchAlgorithmException {
+//        KeyGenerator keyGen = KeyGenerator.getInstance("AES");
+//        keyGen.init(256); // Use 256 bits for AES
+//        return keyGen.generateKey();
+//    }
 
     private String saveFileLocally(MultipartFile file) throws IOException {
         // Create a temporary directory if it doesn't exist
@@ -143,107 +143,107 @@ public class HDFScontroller {
         return path.toString(); // Return the local path for further processing
     }
 
-    @PostMapping("/downloadFile")
-    public ResponseEntity<Resource> downloadFile(
-            @RequestParam String hdfsEncPath,
-            @RequestParam String username) {
-        try {
-            // Extract the file name and extension
-            String encFileName = new File(hdfsEncPath).getName();
-            String originalFileName = encFileName.replace(".enc", "");
-            String fileExtension = originalFileName.substring(originalFileName.lastIndexOf(".") + 1);
-
-            // Define local decrypted file path
-            String localDecryptedPath = "/SkyCrate/downloaded/" + originalFileName;
-
-            // Define HDFS paths for encrypted file
-            String encFilePath = "/SkyCrate/downloaded/" + encFileName;
-
-            FileSystem fs = HDFSConfig.getHDFS();
-
-            // Download encrypted file from HDFS
-            fs.copyToLocalFile(new org.apache.hadoop.fs.Path(hdfsEncPath), new org.apache.hadoop.fs.Path(encFilePath));
-
-            // Retrieve the RSA private key for the user
-            User user = userRepository.findByUsername(username)
-                    .orElseThrow(() -> new RuntimeException("User not found"));
-            PrivateKey privateKey = RSAKeyUtil.getPrivateKeyFromBytes(user.getPrivateKey());
-
-            // Read the encrypted file content
-            byte[] encryptedFileContent = Files.readAllBytes(Paths.get(encFilePath));
-
-            // Step 1: Extract the AES key length from the combined data
-            int aesKeyLength = ((encryptedFileContent[0] & 0xFF) << 24) |
-                    ((encryptedFileContent[1] & 0xFF) << 16) |
-                    ((encryptedFileContent[2] & 0xFF) << 8) |
-                    (encryptedFileContent[3] & 0xFF);
-
-            // Step 2: Extract the encrypted AES key and encrypted data
-            byte[] encryptedAesKey = new byte[aesKeyLength];
-            byte[] encryptedData = new byte[encryptedFileContent.length - 4 - aesKeyLength];
-
-            System.arraycopy(encryptedFileContent, 4, encryptedAesKey, 0, aesKeyLength);
-            System.arraycopy(encryptedFileContent, 4 + aesKeyLength, encryptedData, 0, encryptedData.length);
-
-            // Step 3: Decrypt the AES key using RSA
-            Cipher rsaCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
-            rsaCipher.init(Cipher.DECRYPT_MODE, privateKey);
-            byte[] aesKeyBytes = rsaCipher.doFinal(encryptedAesKey);
-
-            // Create the AES key
-            SecretKey aesKey = new SecretKeySpec(aesKeyBytes, "AES");
-
-            // Step 4: Decrypt the data using AES
-            Cipher aesCipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
-            aesCipher.init(Cipher.DECRYPT_MODE, aesKey);
-
-            // Decrypt the file content using the provided decrypt method
-//            byte[] decryptedFileContent = RSAKeyUtil.decrypt(encryptedFileContent, privateKey);
-            byte[] decryptedFileContent = aesCipher.doFinal(encryptedData);
-
-            // Write the decrypted content to the original file
-            Files.write(Paths.get(localDecryptedPath + "." + fileExtension), decryptedFileContent);
-
-
-            // Log the file creation
-            if (Files.exists(Paths.get(localDecryptedPath + "." + fileExtension))) {
-                System.out.println("File created successfully at: " + localDecryptedPath + "." + fileExtension);
-            } else {
-                System.out.println("Failed to create file at: " + localDecryptedPath + "." + fileExtension);
-            }
-
-            // Create the decrypted file resource
-            File decryptedFile = new File(localDecryptedPath + "." + fileExtension);
-            Resource resource = new FileSystemResource(decryptedFile);
-
-            // Return the file as a response
-            return ResponseEntity.ok()
-                    .contentLength(decryptedFile.length())
-                    .contentType(MediaType.APPLICATION_OCTET_STREAM)
-                    .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + decryptedFile.getName() + "\"")
-                    .body(resource);
-
-        } catch (Exception e) {
-            e.printStackTrace();
-            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
-                    .body(null);
-        }
-    }
-
-
-    public void initializeKeysForUser(String username) {
-        try {
-            // Check if the public key file exists
-            Path publicKeyPath = Paths.get("C:\\Users\\sonal\\OneDrive\\Desktop\\SkyCrate\\Skycrate\\keys", username + "_public.key");
-            if (!Files.exists(publicKeyPath)) {
-                // Generate and store keys if they do not exist
-                KeyUtil.generateAndStoreKeyPair(username);
-            }
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-
+//    @PostMapping("/downloadFile")
+//    public ResponseEntity<Resource> downloadFile(
+//            @RequestParam String hdfsEncPath,
+//            @RequestParam String username) {
+//        try {
+//            // Extract the file name and extension
+//            String encFileName = new File(hdfsEncPath).getName();
+//            String originalFileName = encFileName.replace(".enc", "");
+//            String fileExtension = originalFileName.substring(originalFileName.lastIndexOf(".") + 1);
+//
+//            // Define local decrypted file path
+//            String localDecryptedPath = "/SkyCrate/downloaded/" + originalFileName;
+//
+//            // Define HDFS paths for encrypted file
+//            String encFilePath = "/SkyCrate/downloaded/" + encFileName;
+//
+//            FileSystem fs = HDFSConfig.getHDFS();
+//
+//            // Download encrypted file from HDFS
+//            fs.copyToLocalFile(new org.apache.hadoop.fs.Path(hdfsEncPath), new org.apache.hadoop.fs.Path(encFilePath));
+//
+//            // Retrieve the RSA private key for the user
+//            User user = userRepository.findByUsername(username)
+//                    .orElseThrow(() -> new RuntimeException("User not found"));
+//            PrivateKey privateKey = RSAKeyUtil.getPrivateKeyFromBytes(user.getPrivateKey());
+//
+//            // Read the encrypted file content
+//            byte[] encryptedFileContent = Files.readAllBytes(Paths.get(encFilePath));
+//
+//            // Step 1: Extract the AES key length from the combined data
+//            int aesKeyLength = ((encryptedFileContent[0] & 0xFF) << 24) |
+//                    ((encryptedFileContent[1] & 0xFF) << 16) |
+//                    ((encryptedFileContent[2] & 0xFF) << 8) |
+//                    (encryptedFileContent[3] & 0xFF);
+//
+//            // Step 2: Extract the encrypted AES key and encrypted data
+//            byte[] encryptedAesKey = new byte[aesKeyLength];
+//            byte[] encryptedData = new byte[encryptedFileContent.length - 4 - aesKeyLength];
+//
+//            System.arraycopy(encryptedFileContent, 4, encryptedAesKey, 0, aesKeyLength);
+//            System.arraycopy(encryptedFileContent, 4 + aesKeyLength, encryptedData, 0, encryptedData.length);
+//
+//            // Step 3: Decrypt the AES key using RSA
+//            Cipher rsaCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
+//            rsaCipher.init(Cipher.DECRYPT_MODE, privateKey);
+//            byte[] aesKeyBytes = rsaCipher.doFinal(encryptedAesKey);
+//
+//            // Create the AES key
+//            SecretKey aesKey = new SecretKeySpec(aesKeyBytes, "AES");
+//
+//            // Step 4: Decrypt the data using AES
+//            Cipher aesCipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
+//            aesCipher.init(Cipher.DECRYPT_MODE, aesKey);
+//
+//            // Decrypt the file content using the provided decrypt method
+////            byte[] decryptedFileContent = RSAKeyUtil.decrypt(encryptedFileContent, privateKey);
+//            byte[] decryptedFileContent = aesCipher.doFinal(encryptedData);
+//
+//            // Write the decrypted content to the original file
+//            Files.write(Paths.get(localDecryptedPath + "." + fileExtension), decryptedFileContent);
+//
+//
+//            // Log the file creation
+//            if (Files.exists(Paths.get(localDecryptedPath + "." + fileExtension))) {
+//                System.out.println("File created successfully at: " + localDecryptedPath + "." + fileExtension);
+//            } else {
+//                System.out.println("Failed to create file at: " + localDecryptedPath + "." + fileExtension);
+//            }
+//
+//            // Create the decrypted file resource
+//            File decryptedFile = new File(localDecryptedPath + "." + fileExtension);
+//            Resource resource = new FileSystemResource(decryptedFile);
+//
+//            // Return the file as a response
+//            return ResponseEntity.ok()
+//                    .contentLength(decryptedFile.length())
+//                    .contentType(MediaType.APPLICATION_OCTET_STREAM)
+//                    .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + decryptedFile.getName() + "\"")
+//                    .body(resource);
+//
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
+//                    .body(null);
+//        }
+//    }
+//
+//
+//    public void initializeKeysForUser(String username) {
+//        try {
+//            // Check if the public key file exists
+//            Path publicKeyPath = Paths.get("C:\\Users\\sonal\\OneDrive\\Desktop\\SkyCrate\\Skycrate\\keys", username + "_public.key");
+//            if (!Files.exists(publicKeyPath)) {
+//                // Generate and store keys if they do not exist
+//                KeyUtil.generateAndStoreKeyPair(username);
+//            }
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//        }
+//    }
+//
 
     @DeleteMapping("/deleteFile")
     public ResponseDTO deleteFile(@RequestParam String hdfsPath) {

src/main/java/com/skycrate/backend/skycrateBackend/dto/FileDownloadRequest.java

@@ -0,0 +1,23 @@
+package com.skycrate.backend.skycrateBackend.dto;
+
+public class FileDownloadRequest {
+    private String filename;
+    private String password;
+
+    // Getters and Setters
+    public String getFilename() {
+        return filename;
+    }
+
+    public void setFilename(String filename) {
+        this.filename = filename;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+}

src/main/java/com/skycrate/backend/skycrateBackend/repository/RefreshTokenRepository.java

@@ -15,4 +15,5 @@ public interface RefreshTokenRepository extends JpaRepository<RefreshToken, Long
     @Modifying
     @Query("DELETE FROM RefreshToken t WHERE t.user = :user")
     void deleteByUser(User user);
-}
+
+}

src/main/java/com/skycrate/backend/skycrateBackend/services/AuthenticationService.java

@@ -9,6 +9,8 @@ import com.skycrate.backend.skycrateBackend.utils.EncryptionUtil;
 import com.skycrate.backend.skycrateBackend.utils.RSAKeyUtil;
 import org.apache.hadoop.fs.FileSystem;
 import org.apache.hadoop.fs.Path;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Cacheable;
 import org.springframework.security.authentication.AuthenticationManager;
 import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
 import org.springframework.security.crypto.password.PasswordEncoder;
@@ -17,6 +19,8 @@ import org.springframework.stereotype.Service;
 import javax.crypto.SecretKey;
 import java.security.KeyPair;
 import java.security.NoSuchAlgorithmException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 @Service
 public class AuthenticationService {
@@ -24,13 +28,18 @@ public class AuthenticationService {
     private final UserRepository userRepository;
     private final PasswordEncoder passwordEncoder;
     private final AuthenticationManager authenticationManager;
+    private final KeyCacheService keyCacheService;
+
+    private static final Logger log = LoggerFactory.getLogger(AuthenticationService.class);
 
     public AuthenticationService(UserRepository userRepository,
                                  AuthenticationManager authenticationManager,
-                                 PasswordEncoder passwordEncoder) {
+                                 PasswordEncoder passwordEncoder,
+                                 KeyCacheService keyCacheService) {
         this.userRepository = userRepository;
         this.passwordEncoder = passwordEncoder;
         this.authenticationManager = authenticationManager;
+        this.keyCacheService = keyCacheService;
     }
 
     public User signUp(RegisterUserDto inputUser) {
@@ -90,4 +99,23 @@ public class AuthenticationService {
         return userRepository.findByEmail(inputUser.getEmail())
                 .orElseThrow(() -> new RuntimeException("User not found"));
     }
+
+    @Cacheable(value = "decryptedPrivateKeys", key = "#userId")
+    public byte[] getDecryptedPrivateKey(String userId, String password) throws Exception {
+        User user = userRepository.findById(Integer.valueOf(userId))
+                .orElseThrow(() -> new RuntimeException("User not found: " + userId));
+
+        log.info("Caching decrypted private key for userId: {}", userId);
+
+        SecretKey derivedKey = EncryptionUtil.deriveKey(password.toCharArray(), user.getPrivateKeySalt());
+        byte[] decryptedPrivateKeyBytes = EncryptionUtil.decrypt(user.getPrivateKey(), derivedKey, user.getPrivateKeyIv());
+        return decryptedPrivateKeyBytes;
+    }
+
+    @CacheEvict(value = "decryptedPrivateKeys", key = "#userId")
+    public void clearDecryptedPrivateKeyCache(String userId) {
+        // This method will clear the cached decrypted private key for the given userId
+        log.info("Clearing Caching decrypted private key for userId: {}", userId);
+        keyCacheService.clearKey(Long.valueOf(userId));
+    }
 }

src/main/java/com/skycrate/backend/skycrateBackend/services/FileService.java

@@ -13,7 +13,9 @@ import org.apache.hadoop.fs.FileSystem;
 import org.apache.hadoop.fs.Path;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 
 import javax.crypto.SecretKey;
 import java.io.ByteArrayInputStream;
@@ -24,15 +26,18 @@ import java.security.PublicKey;
 public class FileService {
 
     private static final Logger log = LoggerFactory.getLogger(FileService.class);
-
+    private final AuthenticationService authenticationService;
     private final FileMetadataRepository fileMetadataRepository;
     private final UserRepository userRepository;
 
-    public FileService(FileMetadataRepository fileMetadataRepository, UserRepository userRepository) {
+    @Autowired
+    public FileService(FileMetadataRepository fileMetadataRepository, UserRepository userRepository, AuthenticationService authenticationService) {
         this.fileMetadataRepository = fileMetadataRepository;
         this.userRepository = userRepository;
+        this.authenticationService = authenticationService;
     }
 
+    @Transactional
     public void uploadEncryptedFile(String username, byte[] fileContent, String filename) throws Exception {
         log.info("Starting upload for user={}, file={}", username, filename);
         try {
@@ -91,8 +96,8 @@ public class FileService {
             FileMetadata metadata = fileMetadataRepository.findByUsernameAndFilePath(username, filePath.toString())
                     .orElseThrow(() -> new RuntimeException("File metadata not found for: " + filePath));
 
-            SecretKey derivedKey = EncryptionUtil.deriveKey(password.toCharArray(), user.getPrivateKeySalt());
-            byte[] decryptedPrivateKeyBytes = EncryptionUtil.decrypt(user.getPrivateKey(), derivedKey, user.getPrivateKeyIv());
+            // Use the cached decrypted private key
+            byte[] decryptedPrivateKeyBytes = authenticationService.getDecryptedPrivateKey(String.valueOf(user.getId()), password);
             PrivateKey privateKey = RSAKeyUtil.decodePrivateKey(decryptedPrivateKeyBytes);
 
             byte[] aesKeyBytes = EncryptionUtil.decryptRSA(metadata.getEncryptedKey(), privateKey);

src/main/java/com/skycrate/backend/skycrateBackend/services/HDFSOperations.java

@@ -120,41 +120,41 @@ public class HDFSOperations {
 //        }
 //    }
 
-    public void uploadFile(byte[] fileData, String hdfsPath, String uploadedFileName, String username) {
-        try {
-            FileSystem fs = HDFSConfig.getHDFS();
-            ByteArrayInputStream inputStream = new ByteArrayInputStream(fileData);
-            String finalHdfsPath = hdfsPath.endsWith("/") ? hdfsPath + uploadedFileName : hdfsPath + "/" + uploadedFileName;
-            Path hdfsFilePath = new Path(finalHdfsPath);
-            try (FSDataOutputStream outputStream = fs.create(hdfsFilePath)) {
-                IOUtils.copyBytes(inputStream, outputStream, 4096, true);
-            }
-        } catch (IOException e) {
-            throw new RuntimeException("Failed to upload file to HDFS: " + e.getMessage(), e);
-        } catch (Exception e) {
-            throw new RuntimeException(e);
-        }
-    }
-
-    public void downloadFile(String hdfsEncPath, String localPathWithoutExt, String username) {
-        try {
-            FileSystem fs = HDFSConfig.getHDFS();
-            String encFilePath = localPathWithoutExt + ".enc";
-            fs.copyToLocalFile(new Path(hdfsEncPath), new Path(encFilePath));
-
-            User user = userRepository.findByUsername(username)
-                    .orElseThrow(() -> new RuntimeException("User not found"));
-            PrivateKey privateKey = RSAKeyUtil.getPrivateKeyFromBytes(user.getPrivateKey());
-
-            byte[] encryptedFileContent = Files.readAllBytes(Paths.get(encFilePath));
-            byte[] decryptedFileContent = RSAKeyUtil.decrypt(encryptedFileContent, privateKey);
-
-            Files.write(Paths.get(localPathWithoutExt), decryptedFileContent);
-            Files.deleteIfExists(Paths.get(encFilePath));
-        } catch (Exception e) {
-            throw new RuntimeException("Failed to download or decrypt file: " + e.getMessage(), e);
-        }
-    }
+//    public void uploadFile(byte[] fileData, String hdfsPath, String uploadedFileName, String username) {
+//        try {
+//            FileSystem fs = HDFSConfig.getHDFS();
+//            ByteArrayInputStream inputStream = new ByteArrayInputStream(fileData);
+//            String finalHdfsPath = hdfsPath.endsWith("/") ? hdfsPath + uploadedFileName : hdfsPath + "/" + uploadedFileName;
+//            Path hdfsFilePath = new Path(finalHdfsPath);
+//            try (FSDataOutputStream outputStream = fs.create(hdfsFilePath)) {
+//                IOUtils.copyBytes(inputStream, outputStream, 4096, true);
+//            }
+//        } catch (IOException e) {
+//            throw new RuntimeException("Failed to upload file to HDFS: " + e.getMessage(), e);
+//        } catch (Exception e) {
+//            throw new RuntimeException(e);
+//        }
+//    }
+//
+//    public void downloadFile(String hdfsEncPath, String localPathWithoutExt, String username) {
+//        try {
+//            FileSystem fs = HDFSConfig.getHDFS();
+//            String encFilePath = localPathWithoutExt + ".enc";
+//            fs.copyToLocalFile(new Path(hdfsEncPath), new Path(encFilePath));
+//
+//            User user = userRepository.findByUsername(username)
+//                    .orElseThrow(() -> new RuntimeException("User not found"));
+//            PrivateKey privateKey = RSAKeyUtil.getPrivateKeyFromBytes(user.getPrivateKey());
+//
+//            byte[] encryptedFileContent = Files.readAllBytes(Paths.get(encFilePath));
+//            byte[] decryptedFileContent = RSAKeyUtil.decrypt(encryptedFileContent, privateKey);
+//
+//            Files.write(Paths.get(localPathWithoutExt), decryptedFileContent);
+//            Files.deleteIfExists(Paths.get(encFilePath));
+//        } catch (Exception e) {
+//            throw new RuntimeException("Failed to download or decrypt file: " + e.getMessage(), e);
+//        }
+//    }
 
     public void createFolder(String hdfsPath) {
         try {

src/main/java/com/skycrate/backend/skycrateBackend/services/KeyCacheService.java

@@ -0,0 +1,28 @@
+package com.skycrate.backend.skycrateBackend.services;
+
+import org.springframework.stereotype.Service;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+@Service
+public class KeyCacheService {
+
+    private final ConcurrentHashMap<Long, String> keyCache = new ConcurrentHashMap<>();
+
+    public void cacheKey(Long userId, String decryptedKey) {
+        keyCache.put(userId, decryptedKey);
+    }
+
+    public String getKey(Long userId) {
+        return keyCache.get(userId);
+    }
+
+    public void clearKey(Long userId) {
+        keyCache.remove(userId);
+    }
+
+    public void clearAllKeys() {
+        keyCache.clear();
+    }
+}
+

src/main/java/com/skycrate/backend/skycrateBackend/services/RefreshTokenService.java

@@ -16,7 +16,7 @@ public class RefreshTokenService {
 
     private final RefreshTokenRepository refreshTokenRepo;
 
-    @Value("${security.jwt.refresh-expiry-ms:604800000}") // 7 days default
+    @Value("${security.jwt.refresh-expiry-ms:86400000}")  //1 day in milliseconds
     private Long refreshTokenDurationMs;
 
     public RefreshTokenService(RefreshTokenRepository refreshTokenRepo) {
@@ -35,6 +35,7 @@ public class RefreshTokenService {
         return refreshTokenRepo.save(token);
     }
 
+
     public Optional<RefreshToken> findByToken(String token) {
         return refreshTokenRepo.findByToken(token);
     }
@@ -45,6 +46,20 @@ public class RefreshTokenService {
 
     @Transactional
     public void deleteByUser(User user) {
-        refreshTokenRepo.deleteByUser(user);
+        try {
+            refreshTokenRepo.deleteByUser(user);
+            System.out.println("Successfully deleted refresh tokens for user: " + user.getId());
+        } catch (Exception e) {
+            System.err.println("Error deleting refresh tokens for user: " + user.getId() + " - " + e.getMessage());
+        }
+    }
+
+    @Transactional
+    public void logout(User user) {
+        deleteByUser(user); // This should call the repository method to delete the token
+    }
+
+    public Optional<RefreshToken> refreshAccessToken(String refreshToken) {
+        return findByToken(refreshToken).filter(token -> !isExpired(token));
     }
 }

src/main/java/com/skycrate/backend/skycrateBackend/utils/EncryptionUtil.java

@@ -80,15 +80,15 @@ public class EncryptionUtil {
         return cipher.doFinal(data);
     }
 
-    // --------- Encrypt/decrypt RSA private key using AES derived from password ---------
-
-    public static byte[] encryptPrivateKey(PrivateKey privateKey, String password, byte[] salt, byte[] iv) throws Exception {
-        SecretKey aesKey = deriveKey(password.toCharArray(), salt);
-        return encrypt(privateKey.getEncoded(), aesKey, iv);
-    }
-
-    public static byte[] decryptPrivateKey(byte[] encryptedPrivateKey, String password, byte[] salt, byte[] iv) throws Exception {
-        SecretKey aesKey = deriveKey(password.toCharArray(), salt);
-        return decrypt(encryptedPrivateKey, aesKey, iv);
-    }
+//    // --------- Encrypt/decrypt RSA private key using AES derived from password ---------
+//
+//    public static byte[] encryptPrivateKey(PrivateKey privateKey, String password, byte[] salt, byte[] iv) throws Exception {
+//        SecretKey aesKey = deriveKey(password.toCharArray(), salt);
+//        return encrypt(privateKey.getEncoded(), aesKey, iv);
+//    }
+//
+//    public static byte[] decryptPrivateKey(byte[] encryptedPrivateKey, String password, byte[] salt, byte[] iv) throws Exception {
+//        SecretKey aesKey = deriveKey(password.toCharArray(), salt);
+//        return decrypt(encryptedPrivateKey, aesKey, iv);
+//    }
 }

src/main/java/com/skycrate/backend/skycrateBackend/utils/KeyUtil.java

@@ -9,31 +9,31 @@ import java.security.spec.X509EncodedKeySpec;
 
 public class KeyUtil {
 
-    public static void generateAndStoreKeyPair(String username) throws Exception {
-        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
-        keyPairGenerator.initialize(2048); // Key size
-        KeyPair keyPair = keyPairGenerator.generateKeyPair();
-
-        // Store the public key
-        Path publicKeyPath = Paths.get("C:\\Users\\sonal\\OneDrive\\Desktop\\SkyCrate\\Skycrate\\keys", username + "_public.key");
-        Files.write(publicKeyPath, keyPair.getPublic().getEncoded());
-
-        // Store the private key
-        Path privateKeyPath = Paths.get("C:\\Users\\sonal\\OneDrive\\Desktop\\SkyCrate\\Skycrate\\keys", username + "_private.key");
-        Files.write(privateKeyPath, keyPair.getPrivate().getEncoded());
-    }
-
-    public static PublicKey getPublicKeyForUser(String username) throws Exception {
-        Path path = Paths.get("C:\\Users\\sonal\\OneDrive\\Desktop\\SkyCrate\\Skycrate\\keys", username + "_public.key");
-        byte[] bytes = Files.readAllBytes(path);
-        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(bytes);
-        return KeyFactory.getInstance("RSA").generatePublic(keySpec);
-    }
-
-    public static PrivateKey getPrivateKeyForUser(String username) throws Exception {
-        Path path = Paths.get("C:\\Users\\sonal\\OneDrive\\Desktop\\SkyCrate\\Skycrate\\keys", username + "_private.key");
-        byte[] bytes = Files.readAllBytes(path);
-        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(bytes);
-        return KeyFactory.getInstance("RSA").generatePrivate(keySpec);
-    }
+//    public static void generateAndStoreKeyPair(String username) throws Exception {
+//        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
+//        keyPairGenerator.initialize(2048); // Key size
+//        KeyPair keyPair = keyPairGenerator.generateKeyPair();
+//
+//        // Store the public key
+//        Path publicKeyPath = Paths.get("C:\\Users\\sonal\\OneDrive\\Desktop\\SkyCrate\\Skycrate\\keys", username + "_public.key");
+//        Files.write(publicKeyPath, keyPair.getPublic().getEncoded());
+//
+//        // Store the private key
+//        Path privateKeyPath = Paths.get("C:\\Users\\sonal\\OneDrive\\Desktop\\SkyCrate\\Skycrate\\keys", username + "_private.key");
+//        Files.write(privateKeyPath, keyPair.getPrivate().getEncoded());
+//    }
+//
+//    public static PublicKey getPublicKeyForUser(String username) throws Exception {
+//        Path path = Paths.get("C:\\Users\\sonal\\OneDrive\\Desktop\\SkyCrate\\Skycrate\\keys", username + "_public.key");
+//        byte[] bytes = Files.readAllBytes(path);
+//        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(bytes);
+//        return KeyFactory.getInstance("RSA").generatePublic(keySpec);
+//    }
+//
+//    public static PrivateKey getPrivateKeyForUser(String username) throws Exception {
+//        Path path = Paths.get("C:\\Users\\sonal\\OneDrive\\Desktop\\SkyCrate\\Skycrate\\keys", username + "_private.key");
+//        byte[] bytes = Files.readAllBytes(path);
+//        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(bytes);
+//        return KeyFactory.getInstance("RSA").generatePrivate(keySpec);
+//    }
 }

src/main/java/com/skycrate/backend/skycrateBackend/utils/RSAKeyUtil.java

@@ -52,22 +52,22 @@ public class RSAKeyUtil {
         return cipher.doFinal(encryptedData);
     }
 
-    // AES key generation
-    public static SecretKey generateAESKey(int keySize) throws NoSuchAlgorithmException {
-        if (keySize != 128 && keySize != 192 && keySize != 256) {
-            throw new IllegalArgumentException("Invalid AES key size. Must be 128, 192, or 256 bits.");
-        }
-        KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
-        keyGenerator.init(keySize);
-        return keyGenerator.generateKey();
-    }
-
-    public static byte[] encryptAESKey(SecretKey aesKey, PublicKey publicKey) throws Exception {
-        return encrypt(aesKey.getEncoded(), publicKey);
-    }
-
-    public static SecretKey decryptAESKey(byte[] encryptedAESKey, PrivateKey privateKey, int keySize) throws Exception {
-        byte[] decryptedKey = decrypt(encryptedAESKey, privateKey);
-        return new SecretKeySpec(decryptedKey, 0, decryptedKey.length, "AES");
-    }
+//    // AES key generation
+//    public static SecretKey generateAESKey(int keySize) throws NoSuchAlgorithmException {
+//        if (keySize != 128 && keySize != 192 && keySize != 256) {
+//            throw new IllegalArgumentException("Invalid AES key size. Must be 128, 192, or 256 bits.");
+//        }
+//        KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
+//        keyGenerator.init(keySize);
+//        return keyGenerator.generateKey();
+//    }
+//
+//    public static byte[] encryptAESKey(SecretKey aesKey, PublicKey publicKey) throws Exception {
+//        return encrypt(aesKey.getEncoded(), publicKey);
+//    }
+//
+//    public static SecretKey decryptAESKey(byte[] encryptedAESKey, PrivateKey privateKey, int keySize) throws Exception {
+//        byte[] decryptedKey = decrypt(encryptedAESKey, privateKey);
+//        return new SecretKeySpec(decryptedKey, 0, decryptedKey.length, "AES");
+//    }
 }

src/main/resources/application-prod.yml

@@ -6,4 +6,3 @@ server:
     key-store-password: changeit
     key-store-type: PKCS12
     key-alias: tomcat
-

src/main/resources/application.properties

@@ -5,13 +5,13 @@ spring.servlet.multipart.max-request-size=1000MB
 
 spring.servlet.multipart.enabled=true
 
-security.jwt.secret-key=PPp27xSTfBwOpRn4/AV6gPzQSnQg+Oi80KdWfCcuAHs=
+security.jwt.secret-key=${JWT_SECRET}
 security.jwt.expiration-time=3600000
 
 spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect
-spring.datasource.username=skycrateDB
-spring.datasource.password=loa_dngLLA8729
-spring.datasource.url=jdbc:mysql://192.168.29.36:3306/skycrate
+spring.datasource.username=${DB_USERNAME}
+spring.datasource.password=${DB_PASSWORD}
+spring.datasource.url=jdbc:mysql://${DB_URI}/${DB_NAME}
 
 spring.jpa.hibernate.ddl-auto=update
 spring.jpa.show-sql=true
@@ -23,15 +23,14 @@ server.port=8080
 
 server.ssl.enabled=true
 server.ssl.key-store=classpath:keystore.p12
-server.ssl.key-store-password=changeit
+server.ssl.key-store-password=${SSL_PASSWORD}
 server.ssl.key-store-type=PKCS12
-server.ssl.key-alias=mykey
+server.ssl.key-alias=skycrateSSL
 
 management.endpoints.web.exposure.include=*
 management.endpoint.health.show-details=always
 management.endpoints.enabled-by-default=true
 
-
 # Allow unauthenticated access
 #management.server.port=8080
 #management.server.ssl.enabled=false

src/main/resources/keystore.p12

@@ -0,0 +1 @@
+GENERATE USING: keytool -genkeypair -alias skycrateSSL -keyalg RSA -keysize 4096 -keystore keystore.p12 -storetype PKCS12 -validity 3650 -dname "CN=localhost, OU=Skycrate, O=Skycrate, C=India"