Apache Shiro(三)-登錄認證和權限管理MD5加密

md5 加密

在前面的例子里，用戶密碼是明文的，這樣是有巨大風險的，一旦泄露，就不好了。
所以，通常都會采用非對稱加密，什么是非對稱呢？就是不可逆的，而 md5 就是這樣一個算法.
如代碼所示 123 用 md5 加密后，得到字符串： 202CB962AC59075B964B07152D234B70
這個字符串，卻無法通過計算，反過來得到源密碼是 123.
這個加密后的字符串就存在數據庫里了，下次用戶再登陸，輸入密碼 123， 同樣用md5 加密后，再和這個字符串一比較，就知道密碼是否正確了。
如此這樣，既能保證用戶密碼校驗的功能，又能保證不暴露密碼。

package com.how2java;
 
import org.apache.shiro.crypto.hash.Md5Hash;
 
public class TestEncryption {
 
    public static void main(String[] args) {
        String password = "123";
        String encodedPassword = new Md5Hash(password).toString();
         
        System.out.println(encodedPassword);
    }
}

這個大家都用過，沒啥好說的。

---

 

鹽

面講了md5加密，但是md5加密又有一些缺陷:
1. 如果我的密碼是 123,你的也是 123, 那么md5的值是一樣的，那么通過比較加密后的字符串，我就可以反推過來，原來你的密碼也是123.
2. 與上述相同，雖然 md5 不可逆，但是我可以窮舉法呀，我把特別常用的100萬或者更多個密碼的 md5 值記錄下來，比如12345的，abcde的。 相當一部分人用的密碼也是這些，那么只要到數據庫里一找，也很快就可以知道原密碼是多少了。這樣看上去也就破解了，至少一部分沒有想象中那么安全吧。
為了解決這個問題，引入了鹽的概念。 鹽是什么意思呢？ 比如炒菜，直接使用md5，就是對食材（源密碼）進行炒菜，因為食材是一樣的，所以炒出來的味道都一樣，可是如果加了不同分量的鹽，那么即便食材一樣，炒出來的味道也就不一樣了。

所以，雖然每次 123 md5 之后都是202CB962AC59075B964B07152D234B70，但是 我加上鹽，即 123+隨機數，那么md5值不就不一樣了嗎？ 這個隨機數，就是鹽，而這個隨機數也會在數據庫里保存下來，每個不同的用戶，隨機數也是不一樣的。
再就是加密次數，加密一次是202CB962AC59075B964B07152D234B70，我可以加密兩次呀，就是另一個數了。 而黑客即便是拿到了加密后的密碼，如果不知道到底加密了多少次，也是很難辦的。

在代碼里就演示了，如何用Shiro自帶的工具類，做生成鹽，兩次md5的做法，如圖所示得到一串機密都很高的密文。

 

 

package com.how2java;
 
import org.apache.shiro.crypto.SecureRandomNumberGenerator;
import org.apache.shiro.crypto.hash.SimpleHash;
 
public class TestEncryption {
 
    public static void main(String[] args) {
        String password = "123";
        String salt = new SecureRandomNumberGenerator().nextBytes().toString();
        int times = 2;
        String algorithmName = "md5";
         
        String encodedPassword = new SimpleHash(algorithmName,password,salt,times).toString();
         
        System.out.printf("原始密碼是 %s , 鹽是： %s, 運算次數是： %d, 運算出來的密文是：%s ",password,salt,times,encodedPassword);
         
    }
}

數據庫調整

有了以上基礎，那么就可以開始在原來的教程里加入對加密的支持了。 在開始之前，要修改一下user表，加上鹽 字段: salt。
因鹽是隨機數，得保留下來，如果不知道鹽巴是多少，我們也就沒法判斷密碼是否正確了。

alter table user add (salt varchar(100) )

 User

 給user實體類添加一個salt屬性，並提供getter和setter方法。

package com.how2java;

public class User {

    private int id;
    private String name;
    private String salt;
    private String password;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getSalt() {
        return salt;
    }
    public void setSalt(String salt) {
        this.salt = salt;
    }
    
    
}

