title: how to encrypt password using spring hibernate in java
body: <p>So my problem is this, I have a jsp that has a register button on every navigation page,And i want to encrypt my password using spring and hibernate,but unfortunately i don't know how.. even using spring and hibernate i don't actually get how it works. and also i have a Encryption class i am thinking about encrypting it inside my Users class but i know when logging in it will cause a problem... here is my code by the way</p>
  
  <p>code in controller</p>
  
  <pre><code>@Controller
  @RequestMapping("/ecomplain")
  public class ComplainController 
  {
    @Autowired
    private UserService userService;
    @Autowired
    private ComplainService complainService;
  
    @RequestMapping(value = "/Homepage")
    public String showHomepage(Map&lt;String, Object&gt; map) 
   {
     map.put("users", new Users());
     return "/ecomplain/Homepage";
   }
  
   @RequestMapping(value = "/ComplaintForm")
   public String showComplainForm(Map&lt;String, Object&gt; map) 
   {
     map.put("users", new Users());
     map.put("complains", new Complains());
     return "/ecomplain/ComplaintForm";
   }
  
   @RequestMapping(value = "/CrimeForum")
   public String showCrimeForum(Map&lt;String, Object&gt; map) 
   {
      map.put("users", new Users());
      map.put("complains", new Complains());
      map.put("complainList", complainService.listComplains());
      return "/ecomplain/CrimeForum";
   }
  
   @RequestMapping(value = "/About")
   public String showAbout(Map&lt;String, Object&gt; map) 
   {
      map.put("users", new Users());
      return "/ecomplain/About";
   }
  
   @RequestMapping("/get/{userId}")
   public String getUsers(@PathVariable Long userId, Map&lt;String, Object&gt; map) 
   {
     Users users = userService.getUsers(userId);
     map.put("users", users);
  
     return "/ecomplain/CreateUserForm";
   }
  
   @RequestMapping("/getComplain/{complainId}")
   public String getComplains(@PathVariable Long complainId, Map&lt;String, Object&gt; map) 
   {
     Complains complains = complainService.getComplains(complainId);
     map.put("complains", complains);
  
     return "/ecomplain/ComplainDetails";
   }
  
   @RequestMapping(value = "/save", method = RequestMethod.POST)
   public String saveUsers(@ModelAttribute("users") Users users, BindingResult result)
   {
     userService.saveUsers(users);
     return "redirect:listBooks";
   }
  
   @RequestMapping(value = "/savecomplain", method = RequestMethod.POST)
   public String saveComplains(@ModelAttribute("complains") Complains complains, BindingResult result) 
   {
     complainService.saveComplains(complains);
     return "redirect:ComplaintForm";
   }
  
   @RequestMapping("/delete/{userId}")
   public String deleteUsers(@PathVariable("userId") Long userId) 
   {
     userService.deleteUsers(userId);
     return "redirect:/ecomplain/Homepage";
   }
  
   @RequestMapping("/delete/{complainId}")
   public String deleteComplains(@PathVariable("complainId") Long complainId) 
   {
     complainService.deleteComplains(complainId);
     return "redirect:/ecomplain/Homepage";
   }
  }
  </code></pre>
  
  <p>Users class</p>
  
  <pre><code>@Entity
  @Table(name = "users")
  public class Users
  {
    private Long userId;
    private String email;
    private String username;
    private String password;
    private String location;
  
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    public Long getUserId() 
   {
      return userId;
   }
  
   @Column(nullable = false)
   public String getEmail() 
   {
      return email;
   }
  
   @Column(nullable = false, unique = true)
   public String getUsername() 
   {
      return username;
   }
  
   @Column(nullable = false)
   public String getPassword() 
   {
      return password;
   } 
  
   @Column(nullable = false)
   public String getLocation() 
   {
      return location;
   }
  
   public void setUserId(Long userId) 
   {
      this.userId = userId;
   }
  
   public void setEmail(String email) 
   {
      this.email = email;
   }
  
   public void setUsername(String username) 
   {
      this.username = username;
   }
  
   public void setPassword(String password)
   {
      this.password = password;
   }
  
   public void setLocation(String location)
   {
      this.location = location;
   }
  }
  </code></pre>
  
  <p>UsersDao</p>
  
  <pre><code>public interface UsersDao 
  {
    public void saveUsers(Users users);
    public List&lt;Users&gt; listUsers();
    public Users getUsers(Long userId);
    public void deleteUsers(Long userId);
  }
  </code></pre>
  
  <p>UsersDaoImpl</p>
  
  <pre><code>@Repository
  public class UsersDaoImpl implements UsersDao 
  {
    @Autowired
    private SessionFactory sessionFactory;
  
    public void saveUsers(Users users) 
    {
       getSession().merge(users);
    }
  
    public List&lt;Users&gt; listUsers() 
    {
      return getSession().createCriteria(Users.class).list();
    }
  
    public Users getUsers(Long userId) 
    {
       return (Users) getSession().get(Users.class, userId);
    }
  
    public void deleteUsers(Long userId) 
    {
      Users users = getUsers(userId);
  
      if (null != users) 
      {
         getSession().delete(users);
      }
    }
  
    private Session getSession() 
    {
       Session sess = getSessionFactory().getCurrentSession();
       if (sess == null) 
       {
         sess = getSessionFactory().openSession();
       }
       return sess;
    }
  
    private SessionFactory getSessionFactory() 
   {
      return sessionFactory;
   }
  }
  </code></pre>
  
  <p>and here is my Encryption class that i want to use</p>
  
  <pre><code>public class Encryption 
  {
     public static final String PBKDF2_ALGORITHM = "PBKDF2WithHmacSHA1";
  
     public static final int SALT_BYTE_SIZE = 24;
     public static final int HASH_BYTE_SIZE = 24;
     public static final int PBKDF2_ITERATIONS = 1000;
  
     public static final int ITERATION_INDEX = 0;
     public static final int SALT_INDEX = 1;
     public static final int PBKDF2_INDEX = 2;
  
     public static String createHash(String password) throws NoSuchAlgorithmException,      InvalidKeySpecException
     {
       return createHash(password.toCharArray());
     }
  
    public static String createHash(char[] password) throws NoSuchAlgorithmException, InvalidKeySpecException
    {
  
       SecureRandom random = new SecureRandom();
       byte[] salt = new byte[SALT_BYTE_SIZE];
       random.nextBytes(salt);
       byte[] hash = pbkdf2(password, salt, PBKDF2_ITERATIONS, HASH_BYTE_SIZE);
       return PBKDF2_ITERATIONS + ":" + toHex(salt) + ":" +  toHex(hash);
    }
  
  
    public static boolean validatePassword(String password, String correctHash) throws  NoSuchAlgorithmException, InvalidKeySpecException
    {
       return validatePassword(password.toCharArray(), correctHash);
    }
  
    public static boolean validatePassword(char[] password, String correctHash) throws NoSuchAlgorithmException, InvalidKeySpecException
    {
       String[] params = correctHash.split(":");
       int iterations = Integer.parseInt(params[ITERATION_INDEX]);
       byte[] salt = fromHex(params[SALT_INDEX]);
       byte[] hash = fromHex(params[PBKDF2_INDEX]);   
       byte[] testHash = pbkdf2(password, salt, iterations, hash.length);
       return slowEquals(hash, testHash);
    }
  
    private static boolean slowEquals(byte[] a, byte[] b)
    {
       int diff = a.length ^ b.length;
       for(int i = 0; i &lt; a.length &amp;&amp; i &lt; b.length; i++)
          diff |= a[i] ^ b[i];
       return diff == 0;
    }
  
    private static byte[] pbkdf2(char[] password, byte[] salt, int iterations, int bytes) throws NoSuchAlgorithmException, InvalidKeySpecException
    {
       PBEKeySpec spec = new PBEKeySpec(password, salt, iterations, bytes * 8);
       SecretKeyFactory skf = SecretKeyFactory.getInstance(PBKDF2_ALGORITHM);
       return skf.generateSecret(spec).getEncoded();
    }
  
    private static byte[] fromHex(String hex)
    {
       byte[] binary = new byte[hex.length() / 2];
       for(int i = 0; i &lt; binary.length; i++)
       {
          binary[i] = (byte)Integer.parseInt(hex.substring(2*i, 2*i+2), 16);
       }
       return binary;
    }
  
    private static String toHex(byte[] array)
    {
      BigInteger bi = new BigInteger(1, array);
      String hex = bi.toString(16);
      int paddingLength = (array.length * 2) - hex.length();
      if(paddingLength &gt; 0) 
         return String.format("%0" + paddingLength + "d", 0) + hex;
      else
         return hex;
    }
  
    public String saltedPass(String password) 
    {
       String hash = "";
        try 
        {
           hash = createHash(password);
        } 
  
        catch (NoSuchAlgorithmException e) 
        {
           e.printStackTrace();
        } 
  
        catch (InvalidKeySpecException e) 
        {
           e.printStackTrace();
        }
        return hash;
    }
  
    public boolean validation(String password, String hash) 
    {
        try 
        {
            if (validatePassword(password, hash)) 
            {
              System.out.println("CORRECT PASSWORD!");
              return true;
            }
        }  
  
        catch (Exception ex) 
        {
            System.out.println("ERROR: " + ex);
        }
        return false;
    }
  }
  </code></pre>
  
  <p>i hope someone can help me.. even a small idea can help me</p>