before final cleaning and salt

app/src/main/java/com/example/bsm_notatnik/AESUtils.java

@@ -1,51 +0,0 @@
-package com.example.bsm_notatnik;
-
-import javax.crypto.*;
-import javax.crypto.spec.IvParameterSpec;
-import javax.crypto.spec.SecretKeySpec;
-import java.security.InvalidAlgorithmParameterException;
-import java.security.InvalidKeyException;
-import java.security.NoSuchAlgorithmException;
-import java.util.Base64;
-
-public class AESUtils {
-
-    private static final String ALGORITHM = "AES";
-    private static final String TRANSFORMATION = "AES/ECB/PKCS5Padding"; // Use ECB mode without an IV
-
-    public static String encrypt(String data, String key) {
-        try {
-            Cipher cipher = Cipher.getInstance(TRANSFORMATION);
-            SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(), ALGORITHM);
-            cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
-
-            byte[] encryptedData = cipher.doFinal(data.getBytes());
-
-            return Base64.getEncoder().encodeToString(encryptedData);
-
-        } catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException |
-                 IllegalBlockSizeException | BadPaddingException e) {
-            e.printStackTrace();
-            return null;
-        }
-    }
-
-    public static String decrypt(String encryptedData, String key) {
-        try {
-            byte[] encryptedBytes = Base64.getDecoder().decode(encryptedData);
-
-            Cipher cipher = Cipher.getInstance(TRANSFORMATION);
-            SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(), ALGORITHM);
-            cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);
-
-            byte[] decryptedData = cipher.doFinal(encryptedBytes);
-            return new String(decryptedData);
-
-        } catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException |
-                 IllegalBlockSizeException | BadPaddingException e) {
-            e.printStackTrace();
-            return null;
-        }
-    }
-}
-

app/src/main/java/com/example/bsm_notatnik/CryptoManager.java

@@ -1,100 +0,0 @@
-package com.example.bsm_notatnik;
-
-import android.os.Build;
-import android.security.keystore.KeyGenParameterSpec;
-import android.security.keystore.KeyProperties;
-
-import androidx.annotation.RequiresApi;
-
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.nio.charset.StandardCharsets;
-import java.security.KeyStore;
-
-import javax.crypto.Cipher;
-import javax.crypto.KeyGenerator;
-import javax.crypto.SecretKey;
-import javax.crypto.spec.IvParameterSpec;
-
-public class CryptoManager {
-
-    private final KeyStore keyStore;
-
-    public CryptoManager() throws Exception {
-        keyStore = KeyStore.getInstance("AndroidKeyStore");
-        keyStore.load(null);
-    }
-
-    private Cipher getEncryptCipher() throws Exception {
-        Cipher cipher = Cipher.getInstance(TRANSFORMATION);
-        cipher.init(Cipher.ENCRYPT_MODE, getKey());
-        return cipher;
-    }
-
-    private Cipher getDecryptCipherForIv(byte[] iv) throws Exception {
-        Cipher cipher = Cipher.getInstance(TRANSFORMATION);
-        cipher.init(Cipher.DECRYPT_MODE, getKey(), new IvParameterSpec(iv));
-        return cipher;
-    }
-
-    private SecretKey getKey() throws Exception {
-        KeyStore.SecretKeyEntry existingKey = (KeyStore.SecretKeyEntry) keyStore.getEntry("secret", null);
-        return (existingKey != null) ? existingKey.getSecretKey() : createKey();
-    }
-
-    private SecretKey createKey() throws Exception {
-        KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM);
-        keyGenerator.init(new KeyGenParameterSpec.Builder(
-                "secret",
-                KeyProperties.PURPOSE_ENCRYPT | KeyProperties.PURPOSE_DECRYPT)
-                .setBlockModes(BLOCK_MODE)
-                .setEncryptionPaddings(PADDING)
-                .setUserAuthenticationRequired(false)
-                .setRandomizedEncryptionRequired(true)
-                .build()
-        );
-        return keyGenerator.generateKey();
-    }
-
-
-
-
-    public byte[] encrypt(byte[] bytes, OutputStream outputStream) throws Exception {
-        Cipher encryptCipher = getEncryptCipher();
-        byte[] encryptedBytes = encryptCipher.doFinal(bytes);
-        try {
-            outputStream.write(encryptCipher.getIV().length);
-            outputStream.write(encryptCipher.getIV());
-            outputStream.write(encryptedBytes.length);
-            outputStream.write(encryptedBytes);
-        } finally {
-            outputStream.close();
-        }
-        return encryptedBytes;
-    }
-
-    public byte[] decrypt(InputStream inputStream) throws Exception {
-        byte[] iv;
-        byte[] encryptedBytes;
-        try {
-            int ivSize = inputStream.read();
-            iv = new byte[ivSize];
-            inputStream.read(iv);
-
-            int encryptedBytesSize = inputStream.read();
-            encryptedBytes = new byte[encryptedBytesSize];
-            inputStream.read(encryptedBytes);
-        } finally {
-            inputStream.close();
-        }
-
-        return getDecryptCipherForIv(iv).doFinal(encryptedBytes);
-    }
-
-    private static final String ALGORITHM = KeyProperties.KEY_ALGORITHM_AES;
-    private static final String BLOCK_MODE = KeyProperties.BLOCK_MODE_CBC;
-    private static final String PADDING = KeyProperties.ENCRYPTION_PADDING_PKCS7;
-    private static final String TRANSFORMATION = ALGORITHM + "/" + BLOCK_MODE + "/" + PADDING;
-}