DAO

增加兩個方法 createUser，getUser
createUser 用於注冊，並且在注冊的時候，將用戶提交的密碼加密
getUser 用於取出用戶信息，其中不僅僅包括加密后的密碼，還包括鹽

package com.how2java;
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.HashSet;
import java.util.Set;
 
import org.apache.shiro.crypto.SecureRandomNumberGenerator;
import org.apache.shiro.crypto.hash.SimpleHash;
 
public class DAO {
    public DAO() {
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
 
    public Connection getConnection() throws SQLException {
        return DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/shiro?characterEncoding=UTF-8", "root",
                "admin");
    }
     
    public String createUser(String name, String password) {
         
        String sql = "insert into user values(null,?,?,?)";
         
        String salt = new SecureRandomNumberGenerator().nextBytes().toString(); //鹽量隨機
        String encodedPassword= new SimpleHash("md5",password,salt,2).toString();
         
        try (Connection c = getConnection(); PreparedStatement ps = c.prepareStatement(sql);) {
             
            ps.setString(1, name);
            ps.setString(2, encodedPassword);
            ps.setString(3, salt);
            ps.execute();
        } catch (SQLException e) {
 
            e.printStackTrace();
        }
        return null;       
         
    }
 
    public String getPassword(String userName) {
        String sql = "select password from user where name = ?";
        try (Connection c = getConnection(); PreparedStatement ps = c.prepareStatement(sql);) {
             
            ps.setString(1, userName);
             
            ResultSet rs = ps.executeQuery();
 
            if (rs.next())
                return rs.getString("password");
 
        } catch (SQLException e) {
 
            e.printStackTrace();
        }
        return null;
    }
    public User getUser(String userName) {
        User user = null;
        String sql = "select * from user where name = ?";
        try (Connection c = getConnection(); PreparedStatement ps = c.prepareStatement(sql);) {
             
            ps.setString(1, userName);
             
            ResultSet rs = ps.executeQuery();
             
            if (rs.next()) {
                user = new User();
                user.setId(rs.getInt("id"));
                user.setName(rs.getString("name"));
                user.setPassword(rs.getString("password"));
                user.setSalt(rs.getString("salt"));
            }
             
        } catch (SQLException e) {
             
            e.printStackTrace();
        }
        return user;
    }
     
    public Set<String> listRoles(String userName) {
         
        Set<String> roles = new HashSet<>();
        String sql = "select r.name from user u "
                + "left join user_role ur on u.id = ur.uid "
                + "left join Role r on r.id = ur.rid "
                + "where u.name = ?";
        try (Connection c = getConnection(); PreparedStatement ps = c.prepareStatement(sql);) {
            ps.setString(1, userName);
            ResultSet rs = ps.executeQuery();
             
            while (rs.next()) {
                roles.add(rs.getString(1));
            }
             
        } catch (SQLException e) {
             
            e.printStackTrace();
        }
        return roles;
    }
    public Set<String> listPermissions(String userName) {
        Set<String> permissions = new HashSet<>();
        String sql =
            "select p.name from user u "+
            "left join user_role ru on u.id = ru.uid "+
            "left join role r on r.id = ru.rid "+
            "left join role_permission rp on r.id = rp.rid "+
            "left join permission p on p.id = rp.pid "+
            "where u.name =?";
         
        try (Connection c = getConnection(); PreparedStatement ps = c.prepareStatement(sql);) {
             
            ps.setString(1, userName);
             
            ResultSet rs = ps.executeQuery();
             
            while (rs.next()) {
                permissions.add(rs.getString(1));
            }
             
        } catch (SQLException e) {
             
            e.printStackTrace();
        }
        return permissions;
    }
}

DatabaseRealm

修改 DatabaseRealm，把用戶通過 UsernamePasswordToken 傳進來的密碼，以及數據庫里取出來的 salt 進行加密，加密之后再與數據庫里的密文進行比較，判斷用戶是否能夠通過驗證。

