IMPLEMENTED ENCRYPTION & DECRYPTION

.gitignore

@@ -31,6 +31,3 @@ build/
 
 ### VS Code ###
 .vscode/
-
-### apach-maven binary ###
-apache-maven-3.9.6

Dockerfile

@@ -1,34 +0,0 @@
-## BACKEND ##
-
-# Base image
-FROM debian:12-slim
-
-# Metadata
-LABEL maintainer="kshitijka"
-LABEL version=1.0
-LABEL description="Skycrate is a web based file management system that uses Hadoop as filesystem."
-
-# Update & upgrade & install & rm
-RUN apt-get update && apt-get upgrade -y && \
-    apt-get install -y openjdk-17-jdk && \
-    rm -rf /var/lib/apt/lists/* 
-
-# Create non-root user
-RUN useradd -s /bin/bash skycrateBack
-
-# Create work dir
-RUN mkdir /app
-RUN chown -R skycrateBack:skycrateBack /app
-COPY ./target/ /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
-
-CMD ["java", "-jar", "/app/skycrateBackend-0.0.1-SNAPSHOT.jar"]

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

@@ -12,8 +12,8 @@ import java.security.PrivilegedExceptionAction;
 public class HDFSConfig {
     public static FileSystem getHDFS() throws Exception {
         Configuration conf = new Configuration();
-        conf.set("fs.defaultFS", "hdfs://namenode:9000");
-        return FileSystem.get(new URI("hdfs://namenode:9000"), conf);
+        conf.set("fs.defaultFS", "hdfs://192.168.29.56:9000");
+        return FileSystem.get(new URI("hdfs://192.168.29.56:9000"), conf);
     }
 
 

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

@@ -36,6 +36,7 @@ public class JwtAuthenticationFilter extends OncePerRequestFilter {
         }
 
         @Override
+
     protected void doFilterInternal(
         @NonNull HttpServletRequest request,
         @NonNull HttpServletResponse response,
@@ -59,6 +60,8 @@ public class JwtAuthenticationFilter extends OncePerRequestFilter {
                         );
                     authenticationToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                     SecurityContextHolder.getContext().setAuthentication(authenticationToken);
+
+
                 }
 
             }

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

@@ -73,29 +73,30 @@ public class HDFScontroller {
             @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
+            // Step 1: Retrieve the user and their RSA public key
+            User user = userRepository.findByUsername(username)
+                    .orElseThrow(() -> new RuntimeException("User not found"));
             byte[] publicKeyBytes = user.getPublicKey();
             PublicKey publicKey = RSAKeyUtil.getPublicKeyFromBytes(publicKeyBytes);
 
-            // Encrypt the file content using the public key
-            byte[] encryptedData = encryptFile(file, publicKey);
+            // Step 2: Encrypt the file content using hybrid encryption (AES + RSA)
+            byte[] fileBytes = file.getBytes();
+            byte[] encryptedData = EncryptionUtil.encrypt(fileBytes, publicKey);
 
-            // Upload the encrypted file to HDFS
+            // Step 3: Upload encrypted data 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);
+            return new ResponseDTO("Failed to read file: " + 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
@@ -279,25 +280,4 @@ public class HDFScontroller {
                     .body("Failed to list files: " + e.getMessage());
         }
     }
-
-
-    @GetMapping("/getUsernameByEmail")
-    public ResponseEntity<?> getUsernameByEmail(@RequestParam String email) {
-        try {
-            // Fetch user from the database using the provided email
-            User user = userRepository.findByEmail(email)
-                    .orElseThrow(() -> new RuntimeException("User not found with email: " + email));
-
-//            // Log the retrieved user object to verify the username
-//            System.out.println("Retrieved user: " + user.getFullname());
-
-            // Return the username as the response
-            return ResponseEntity.ok(user.getFullname()); // Return the username
-        } catch (Exception e) {
-            // Handle error if user is not found or other exceptions occur
-            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
-                    .body("Failed to fetch username: " + e.getMessage());
-        }
-    }
-
 }

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

@@ -1,10 +1,9 @@
 package com.skycrate.backend.skycrateBackend.services;
 
-import com.skycrate.backend.skycrateBackend.utils.RSAKeyUtil;
-
 import javax.crypto.*;
 import javax.crypto.spec.SecretKeySpec;
 import java.security.*;
+import java.util.Arrays;
 
 public class EncryptionUtil {
     private static final String RSA_ALGORITHM = "RSA";
@@ -20,57 +19,36 @@ public class EncryptionUtil {
     }
 
     // Encrypt data using AES (AES Key is encrypted using RSA)
-//    public static byte[] encrypt(byte[] data, PublicKey publicKey) throws Exception {
-//        // Step 1: Generate AES Key
-//        SecretKey aesKey = generateAESKey();
-//
-//        // Encrypt data using AES
-//        Cipher aesCipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
-//        aesCipher.init(Cipher.ENCRYPT_MODE, aesKey);
-//        byte[] encryptedData = aesCipher.doFinal(data);
-//
-//        // 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 encrypted AES key and encrypted data into one array
-//        byte[] combined = new byte[4 + encryptedAesKey.length + encryptedData.length];
-//
-//        // First 4 bytes indicate the length of the AES encrypted key
-//        combined[0] = (byte) (encryptedAesKey.length >> 24);
-//        combined[1] = (byte) (encryptedAesKey.length >> 16);
-//        combined[2] = (byte) (encryptedAesKey.length >> 8);
-//        combined[3] = (byte) encryptedAesKey.length;
-//
-//        // Copy AES Key and Encrypted Data into the combined array
-//        System.arraycopy(encryptedAesKey, 0, combined, 4, encryptedAesKey.length);
-//        System.arraycopy(encryptedData, 0, combined, 4 + encryptedAesKey.length, encryptedData.length);
-//
-//        return combined;
-//    }
-
     public static byte[] encrypt(byte[] data, PublicKey publicKey) throws Exception {
-        SecretKey aesKey = RSAKeyUtil.generateAESKey(256); // Ensure 256 bits
-        byte[] encryptedData = encryptDataWithAES(data, aesKey);
-        byte[] encryptedAesKey = RSAKeyUtil.encryptAESKey(aesKey, publicKey);
-        return combineEncryptedData(encryptedAesKey, encryptedData);
-    }
+        // Step 1: Generate AES Key
+        SecretKey aesKey = generateAESKey();
 
-    private static byte[] encryptDataWithAES(byte[] data, SecretKey aesKey) throws Exception {
+        // Encrypt data using AES
         Cipher aesCipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
         aesCipher.init(Cipher.ENCRYPT_MODE, aesKey);
-        return aesCipher.doFinal(data);
-    }
+        byte[] encryptedData = aesCipher.doFinal(data);
 
-    private static byte[] combineEncryptedData(byte[] encryptedAesKey, byte[] encryptedData) {
+        // 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 encrypted AES key and encrypted data into one array
         byte[] combined = new byte[4 + encryptedAesKey.length + encryptedData.length];
+
+        // First 4 bytes indicate the length of the AES encrypted key
+        combined[0] = (byte) (encryptedAesKey.length >> 24);
+        combined[1] = (byte) (encryptedAesKey.length >> 16);
+        combined[2] = (byte) (encryptedAesKey.length >> 8);
+        combined[3] = (byte) encryptedAesKey.length;
+
+        // Copy AES Key and Encrypted Data into the combined array
         System.arraycopy(encryptedAesKey, 0, combined, 4, encryptedAesKey.length);
         System.arraycopy(encryptedData, 0, combined, 4 + encryptedAesKey.length, encryptedData.length);
+
         return combined;
     }
 
-
     // Decrypt data using RSA (AES Key is decrypted using RSA, then used for AES decryption)
     public static byte[] decrypt(byte[] encryptedCombined, PrivateKey privateKey) throws Exception {
         // Step 1: Extract AES Key length from the combined data
@@ -99,4 +77,11 @@ public class EncryptionUtil {
         aesCipher.init(Cipher.DECRYPT_MODE, aesKey);
         return aesCipher.doFinal(encryptedData);
     }
+
+    // Generate a random AES key
+    private static SecretKey generateAESKey() throws NoSuchAlgorithmException {
+        KeyGenerator keyGen = KeyGenerator.getInstance(AES_ALGORITHM);
+        keyGen.init(AES_KEY_SIZE);
+        return keyGen.generateKey();
+    }
 }

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

@@ -39,118 +39,82 @@ public class HDFSOperations {
         this.userRepository = userRepository;
     }
 
-//    public void uploadFile(byte[] fileData, String hdfsPath, String uploadedFileName, String username) {
-//        try {
-//            FileSystem fs = HDFSConfig.getHDFS();
-//
-//            // Create an InputStream from the byte array
-//            ByteArrayInputStream inputStream = new ByteArrayInputStream(fileData);
-//
-//            // Prepare the path for HDFS
-//            String finalHdfsPath = hdfsPath.endsWith("/") ? hdfsPath + uploadedFileName : hdfsPath + "/" + uploadedFileName;
-//
-//            // Upload the file directly to HDFS from the InputStream
-//            Path hdfsFilePath = new Path(finalHdfsPath);
-//            FSDataOutputStream outputStream = fs.create(hdfsFilePath);
-//            IOUtils.copyBytes(inputStream, outputStream, 4096, true);
-//
-//        } catch (IOException e) {
-//            // Handle I/O exception and log the error
-//            throw new RuntimeException("Failed to upload file to HDFS: " + e.getMessage(), e);
-//        } catch (Exception e) {
-//            // Catch any other exceptions
-//            throw new RuntimeException("Failed to upload file to HDFS: " + e.getMessage(), e);
-//        }
-//    }
-//
-//    public void downloadFile(String hdfsEncPath, String localPathWithoutExt, String username) {
-//        try {
-//            FileSystem fs = HDFSConfig.getHDFS();
-//
-//            // Extract file name and extension
-//            String encFileName = new File(hdfsEncPath).getName();
-//            String originalFileName = encFileName.replace(".enc", "");
-//            String fileExtension = originalFileName.substring(originalFileName.lastIndexOf(".") + 1);
-//
-//            String fullDecryptedPath = localPathWithoutExt + "/" + originalFileName;
-//            String encFilePath = fullDecryptedPath + ".enc";
-//            String keyFilePath = fullDecryptedPath + ".key";
-//
-//            // Download encrypted file and AES key from HDFS
-//            fs.copyToLocalFile(new Path(hdfsEncPath), new Path(encFilePath));
-//            fs.copyToLocalFile(new Path(hdfsEncPath.replace(".enc", ".key")), new Path(keyFilePath));
-//
-//            // Read the encrypted AES key
-//            byte[] encryptedAesKey = Files.readAllBytes(Paths.get(keyFilePath));
-//            System.out.println("Length of encrypted AES key: " + encryptedAesKey.length);
-//
-//            // 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());
-//
-//            Cipher rsaCipher = Cipher.getInstance("RSA");
-//            rsaCipher.init(Cipher.DECRYPT_MODE, privateKey);
-//            byte[] aesKeyBytes = rsaCipher.doFinal(encryptedAesKey);
-//
-//            // Ensure valid AES key length
-//            if (aesKeyBytes.length != 16 && aesKeyBytes.length != 24 && aesKeyBytes.length != 32) {
-//                throw new RuntimeException("Invalid AES key length: " + aesKeyBytes.length + " bytes");
-//            }
-//
-//            SecretKey aesKey = new SecretKeySpec(aesKeyBytes, 0, aesKeyBytes.length, "AES");
-//
-//            // Read the encrypted file content
-//            byte[] encryptedFileContent = Files.readAllBytes(Paths.get(encFilePath));
-//
-//            // Decrypt the file content using AES
-//            Cipher aesCipher = Cipher.getInstance("AES/ECB/PKCS5Padding"); // Specify padding
-//            aesCipher.init(Cipher.DECRYPT_MODE, aesKey);
-//            byte[] decryptedFileContent = aesCipher.doFinal(encryptedFileContent);
-//
-//            // Write the decrypted content to the original file
-//            Files.write(Paths.get(fullDecryptedPath + "." + fileExtension), decryptedFileContent);
-//
-//            // Cleanup temporary files
-//            Files.deleteIfExists(Paths.get(encFilePath));
-//            Files.deleteIfExists(Paths.get(keyFilePath));
-//
-//        } 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();
+
+            // Create an InputStream from the byte array
             ByteArrayInputStream inputStream = new ByteArrayInputStream(fileData);
+
+            // Prepare the path for HDFS
             String finalHdfsPath = hdfsPath.endsWith("/") ? hdfsPath + uploadedFileName : hdfsPath + "/" + uploadedFileName;
+
+            // Upload the file directly to HDFS from the InputStream
             Path hdfsFilePath = new Path(finalHdfsPath);
-            try (FSDataOutputStream outputStream = fs.create(hdfsFilePath)) {
-                IOUtils.copyBytes(inputStream, outputStream, 4096, true);
-            }
+            FSDataOutputStream outputStream = fs.create(hdfsFilePath);
+            IOUtils.copyBytes(inputStream, outputStream, 4096, true);
+
         } catch (IOException e) {
+            // Handle I/O exception and log the error
             throw new RuntimeException("Failed to upload file to HDFS: " + e.getMessage(), e);
         } catch (Exception e) {
-            throw new RuntimeException(e);
+            // Catch any other exceptions
+            throw new RuntimeException("Failed to upload file to HDFS: " + e.getMessage(), 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));
 
+            // Extract file name and extension
+            String encFileName = new File(hdfsEncPath).getName();
+            String originalFileName = encFileName.replace(".enc", "");
+            String fileExtension = originalFileName.substring(originalFileName.lastIndexOf(".") + 1);
+
+            String fullDecryptedPath = localPathWithoutExt + "/" + originalFileName;
+            String encFilePath = fullDecryptedPath + ".enc";
+            String keyFilePath = fullDecryptedPath + ".key";
+
+            // Download encrypted file and AES key from HDFS
+            fs.copyToLocalFile(new Path(hdfsEncPath), new Path(encFilePath));
+            fs.copyToLocalFile(new Path(hdfsEncPath.replace(".enc", ".key")), new Path(keyFilePath));
+
+            // Read the encrypted AES key
+            byte[] encryptedAesKey = Files.readAllBytes(Paths.get(keyFilePath));
+            System.out.println("Length of encrypted AES key: " + encryptedAesKey.length);
+
+            // 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());
 
-            byte[] encryptedFileContent = Files.readAllBytes(Paths.get(encFilePath));
-            byte[] decryptedFileContent = RSAKeyUtil.decrypt(encryptedFileContent, privateKey);
+            Cipher rsaCipher = Cipher.getInstance("RSA");
+            rsaCipher.init(Cipher.DECRYPT_MODE, privateKey);
+            byte[] aesKeyBytes = rsaCipher.doFinal(encryptedAesKey);
 
-            Files.write(Paths.get(localPathWithoutExt), decryptedFileContent);
+            // Ensure valid AES key length
+            if (aesKeyBytes.length != 16 && aesKeyBytes.length != 24 && aesKeyBytes.length != 32) {
+                throw new RuntimeException("Invalid AES key length: " + aesKeyBytes.length + " bytes");
+            }
+
+            SecretKey aesKey = new SecretKeySpec(aesKeyBytes, 0, aesKeyBytes.length, "AES");
+
+            // Read the encrypted file content
+            byte[] encryptedFileContent = Files.readAllBytes(Paths.get(encFilePath));
+
+            // Decrypt the file content using AES
+            Cipher aesCipher = Cipher.getInstance("AES/ECB/PKCS5Padding"); // Specify padding
+            aesCipher.init(Cipher.DECRYPT_MODE, aesKey);
+            byte[] decryptedFileContent = aesCipher.doFinal(encryptedFileContent);
+
+            // Write the decrypted content to the original file
+            Files.write(Paths.get(fullDecryptedPath + "." + fileExtension), decryptedFileContent);
+
+            // Cleanup temporary files
             Files.deleteIfExists(Paths.get(encFilePath));
+            Files.deleteIfExists(Paths.get(keyFilePath));
+
         } catch (Exception e) {
             throw new RuntimeException("Failed to download or decrypt file: " + e.getMessage(), e);
         }

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

@@ -52,29 +52,19 @@ public class RSAKeyUtil {
         keyGenerator.init(keySize); // Specify the key size
         return keyGenerator.generateKey();
     }
-//
-//    // Encrypt AES Key using RSA
-//    public static byte[] encryptAESKey(SecretKey aesKey, PublicKey publicKey) throws Exception {
-//        return encrypt(aesKey.getEncoded(), publicKey); // Encrypt the AES key using RSA
-//    }
-//
-//    // Decrypt AES Key using RSA
-//    public static SecretKey decryptAESKey(byte[] encryptedAESKey, PrivateKey privateKey, int keySize) throws Exception {
-//        byte[] decryptedKey = decrypt(encryptedAESKey, privateKey); // Decrypt with RSA
-//        // Ensure that the decrypted key length matches the expected AES key size
-//        if (decryptedKey.length != keySize / 8) {
-//            throw new IllegalArgumentException("Decrypted key size does not match expected AES key size.");
-//        }
-//        return new SecretKeySpec(decryptedKey, 0, decryptedKey.length, "AES"); // Convert to AES Key
-//    }
 
+    // Encrypt AES Key using RSA
     public static byte[] encryptAESKey(SecretKey aesKey, PublicKey publicKey) throws Exception {
-        return encrypt(aesKey.getEncoded(), publicKey);
+        return encrypt(aesKey.getEncoded(), publicKey); // Encrypt the AES key using RSA
     }
 
+    // Decrypt AES Key using RSA
     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");
+        byte[] decryptedKey = decrypt(encryptedAESKey, privateKey); // Decrypt with RSA
+        // Ensure that the decrypted key length matches the expected AES key size
+        if (decryptedKey.length != keySize / 8) {
+            throw new IllegalArgumentException("Decrypted key size does not match expected AES key size.");
+        }
+        return new SecretKeySpec(decryptedKey, 0, decryptedKey.length, "AES"); // Convert to AES Key
     }
-
-}
+}

src/main/resources/application.properties

@@ -9,9 +9,9 @@ security.jwt.secret-key=3cfa76ef14937c1c0ea519f8fc057a80fcd04a7420f8e8bcd0a7567c
 security.jwt.expiration-time=3600000
 
 spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect
-spring.datasource.username=skycrateDB
-spring.datasource.password=${MYSQL_PASSWORD}
-spring.datasource.url=jdbc:mysql://db:3306/skycrate
+spring.datasource.username=kshitij
+spring.datasource.password=loa_dngLLA8729
+spring.datasource.url=jdbc:mysql://192.168.29.55:3306/skycrate
 
 spring.jpa.hibernate.ddl-auto=update
 spring.jpa.show-sql=true
@@ -19,7 +19,7 @@ spring.jpa.properties.hibernate.format_sql=true
 spring.jpa.open-in-view=false
 logging.level.org.springframework.security.config.annotation.authentication.configuration.InitializeUserDetailsBeanManagerConfigurer=ERROR
 
-server.port=8081
+server.port=8080