app/src/main/java/com/example/bsm_notatnik/Login.java

@@ -23,6 +23,7 @@ import java.util.Base64;
 import javax.crypto.SecretKey;
 import javax.crypto.SecretKeyFactory;
 import javax.crypto.spec.PBEKeySpec;
+import javax.crypto.spec.SecretKeySpec;
 
 public class Login extends AppCompatActivity {
 
@@ -79,7 +80,13 @@ public class Login extends AppCompatActivity {
                     return;
                 }
 
-                login(hashedEmail, password);
+                try {
+                    login(hashedEmail, password);
+                } catch (NoSuchAlgorithmException e) {
+                    throw new RuntimeException(e);
+                } catch (InvalidKeySpecException e) {
+                    throw new RuntimeException(e);
+                }
                 //progressBar.setVisibility(View.GONE);
             }
         });
@@ -91,7 +98,7 @@ public class Login extends AppCompatActivity {
         return sharedPreferences.contains("user_" + hashedemail);
     }
 
-    private void login(String hashedemail, String password){
+    private void login(String hashedemail, String password) throws NoSuchAlgorithmException, InvalidKeySpecException {
         SharedPreferences sharedPreferences = getSharedPreferences(SHARED_NAME_CREDENTIALS, MODE_PRIVATE);
         String passwordHashFromData = sharedPreferences.getString("user_" + hashedemail, "err");
 
@@ -107,7 +114,8 @@ public class Login extends AppCompatActivity {
 
             Intent intent = new Intent(getApplicationContext(), MainActivity.class);
             intent.putExtra("CURRENT_USER_EMAIL_HASH", hashedemail);
-            intent.putExtra("KEY_HASH", genKeyHash(hashedemail, password));
+            //intent.putExtra("KEY", getKeyFromPassword(password, getSalt2(hashedemail)));
+            intent.putExtra("KEY", password);
             startActivity(intent);
             finish();
 
@@ -117,6 +125,15 @@ public class Login extends AppCompatActivity {
         }
     }
 
+    public static SecretKey getKeyFromPassword(String password, String salt) throws NoSuchAlgorithmException, InvalidKeySpecException {
+
+        SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
+        KeySpec spec = new PBEKeySpec(password.toCharArray(), salt.getBytes(), 65536, 256);
+        SecretKey secret = new SecretKeySpec(factory.generateSecret(spec).getEncoded(), "AES");
+
+        return secret;
+    }
+
     private String genKeyHash(String hashedemail, String password){
         byte[] salt2 = getSaltForUser(hashedemail, true);
         return Utility.hashCredential(password, salt2, 5000);
@@ -136,4 +153,9 @@ public class Login extends AppCompatActivity {
 
     }
 
+    private String getSalt2(String hashedEmail){
+        SharedPreferences sharedPreferences = getSharedPreferences(SHARED_NAME_CREDENTIALS, MODE_PRIVATE);
+        return sharedPreferences.getString("salt_2_" + hashedEmail, "err");
+    }
+
 }

app/src/main/java/com/example/bsm_notatnik/MainActivity.java

@@ -3,7 +3,6 @@ import android.content.Intent;
 import android.content.SharedPreferences;
 import android.os.Bundle;
 import android.text.TextUtils;
-import android.util.Log;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.widget.Button;
@@ -15,71 +14,80 @@ import android.widget.Toast;
 import androidx.appcompat.app.AlertDialog;
 import androidx.appcompat.app.AppCompatActivity;
 
-import java.io.ByteArrayInputStream;
+import java.security.InvalidAlgorithmParameterException;
-import java.io.ByteArrayOutputStream;
+import java.security.InvalidKeyException;
-import java.io.OutputStream;
+import java.security.NoSuchAlgorithmException;
-import java.nio.charset.StandardCharsets;
+import java.security.spec.InvalidKeySpecException;
-import java.security.SecureRandom;
+import java.security.spec.KeySpec;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Base64;
 import java.util.List;
-import java.util.Objects;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
+import javax.crypto.BadPaddingException;
 import javax.crypto.Cipher;
+import javax.crypto.IllegalBlockSizeException;
+import javax.crypto.NoSuchPaddingException;
+import javax.crypto.SecretKey;
+import javax.crypto.SecretKeyFactory;
 import javax.crypto.spec.IvParameterSpec;
+import javax.crypto.spec.PBEKeySpec;
 import javax.crypto.spec.SecretKeySpec;
 
 
 public class MainActivity extends AppCompatActivity {
-    private CryptoManager cryptoManager;
-
     Button buttonLogout, buttonChangePassword, buttonAddNewNote;
     private static final String SHARED_NAME_CREDENTIALS = "Credentials";
-    private static final String SHARED_NOTES_NAME = "Notes";
+    private static final String SHARED_NAME_NOTES = "Notes";
     private static String HASHED_EMAIL = "";
-    private static String KEY_HASH = "";
+    private static String KEY = "";
     private List<Note> noteList;
     private LinearLayout notesContainer;
 
-    private static final String ALGORITHM = "AES";
-    private static final String TRANSFORMATION = "AES/CBC/PKCS5Padding";
-
     @Override
     protected void onCreate(Bundle savedInstanceState) {
 
-        try {
-            cryptoManager = new CryptoManager();
-        } catch (Exception e) {
-            e.printStackTrace(); // Handle exceptions according to your needs
-        }
-
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
 
         Intent intent = getIntent();
         String current_username_hashed = intent.getStringExtra("CURRENT_USER_EMAIL_HASH");
         HASHED_EMAIL = current_username_hashed;
-        KEY_HASH = intent.getStringExtra("KEY_HASH");
+        KEY = intent.getStringExtra("KEY");
 
         notesContainer = findViewById(R.id.notesContainer);
         noteList = new ArrayList<>();
-        loadNotesFromPreferencesToList();
+        try {
+            loadNotesFromPreferencesToList();
+        } catch (NoSuchAlgorithmException e) {
+            throw new RuntimeException(e);
+        } catch (InvalidKeySpecException e) {
+            throw new RuntimeException(e);
+        } catch (InvalidAlgorithmParameterException e) {
+            throw new RuntimeException(e);
+        } catch (NoSuchPaddingException e) {
+            throw new RuntimeException(e);
+        } catch (IllegalBlockSizeException e) {
+            throw new RuntimeException(e);
+        } catch (BadPaddingException e) {
+            throw new RuntimeException(e);
+        } catch (InvalidKeyException e) {
+            throw new RuntimeException(e);
+        }
+
         displayNotes();
 
         buttonLogout = findViewById(R.id.btn_logout);
         buttonChangePassword = findViewById(R.id.btn_change_password);
         buttonAddNewNote = findViewById(R.id.btn_add_note);
 
-        Log.i("KURWAAAAAAAAAAAAAAAAA", KEY_HASH);
-
         buttonLogout.setOnClickListener(view -> logOut());
 
         buttonChangePassword.setOnClickListener(view -> showPasswordChangeDialog(current_username_hashed));
 
         buttonAddNewNote.setOnClickListener(view -> showAddNewNoteDialog());
-
     }
 
 
@@ -127,77 +135,36 @@ public class MainActivity extends AppCompatActivity {
             }
 
             if (newPassword.equals(confirmPassword)) {
-                updatePassword(hashedEmail, newPassword);
+                try {
+                    updatePassword(hashedEmail, newPassword);
+                } catch (InvalidAlgorithmParameterException e) {
+                    throw new RuntimeException(e);
+                } catch (NoSuchPaddingException e) {
+                    throw new RuntimeException(e);
+                } catch (IllegalBlockSizeException e) {
+                    throw new RuntimeException(e);
+                } catch (NoSuchAlgorithmException e) {
+                    throw new RuntimeException(e);
+                } catch (InvalidKeySpecException e) {
+                    throw new RuntimeException(e);
+                } catch (BadPaddingException e) {
+                    throw new RuntimeException(e);
+                } catch (InvalidKeyException e) {
+                    throw new RuntimeException(e);
+                }
+
                 Toast.makeText(MainActivity.this, "Password Changed", Toast.LENGTH_SHORT).show();
             } else {
                 Toast.makeText(MainActivity.this, "New passwords don't match!", Toast.LENGTH_SHORT).show();
             }
         });
 
-        // Set up the negative (Cancel) button
         builder.setNegativeButton("Cancel", (dialogInterface, i) -> dialogInterface.dismiss());
 
-        // Create and show the AlertDialog
         AlertDialog alertDialog = builder.create();
         alertDialog.show();
     }
 