package com.how2java;
 
import java.util.Set;
 
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.crypto.hash.SimpleHash;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.util.ByteSource;
 
public class DatabaseRealm extends AuthorizingRealm {
 
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
         
        //能進入到這里，表示賬號已經通過驗證了
        String userName =(String) principalCollection.getPrimaryPrincipal();
        //通過DAO獲取角色和權限
        Set<String> permissions = new DAO().listPermissions(userName);
        Set<String> roles = new DAO().listRoles(userName);
         
        //授權對象
        SimpleAuthorizationInfo s = new SimpleAuthorizationInfo();
        //把通過DAO獲取到的角色和權限放進去
        s.setStringPermissions(permissions);
        s.setRoles(roles);
        return s;
    }
 
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        //獲取賬號密碼
        UsernamePasswordToken t = (UsernamePasswordToken) token;
        String userName= token.getPrincipal().toString();
        String password =new String(t.getPassword());
        //獲取數據庫中的密碼
         
        User user = new DAO().getUser(userName);
        String passwordInDB = user.getPassword();
        String salt = user.getSalt();
        String passwordEncoded = new SimpleHash("md5",password,salt,2).toString();
         
        if(null==user || !passwordEncoded.equals(passwordInDB))
            throw new AuthenticationException();
         
        //認證信息里存放賬號密碼, getName() 是當前Realm的繼承方法,通常返回當前類名 :databaseRealm
        SimpleAuthenticationInfo a = new SimpleAuthenticationInfo(userName,password,getName());
        return a;
    }
 
}

shiro.ini

[main]
credentialsMatcher=org.apache.shiro.authc.credential.HashedCredentialsMatcher
credentialsMatcher.hashAlgorithmName=md5
credentialsMatcher.hashIterations=2
credentialsMatcher.storedCredentialsHexEncoded=true
 
databaseRealm=com.how2java.DatabaseRealm
databaseRealm.credentialsMatcher=$credentialsMatcher
securityManager.realms=$databaseRealm

 

TestShiro

進行賬號密碼驗證測試。 注意，測試之前要先釋放注釋，以執行一次注冊用戶行為，如果不注冊，后面肯定是不能驗證通過的，因為數據庫里沒有嘛。

new DAO().createUser("tom", "123");

package com.how2java;
 
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.util.Factory;
 
public class TestShiro {
    public static void main(String[] args) {
        //這里要釋放注釋，先注冊一個用戶
//      new DAO().createUser("tom", "123");
         
        User user = new User();
        user.setName("tom");
        user.setPassword("123");
         
        if(login(user))
            System.out.println("登錄成功");
        else
            System.out.println("登錄失敗");
         
    }
     
    private static boolean hasRole(User user, String role) {
        Subject subject = getSubject(user);
        return subject.hasRole(role);
    }
     
    private static boolean isPermitted(User user, String permit) {
        Subject subject = getSubject(user);
        return subject.isPermitted(permit);
    }
 
    private static Subject getSubject(User user) {
        //加載配置文件，並獲取工廠
        Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro.ini");
        //獲取安全管理者實例
        SecurityManager sm = factory.getInstance();
        //將安全管理者放入全局對象
        SecurityUtils.setSecurityManager(sm);
        //全局對象通過安全管理者生成Subject對象
        Subject subject = SecurityUtils.getSubject();
         
        return subject;
    }
     
    private static boolean login(User user) {
        Subject subject= getSubject(user);
        //如果已經登錄過了，退出
        if(subject.isAuthenticated())
            subject.logout();
         
        //封裝用戶的數據
        UsernamePasswordToken token = new UsernamePasswordToken(user.getName(), user.getPassword());
        try {
            //將用戶的數據token 最終傳遞到Realm中進行對比
            subject.login(token);
        } catch (AuthenticationException e) {
            //驗證錯誤
            return false;
        }              
         
        return subject.isAuthenticated();
    }
     
}

 

最后

代碼下載地址：https://gitee.com/fengyuduke/my_open_resources/blob/master/shiro-md5.rar