-    private boolean validatePassword(String password){
-        final String PASSWORD_PATTERN = "^.{6,}$";
-        Pattern pattern = Pattern.compile(PASSWORD_PATTERN);
-        Matcher matcher = pattern.matcher(password);
-
-        return matcher.matches();
-    }
-
-    private void updatePassword(String hashedEmail, String newPassword){
-        SharedPreferences sharedPreferences = getSharedPreferences(SHARED_NAME_CREDENTIALS, MODE_PRIVATE);
-        SharedPreferences.Editor editor = sharedPreferences.edit();
-
-        byte[] newSalt = Utility.generateSalt();
-        String newSaltString = Base64.getEncoder().encodeToString(newSalt);
-        editor.putString("salt_" + hashedEmail, newSaltString);
-
-        String hashedNewPassword = Utility.hashCredential(newPassword, newSalt, 1000);
-        editor.putString("user_" + hashedEmail, hashedNewPassword);
-        editor.apply();
-    }
-
-    private boolean validateOldPassword(String hashedEmail, String oldPassword){
-        byte[] salt = getSaltForUser(hashedEmail, false);
-        String hashedOldPassword = Utility.hashCredential(oldPassword, salt, 1000);
-        String hashedCorrectPassword = getPasswordFromShared(hashedEmail);
-
-        assert hashedOldPassword != null;
-        return hashedOldPassword.equals(hashedCorrectPassword);
-    }
-
-    private byte[] getSaltForUser(String hashedEmail, boolean salt2){
-        SharedPreferences sharedPreferences = getSharedPreferences(SHARED_NAME_CREDENTIALS, MODE_PRIVATE);
-        String saltFromData;
-
-        if (salt2){
-             saltFromData = sharedPreferences.getString("salt_2_" + hashedEmail, "err");
-        }
-        else {
-             saltFromData = sharedPreferences.getString("salt_" + hashedEmail, "err");
-        }
-        return Base64.getDecoder().decode(saltFromData);
-
-    }
-
-    private String getPasswordFromShared(String hashedEmail){
-        SharedPreferences sharedPreferences = getSharedPreferences(SHARED_NAME_CREDENTIALS, MODE_PRIVATE);
-        return sharedPreferences.getString("user_" + hashedEmail, "err");
-    }
-
-
-
-
-
-
-
-
 
     private void showAddNewNoteDialog(){
         LayoutInflater inflater = getLayoutInflater();
@@ -220,7 +187,23 @@ public class MainActivity extends AppCompatActivity {
 
                 noteList.add(note);
 
-                saveNotesToPreferences("add");
+                try {
+                    saveNotesToPreferences("add");
+                } catch (NoSuchAlgorithmException e) {
+                    throw new RuntimeException(e);
+                } catch (InvalidKeySpecException e) {
+                    throw new RuntimeException(e);
+                } catch (InvalidAlgorithmParameterException e) {
+                    throw new RuntimeException(e);
+                } catch (NoSuchPaddingException e) {
+                    throw new RuntimeException(e);
+                } catch (IllegalBlockSizeException e) {
+                    throw new RuntimeException(e);
+                } catch (BadPaddingException e) {
+                    throw new RuntimeException(e);
+                } catch (InvalidKeyException e) {
+                    throw new RuntimeException(e);
+                }
                 createNoteView(note);
             }
 
@@ -251,14 +234,46 @@ public class MainActivity extends AppCompatActivity {
             String content = noteContentEditText.getText().toString();
 
             if (!title.isEmpty() && !content.isEmpty()){
-                deleteNoteAndRefresh(note);
+                try {
+                    deleteNoteAndRefresh(note);
+                } catch (InvalidAlgorithmParameterException e) {
+                    throw new RuntimeException(e);
+                } catch (NoSuchPaddingException e) {
+                    throw new RuntimeException(e);
+                } catch (IllegalBlockSizeException e) {
+                    throw new RuntimeException(e);
+                } catch (NoSuchAlgorithmException e) {
+                    throw new RuntimeException(e);
+                } catch (InvalidKeySpecException e) {
+                    throw new RuntimeException(e);
+                } catch (BadPaddingException e) {
+                    throw new RuntimeException(e);
+                } catch (InvalidKeyException e) {
+                    throw new RuntimeException(e);
+                }
 
                 note.setTitle(title);
                 note.setContent(content);
 
                 noteList.add(note);
 
-                saveNotesToPreferences("add");
+                try {
+                    saveNotesToPreferences("add");
+                } catch (NoSuchAlgorithmException e) {
+                    throw new RuntimeException(e);
+                } catch (InvalidKeySpecException e) {
+                    throw new RuntimeException(e);
+                } catch (InvalidAlgorithmParameterException e) {
+                    throw new RuntimeException(e);
+                } catch (NoSuchPaddingException e) {
+                    throw new RuntimeException(e);
+                } catch (IllegalBlockSizeException e) {
+                    throw new RuntimeException(e);
+                } catch (BadPaddingException e) {
+                    throw new RuntimeException(e);
+                } catch (InvalidKeyException e) {
+                    throw new RuntimeException(e);
+                }
                 createNoteView(note);
             }else {
                 Toast.makeText(MainActivity.this, "Enter title and content!", Toast.LENGTH_SHORT).show();
@@ -274,8 +289,94 @@ public class MainActivity extends AppCompatActivity {
     }
 
 
-    private void saveNotesToPreferences(String mode){
+    private void showDeleteDialog(final Note note){
-        SharedPreferences sharedPreferences = getSharedPreferences(SHARED_NOTES_NAME, MODE_PRIVATE);
+        AlertDialog.Builder builder = new AlertDialog.Builder(this);
+        builder.setTitle("Delete this note");
+        builder.setMessage("Are you sure you want to delete it?");
+        builder.setPositiveButton("Delete", (dialogInterface, i) -> {
+            try {
+                deleteNoteAndRefresh(note);
+            } catch (InvalidAlgorithmParameterException e) {
+                throw new RuntimeException(e);
+            } catch (NoSuchPaddingException e) {
+                throw new RuntimeException(e);
+            } catch (IllegalBlockSizeException e) {
+                throw new RuntimeException(e);
+            } catch (NoSuchAlgorithmException e) {
+                throw new RuntimeException(e);
+            } catch (InvalidKeySpecException e) {
+                throw new RuntimeException(e);
+            } catch (BadPaddingException e) {
+                throw new RuntimeException(e);
+            } catch (InvalidKeyException e) {
+                throw new RuntimeException(e);
+            }
+        });
+        builder.setNegativeButton("Cancel", null);
+        builder.show();
+    }
+
+
+
+
+
+    private boolean validatePassword(String password){
+        final String PASSWORD_PATTERN = "^.{6,}$";
+        Pattern pattern = Pattern.compile(PASSWORD_PATTERN);
+        Matcher matcher = pattern.matcher(password);
+
+        return matcher.matches();
+    }
+
+    private void updatePassword(String hashedEmail, String newPassword) throws InvalidAlgorithmParameterException, NoSuchPaddingException, IllegalBlockSizeException, NoSuchAlgorithmException, InvalidKeySpecException, BadPaddingException, InvalidKeyException {
+        SharedPreferences sharedPreferences = getSharedPreferences(SHARED_NAME_CREDENTIALS, MODE_PRIVATE);
+        SharedPreferences.Editor editor = sharedPreferences.edit();
+
+        byte[] newSalt = Utility.generateSalt();
+        String newSaltString = Base64.getEncoder().encodeToString(newSalt);
+        editor.putString("salt_" + hashedEmail, newSaltString);
+
+        String hashedNewPassword = Utility.hashCredential(newPassword, newSalt, 1000);
+        editor.putString("user_" + hashedEmail, hashedNewPassword);
+        editor.apply();
+
+        KEY = newPassword;
+        saveNotesToPreferences("");
+    }
+
+    private boolean validateOldPassword(String hashedEmail, String oldPassword){
+        byte[] salt = getSaltForUser(hashedEmail, false);
+        String hashedOldPassword = Utility.hashCredential(oldPassword, salt, 1000);
+        String hashedCorrectPassword = gerPasswrodHashFromShared(hashedEmail);
+
+        assert hashedOldPassword != null;
+        return hashedOldPassword.equals(hashedCorrectPassword);
+    }
+
+    private byte[] getSaltForUser(String hashedEmail, boolean salt2){
+        SharedPreferences sharedPreferences = getSharedPreferences(SHARED_NAME_CREDENTIALS, MODE_PRIVATE);
+        String saltFromData;
+
+        if (salt2){
+             saltFromData = sharedPreferences.getString("salt_2_" + hashedEmail, "err");
+        }
+        else {
+             saltFromData = sharedPreferences.getString("salt_" + hashedEmail, "err");
+        }
+        return Base64.getDecoder().decode(saltFromData);
+
+    }
+
+    private String gerPasswrodHashFromShared(String hashedEmail){
+        SharedPreferences sharedPreferences = getSharedPreferences(SHARED_NAME_CREDENTIALS, MODE_PRIVATE);
+        return sharedPreferences.getString("user_" + hashedEmail, "err");
+    }
+
+
+
+
+    private void saveNotesToPreferences(String mode) throws NoSuchAlgorithmException, InvalidKeySpecException, InvalidAlgorithmParameterException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, InvalidKeyException {
+        SharedPreferences sharedPreferences = getSharedPreferences(SHARED_NAME_NOTES, MODE_PRIVATE);
         SharedPreferences.Editor editor = sharedPreferences.edit();
         if (mode.equals("del")){
             int noteCount = sharedPreferences.getInt("notecount_"+HASHED_EMAIL, 0);
@@ -288,7 +389,7 @@ public class MainActivity extends AppCompatActivity {
         editor.putInt("notecount_" + HASHED_EMAIL, noteList.size());
         for(int i=0; i<noteList.size(); i++){
             Note note = noteList.get(i);
-            editor.putString(i + "_title_" + HASHED_EMAIL, encryptCesar(note.getTitle(), 2));
+            editor.putString(i + "_title_" + HASHED_EMAIL, encrypt("AES/CBC/PKCS5Padding", note.getTitle(), getKeyFromPassword(KEY, getSaltForUser(HASHED_EMAIL, true)), generateIv()));
             editor.putString(i + "_content_" + HASHED_EMAIL, note.getContent());
 
         }
@@ -296,9 +397,18 @@ public class MainActivity extends AppCompatActivity {
         editor.apply();
     }
 
+    public static SecretKey getKeyFromPassword(String password, byte[] salt) throws NoSuchAlgorithmException, InvalidKeySpecException {
 
-    private void loadNotesFromPreferencesToList(){
+        SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
-        SharedPreferences sharedPreferences = getSharedPreferences(SHARED_NOTES_NAME, MODE_PRIVATE);
+        KeySpec spec = new PBEKeySpec(password.toCharArray(), salt, 65536, 256);
+        SecretKey secret = new SecretKeySpec(factory.generateSecret(spec).getEncoded(), "AES");
+
+        return secret;
+    }
+
+
+    private void loadNotesFromPreferencesToList() throws NoSuchAlgorithmException, InvalidKeySpecException, InvalidAlgorithmParameterException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, InvalidKeyException {
+        SharedPreferences sharedPreferences = getSharedPreferences(SHARED_NAME_NOTES, MODE_PRIVATE);
         int noteCount = sharedPreferences.getInt("notecount_" + HASHED_EMAIL, 0);
 
         for(int i=0; i<noteCount; i++){
@@ -306,13 +416,44 @@ public class MainActivity extends AppCompatActivity {
             String content = sharedPreferences.getString(i + "_content_" + HASHED_EMAIL, "");
 
             Note note = new Note();
-            note.setTitle(decryptCesar(title, 2));
+            note.setTitle(decrypt("AES/CBC/PKCS5Padding", title, getKeyFromPassword(KEY, getSaltForUser(HASHED_EMAIL, true)), generateIv()) );
             note.setContent(content);
 
             noteList.add(note);
         }
     }
 
+    private static final byte[] FIXED_IV = {
+            0x01, 0x02, 0x03, 0x04,
+            0x05, 0x06, 0x07, 0x08,
+            0x09, 0x0A, 0x0B, 0x0C,
+            0x0D, 0x0E, 0x0F, 0x10
+    };
+
+    public static IvParameterSpec generateIv() {
+        return new IvParameterSpec(Arrays.copyOf(FIXED_IV, FIXED_IV.length));
+    }
+
+    public static String encrypt(String algorithm, String input, SecretKey key, IvParameterSpec iv) throws
+            NoSuchPaddingException, NoSuchAlgorithmException, InvalidAlgorithmParameterException, InvalidKeyException,
+            BadPaddingException, IllegalBlockSizeException {
+
+        Cipher cipher = Cipher.getInstance(algorithm);
+        cipher.init(Cipher.ENCRYPT_MODE, key, iv);
+        byte[] cipherText = cipher.doFinal(input.getBytes());
+        return Base64.getEncoder().encodeToString(cipherText);
+    }
+
+    public static String decrypt(String algorithm, String cipherText, SecretKey key, IvParameterSpec iv) throws NoSuchPaddingException, NoSuchAlgorithmException,
+            InvalidAlgorithmParameterException, InvalidKeyException,
+            BadPaddingException, IllegalBlockSizeException{
+
+        Cipher cipher = Cipher.getInstance(algorithm);
+        cipher.init(Cipher.DECRYPT_MODE, key, iv);
+        byte[] plainText = cipher.doFinal(Base64.getDecoder().decode(cipherText));
+        return new String(plainText);
+    }
+
 
     private void createNoteView(final Note note){
         View noteView = getLayoutInflater().inflate(R.layout.note_item, null);
@@ -323,31 +464,19 @@ public class MainActivity extends AppCompatActivity {
         noteTitleTextView.setText(note.getTitle());
         noteContentTextView.setText(note.getContent());
 
-        deleteNoteDutton.setOnClickListener(view -> {
+        deleteNoteDutton.setOnClickListener(view -> showDeleteDialog(note));
-            showDeleteDialog(note);
-        });
 
-        noteView.setOnLongClickListener(new View.OnLongClickListener() {
+        noteView.setOnLongClickListener(view -> {
-            @Override
+            showEditNoteDialog(note);
-            public boolean onLongClick(View view) {
+            return true;
-                showEditNoteDialog(note);
-                return true;
-            }
         });
 
         notesContainer.addView(noteView);
     }
 
-    private void showDeleteDialog(final Note note){
-        AlertDialog.Builder builder = new AlertDialog.Builder(this);
-        builder.setTitle("Delete this note");
-        builder.setMessage("Are you sure you want to delete it?");
-        builder.setPositiveButton("Delete", (dialogInterface, i) -> deleteNoteAndRefresh(note));
-        builder.setNegativeButton("Cancel", null);
-        builder.show();
-    }
 
-    private void deleteNoteAndRefresh(Note note){
+
+    private void deleteNoteAndRefresh(Note note) throws InvalidAlgorithmParameterException, NoSuchPaddingException, IllegalBlockSizeException, NoSuchAlgorithmException, InvalidKeySpecException, BadPaddingException, InvalidKeyException {
         noteList.remove(note);
         saveNotesToPreferences("del");
         refreshNotesView();
@@ -364,94 +493,6 @@ public class MainActivity extends AppCompatActivity {
         }
     }
 
-    private static final byte[] CONSTANT_IV = new byte[] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
-
-    // Function to encrypt a message using AES in CBC mode with a constant IV
-    public static String encrypt(String data, String key) {
-        try {
-            Cipher cipher = Cipher.getInstance(TRANSFORMATION);
-
-            // Use the constant IV
-            IvParameterSpec ivParameterSpec = new IvParameterSpec(CONSTANT_IV);
-
-            // Create a SecretKeySpec using the provided key
-            SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(), ALGORITHM);
-
-            // Initialize the cipher for encryption
-            cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec, ivParameterSpec);
-
-            // Encrypt the data
-            byte[] encryptedBytes = cipher.doFinal(data.getBytes());
-
-            // Combine IV and encrypted data for later decryption
-            byte[] combined = new byte[CONSTANT_IV.length + encryptedBytes.length];
-            System.arraycopy(CONSTANT_IV, 0, combined, 0, CONSTANT_IV.length);
-            System.arraycopy(encryptedBytes, 0, combined, CONSTANT_IV.length, encryptedBytes.length);
-
-            // Base64 encode the result for easy storage and transmission
-            return Base64.getEncoder().encodeToString(combined);
-
-        } catch (Exception e) {
-            e.printStackTrace();
-            return null;
-        }
-    }
-
-    // Function to decrypt a message using AES in CBC mode with a constant IV
-    public static String decrypt(String encryptedData, String key) {
-        try {
-            Cipher cipher = Cipher.getInstance(TRANSFORMATION);
-
-            // Decode the Base64-encoded input
-            byte[] combined = Base64.getDecoder().decode(encryptedData);
-
-            // Extract IV from the combined data
-            byte[] iv = new byte[CONSTANT_IV.length];
-            System.arraycopy(combined, 0, iv, 0, CONSTANT_IV.length);
-            IvParameterSpec ivParameterSpec = new IvParameterSpec(iv);
-
-            // Create a SecretKeySpec using the provided key
-            SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(), ALGORITHM);
-
-            // Initialize the cipher for decryption
-            cipher.init(Cipher.DECRYPT_MODE, secretKeySpec, ivParameterSpec);
-
-            // Decrypt the data
-            byte[] decryptedBytes = cipher.doFinal(combined, CONSTANT_IV.length, combined.length - CONSTANT_IV.length);
-
-            return new String(decryptedBytes);
-
-        } catch (Exception e) {
-            e.printStackTrace();
-            return null;
-        }
-    }
-
-    // Function to encrypt a message using Caesar Cipher
-    public static String encryptCesar(String message, int key) {
-        StringBuilder encryptedMessage = new StringBuilder();
-
-        for (char character : message.toCharArray()) {
-            if (Character.isLetter(character)) {
-                char base = Character.isUpperCase(character) ? 'A' : 'a';
-                char encryptedChar = (char) ((character - base + key) % 26 + base);
-                encryptedMessage.append(encryptedChar);
-            } else {
-                // Keep non-alphabetic characters unchanged
-                encryptedMessage.append(character);
-            }
-        }
-
-        return encryptedMessage.toString();
-    }
-
-    // Function to decrypt a message using Caesar Cipher with a key
-    public static String decryptCesar(String encryptedMessage, int key) {
-        return encryptCesar(encryptedMessage, 26 - (key % 26)); // Decryption is equivalent to shifting in the opposite direction
-    }
-
-
-