CAS单点登陆密码加密处理

最新推荐文章于 2024-08-30 02:08:10 发布
最新推荐文章于 2024-08-30 02:08:10 发布
阅读量4.7k 收藏
点赞数 1
分类专栏： SSO单点登陆 文章标签： SSO单点登陆 CAS加密处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42549122/article/details/90315142
版权
在当前的网络环境下,使用未加密的密码进行储存,极易遭受破解.所以在现在的开发中,所有注重安全的网站都会进行哈希算法加密处理,常用的哈希算法由MD5加密或SHA1加密处理,本文采用MD5进行演示,有兴趣的小伙伴可以自己尝试SHA1加密.为了防止用户输入简单的密码123456等,被轻易恶意破解,所以还要对密码进行加盐处理,根据自己网站的特殊规律设置,使密码加盐

1.首先我们需要把MD5.class文件导入项目,下面附MD5.class代码,仅供参考

public class MD5code {
    static final int S11 = 7;

    static final int S12 = 12;

    static final int S13 = 17;

    static final int S14 = 22;

    static final int S21 = 5;

    static final int S22 = 9;

    static final int S23 = 14;

    static final int S24 = 20;

    static final int S31 = 4;

    static final int S32 = 11;

    static final int S33 = 16;

    static final int S34 = 23;

    static final int S41 = 6;

    static final int S42 = 10;

    static final int S43 = 15;

    static final int S44 = 21;

    static final byte[] PADDING = { -128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0 };

    private long[] state = new long[4];// state (ABCD)

    private long[] count = new long[2];// number of bits, modulo 2^64 (lsb

    // first)

    private byte[] buffer = new byte[64]; // input buffer


    public String digestHexStr;

    private byte[] digest = new byte[16];

    public String getMD5ofStr(String inbuf) {
        md5Init();
        md5Update(inbuf.getBytes(), inbuf.length());
        md5Final();
        digestHexStr = "";
        for (int i = 0; i < 16; i++) {
            digestHexStr += byteHEX(digest[i]);
        }
        return digestHexStr;
    }

    public MD5code() {
        md5Init();
        return;
    }

    private void md5Init() {
        count[0] = 0L;
        count[1] = 0L;
        // /* Load magic initialization constants.
        state[0] = 0x67452301L;
        state[1] = 0xefcdab89L;
        state[2] = 0x98badcfeL;
        state[3] = 0x10325476L;
        return;
    }

    private long F(long x, long y, long z) {
        return (x & y) | ((~x) & z);
    }

    private long G(long x, long y, long z) {
        return (x & z) | (y & (~z));
    }

    private long H(long x, long y, long z) {
        return x ^ y ^ z;
    }

    private long I(long x, long y, long z) {
        return y ^ (x | (~z));
    }

    private long FF(long a, long b, long c, long d, long x, long s, long ac) {
        a += F(b, c, d) + x + ac;
        a = ((int) a << s) | ((int) a >>> (32 - s));
        a += b;
        return a;
    }

    private long GG(long a, long b, long c, long d, long x, long s, long ac) {
        a += G(b, c, d) + x + ac;
        a = ((int) a << s) | ((int) a >>> (32 - s));
        a += b;
        return a;
    }

    private long HH(long a, long b, long c, long d, long x, long s, long ac) {
        a += H(b, c, d) + x + ac;
        a = ((int) a << s) | ((int) a >>> (32 - s));
        a += b;
        return a;
    }

    private long II(long a, long b, long c, long d, long x, long s, long ac) {
        a += I(b, c, d) + x + ac;
        a = ((int) a << s) | ((int) a >>> (32 - s));
        a += b;
        return a;
    }

    private void md5Update(byte[] inbuf, int inputLen) {
        int i, index, partLen;
        byte[] block = new byte[64];
        index = (int) (count[0] >>> 3) & 0x3F;
        // /* Update number of bits */
        if ((count[0] += (inputLen << 3)) < (inputLen << 3))
            count[1]++;
        count[1] += (inputLen >>> 29);
        partLen = 64 - index;
        // Transform as many times as possible.
        if (inputLen >= partLen) {
            md5Memcpy(buffer, inbuf, index, 0, partLen);
            md5Transform(buffer);
            for (i = partLen; i + 63 < inputLen; i += 64) {
                md5Memcpy(block, inbuf, 0, i, 64);
                md5Transform(block);
            }
            index = 0;
        } else
            i = 0;
        // /* Buffer remaining input */
        md5Memcpy(buffer, inbuf, index, i, inputLen - i);
    }

    private void md5Final() {
        byte[] bits = new byte[8];
        int index, padLen;
        // /* Save number of bits */
        Encode(bits, count, 8);
        // /* Pad out to 56 mod 64.
        index = (int) (count[0] >>> 3) & 0x3f;
        padLen = (index < 56) ? (56 - index) : (120 - index);
        md5Update(PADDING, padLen);
        // /* Append length (before padding) */
        md5Update(bits, 8);
        // /* Store state in digest */
        Encode(digest, state, 16);
    }

    private void md5Memcpy(byte[] output, byte[] input, int outpos, int inpos,
                           int len) {
        int i;
        for (i = 0; i < len; i++)
            output[outpos + i] = input[inpos + i];
    }

    private void md5Transform(byte block[]) {
        long a = state[0], b = state[1], c = state[2], d = state[3];
        long[] x = new long[16];
        Decode(x, block, 64);
        /* Round 1 */
        a = FF(a, b, c, d, x[0], S11, 0xd76aa478L); /* 1 */
        d = FF(d, a, b, c, x[1], S12, 0xe8c7b756L); /* 2 */
        c = FF(c, d, a, b, x[2], S13, 0x242070dbL); /* 3 */
        b = FF(b, c, d, a, x[3], S14, 0xc1bdceeeL); /* 4 */
        a = FF(a, b, c, d, x[4], S11, 0xf57c0fafL); /* 5 */
        d = FF(d, a, b, c, x[5], S12, 0x4787c62aL); /* 6 */
        c = FF(c, d, a, b, x[6], S13, 0xa8304613L); /* 7 */
        b = FF(b, c, d, a, x[7], S14, 0xfd469501L); /* 8 */
        a = FF(a, b, c, d, x[8], S11, 0x698098d8L); /* 9 */
        d = FF(d, a, b, c, x[9], S12, 0x8b44f7afL); /* 10 */
        c = FF(c, d, a, b, x[10], S13, 0xffff5bb1L); /* 11 */
        b = FF(b, c, d, a, x[11], S14, 0x895cd7beL); /* 12 */
        a = FF(a, b, c, d, x[12], S11, 0x6b901122L); /* 13 */
        d = FF(d, a, b, c, x[13], S12, 0xfd987193L); /* 14 */
        c = FF(c, d, a, b, x[14], S13, 0xa679438eL); /* 15 */
        b = FF(b, c, d, a, x[15], S14, 0x49b40821L); /* 16 */
        /* Round 2 */
        a = GG(a, b, c, d, x[1], S21, 0xf61e2562L); /* 17 */
        d = GG(d, a, b, c, x[6], S22, 0xc040b340L); /* 18 */
        c = GG(c, d, a, b, x[11], S23, 0x265e5a51L); /* 19 */
        b = GG(b, c, d, a, x[0], S24, 0xe9b6c7aaL); /* 20 */
        a = GG(a, b, c, d, x[5], S21, 0xd62f105dL); /* 21 */
        d = GG(d, a, b, c, x[10], S22, 0x2441453L); /* 22 */
        c = GG(c, d, a, b, x[15], S23, 0xd8a1e681L); /* 23 */
        b = GG(b, c, d, a, x[4], S24, 0xe7d3fbc8L); /* 24 */
        a = GG(a, b, c, d, x[9], S21, 0x21e1cde6L); /* 25 */
        d = GG(d, a, b, c, x[14], S22, 0xc33707d6L); /* 26 */
        c = GG(c, d, a, b, x[3], S23, 0xf4d50d87L); /* 27 */
        b = GG(b, c, d, a, x[8], S24, 0x455a14edL); /* 28 */
        a = GG(a, b, c, d, x[13], S21, 0xa9e3e905L); /* 29 */
        d = GG(d, a, b, c, x[2], S22, 0xfcefa3f8L); /* 30 */
        c = GG(c, d, a, b, x[7], S23, 0x676f02d9L); /* 31 */
        b = GG(b, c, d, a, x[12], S24, 0x8d2a4c8aL); /* 32 */
        /* Round 3 */
        a = HH(a, b, c, d, x[5], S31, 0xfffa3942L); /* 33 */
        d = HH(d, a, b, c, x[8], S32, 0x8771f681L); /* 34 */
        c = HH(c, d, a, b, x[11], S33, 0x6d9d6122L); /* 35 */
        b = HH(b, c, d, a, x[14], S34, 0xfde5380cL); /* 36 */
        a = HH(a, b, c, d, x[1], S31, 0xa4beea44L); /* 37 */
        d = HH(d, a, b, c, x[4], S32, 0x4bdecfa9L); /* 38 */
        c = HH(c, d, a, b, x[7], S33, 0xf6bb4b60L); /* 39 */
        b = HH(b, c, d, a, x[10], S34, 0xbebfbc70L); /* 40 */
        a = HH(a, b, c, d, x[13], S31, 0x289b7ec6L); /* 41 */
        d = HH(d, a, b, c, x[0], S32, 0xeaa127faL); /* 42 */
        c = HH(c, d, a, b, x[3], S33, 0xd4ef3085L); /* 43 */
        b = HH(b, c, d, a, x[6], S34, 0x4881d05L); /* 44 */
        a = HH(a, b, c, d, x[9], S31, 0xd9d4d039L); /* 45 */
        d = HH(d, a, b, c, x[12], S32, 0xe6db99e5L); /* 46 */
        c = HH(c, d, a, b, x[15], S33, 0x1fa27cf8L); /* 47 */
        b = HH(b, c, d, a, x[2], S34, 0xc4ac5665L); /* 48 */
        /* Round 4 */
        a = II(a, b, c, d, x[0], S41, 0xf4292244L); /* 49 */
        d = II(d, a, b, c, x[7], S42, 0x432aff97L); /* 50 */
        c = II(c, d, a, b, x[14], S43, 0xab9423a7L); /* 51 */
        b = II(b, c, d, a, x[5], S44, 0xfc93a039L); /* 52 */
        a = II(a, b, c, d, x[12], S41, 0x655b59c3L); /* 53 */
        d = II(d, a, b, c, x[3], S42, 0x8f0ccc92L); /* 54 */
        c = II(c, d, a, b, x[10], S43, 0xffeff47dL); /* 55 */
        b = II(b, c, d, a, x[1], S44, 0x85845dd1L); /* 56 */
        a = II(a, b, c, d, x[8], S41, 0x6fa87e4fL); /* 57 */
        d = II(d, a, b, c, x[15], S42, 0xfe2ce6e0L); /* 58 */
        c = II(c, d, a, b, x[6], S43, 0xa3014314L); /* 59 */
        b = II(b, c, d, a, x[13], S44, 0x4e0811a1L); /* 60 */
        a = II(a, b, c, d, x[4], S41, 0xf7537e82L); /* 61 */
        d = II(d, a, b, c, x[11], S42, 0xbd3af235L); /* 62 */
        c = II(c, d, a, b, x[2], S43, 0x2ad7d2bbL); /* 63 */
        b = II(b, c, d, a, x[9], S44, 0xeb86d391L); /* 64 */
        state[0] += a;
        state[1] += b;
        state[2] += c;
        state[3] += d;
    }

    private void Encode(byte[] output, long[] input, int len) {
        int i, j;
        for (i = 0, j = 0; j < len; i++, j += 4) {
            output[j] = (byte) (input[i] & 0xffL);
            output[j + 1] = (byte) ((input[i] >>> 8) & 0xffL);
            output[j + 2] = (byte) ((input[i] >>> 16) & 0xffL);
            output[j + 3] = (byte) ((input[i] >>> 24) & 0xffL);
        }
    }

    private void Decode(long[] output, byte[] input, int len) {
        int i, j;
        for (i = 0, j = 0; j < len; i++, j += 4)
            output[i] = b2iu(input[j]) | (b2iu(input[j + 1]) << 8)
                    | (b2iu(input[j + 2]) << 16) | (b2iu(input[j + 3]) << 24);
        return;
    }

    public static long b2iu(byte b) {
        return b < 0 ? b & 0x7F + 128 : b;
    }

    public static String byteHEX(byte ib) {
        char[] Digit = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A',
                'B', 'C', 'D', 'E', 'F' };
        char[] ob = new char[2];
        ob[0] = Digit[(ib >>> 4) & 0X0F];
        ob[1] = Digit[ib & 0X0F];
        String s = new String(ob);
        return s;
    }
}

2.我们需要在cas.war开发包文件中找到用于密码处理的类,并进行继承重写
附CAS下载地址
https://github.com/apereo/cas/releases?after=v5.0.0.M2
找到cas-server-core-api-4.1.5.jar导入到项目中
需要继承jar包中提供的PasswordEncoder密码处理格式,在此基础上进行MD5加密处理

import org.jasig.cas.authentication.handler.PasswordEncoder;
//需要继承jar包中的PasswordEncoder
public class GetMd5 implements PasswordEncoder {
    @Override
    public String encode(String password) {
        //首先对密码进行加盐处理
        String Slat_password="{{"+"hello,sjw"+password+"}}";
        //进行MD5加密
        String new_password=new MD5code().getMD5ofStr(Slat_password);
        //返回经过加密处理的密码
        return new_password;
    }
}

3.打成JAR包
在这里插入图片描述
在这里插入图片描述
上传到Tomcat目录下的cas目录的lib目录里

4.配置deployerConfigContext.xml文件

(1)定义加密类

<bean id="passwordEncoder" class="GetMd5" />

(2)把定义的类加入dbAuthHandler

<bean id="dbAuthHandler" class="org.jasig.cas.adaptors.jdbc.QueryDatabaseAuthenticationHandler">
	    <property name="dataSource" ref="dataSource"/>
		<property name="sql" value="select password from member where mid=? AND locked=0"/>
		<property name="passwordEncoder" ref="passwordEncoder"/>
</bean>

5.启动Tomcat
输入账号密码,会自动转变成MD5与数据库相对
在这里插入图片描述

在这里插入图片描述
成功!!!

技术傻白甜
关注
专栏目录
CAS 4.2.1单点登录（四） 密码加密之MD5加盐
weixin_39463716的博客
01-08 2390
这里只用MD5加盐的方式对密码进行加密，为了提高安全性，盐值采用的是用户名+一个从数据库中获取的字段salt 密码比对的逻辑是在QueryDatabaseAuthenticationHandler的authenticateUsernamePasswordInternal方法中，因此加密操作如下： 1.自定义一个类MyQueryDatabaseAuthenticationHandler 该类与Que...
CAS使用账号密码实现单点登陆
blankforone的博客
08-26 7919
CAS使用账号密码实现单点登陆CAS单点登陆框架项目需求实现思路1、使用用户名密码获取TGT2、根据TGT和Service获取ST3、使用ST访问目标资源Java代码实现 CAS单点登陆框架 CAS 是 Yale 大学发起的一个开源项目，旨在为 Web 应用系统提供一种可靠的单点登录方法 官方网站 https://www.apereo.org/projects/cas 这里不详细介绍CAS的单点登陆原理，感兴趣的同学可以自己去研究一下，这里仅就项目中遇到的问题进行记录 项目需求 我们的系统通过单点登陆跳转到
cas 单点登录(SSO)之一: jasig cas-server 安装
恒
08-06 4568
cas 单点登录(SSO)实验之一: jasig cas-server 安装参考文章：http://my.oschina.net/indestiny/blog/200768#commentshttp://wenku.baidu.com/view/0bcc0d01e87101f69e319595.htmlSSO原理不多重复，需要理解的就一点，一个复杂系统需要一个唯一的验证服务，这就是CAS(Cent
CAS单点登录-密码管理（十三）
最新发布
2401_85125162的博客
08-30 400
重置信息 https://apereo.github.io/cas/5.1.x/installation/Configuration-Properties.html#password-management。来进行简单的罗列一下，好给大家一个简单的介绍，当然了，这些界面是cas提供的，我们在上线的时候的一般需要自定义一套，有文章姐简单介绍了一下。#邮件内容，必须要有%s，因为会生成一个连接并且带了token，否则无法打开链接，当然这个链接也和cas.server.prefix有关系。#根据用户名查找邮箱。
单点登录——CAS服务端连接mysql自定义密码加密
LSY_CSDN_的博客
05-22 1385
目录 1、自定义密码加密分析： 2、单纯密码加密： （1）引入依赖： （2）配置cas的jdbc连接信息： （3）去掉配置的用户名和密码： （4）定义实体类实现接口： （5）重写encode方法： （6）重写matches方法： （7）启动访问测试： 3、复杂密码加密： （1）引入依赖： （2）配置spring的jdbc连接方式： （3）定义实体类继承handler： （4）重写authenticate方法： （5）重写support方法： （6）定义实体类实现接口： （7
简单的cas单点登录+加密 SSM
yys_ztmshuai的博客
12-19 1606
楼主新萌一枚,写了一些小的demo 拿出来分析一下,如果有那些问题 欢迎大家前来指点,废话不多说啦,下面是代码 ~~~~~~~~~~~~~~~~~~~~华丽的分割线~~~~~~~~~~~~~~~~~~~ /*楼主redis 的xml配置一直失败,然后就放弃了,改成了编码形式  第一次发帖,害羞胆怯 登陆方法 */ @Override     public Customer l
Cas用户密码自定义加密
探索丶挑战丶突破
08-17 2895
配置案例1 在cas配置文件中修改deployerConfigContext.xml文件： &lt;bean class="org.jasig.cas.adaptors.jdbc.QueryDatabaseAuthenticationHandler"&gt; &lt;property name="dataSource" ref="dataSourceForMySql" &gt;&...
cas单点登录数据库配置及自定义密码加密方式
allan_chan的专栏
10-24 3424
修改deployerConfigContext.xml文件： &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;bean id="authenticationManager" class="org.jasig.cas.authentication.PolicyBasedAuthenticationManager"&gt; &amp
Jeecg配置单点登录 登录验证完整代码
11-02
4. **处理登录与登出逻辑**：配置完成后，Jeecg应用会自动重定向到CAS登录页面进行身份验证。验证成功后，CAS服务器会向Jeecg应用返回一个服务票证（ST），Jeecg应用通过这个票证向CAS服务器验证用户身份，然后创建...
CAS单点登录Demo
11-08
在本文中，我们将深入探讨CAS单点登录的基本原理、工作流程以及如何通过提供的Demo进行实践操作。 **CAS基本原理** CAS的核心思想是用户只需在一个应用系统中验证身份，之后访问其他所有支持CAS的应用系统时都不再...
cas.rar_67194com_67194。com_CAS_cas单点demo_shiro 单点登录
09-15
"cas单点demo"和"shiro_单点登录"则明确表示这是一个关于CAS和Shiro单点登录的示例项目。 总的来说，这个项目展示了如何利用CAS的单点登录功能，结合Spring MVC的控制能力以及Shiro的权限管理，实现一个全面的身份...
CAS自定义加密和登录验证
11-13
对应博客：https://blog.csdn.net/fancheng614/article/details/84038266
定制cas单点登录用户名密码验证
12-03
定制CAS单点登录用户名和密码验证资料，供学习
cas多条件查询、登录、密码加密、验证码实现
06-06
CAS实现MD5+Base64密码加密方式，实现多条件登录及查询，返回客户端多个值，验证码实现；因文件太大，只保留了最重要的三个jar包，请先到官网下载服务端的war包，解压后将lib目录下的jar包导入到sso中的lib目录下，注意：sso中的jar包是必须的，不可替换。然后直接部署到tomcat下即可运行。
Cas单点登录(3)数据库验证用户之无密码加密
祈雨v的博客
11-07 909
修改Cas Server下的cas项目的配置文件cas/WEB-INF/deployerConfigContext.xml：1、删除以下配置（该配置为Cas Server默认的账号密码）：<bean id="primaryAuthenticationHandler" class="org.jasig.cas.authentication.AcceptUsersAuthenticationHandle
单点登录 cas 二次开发 用户名密码校验使用mysql【系列二】
qq_29384639的博客
01-23 1875
1、src下新增目录结构 重写密码校验规则 配置pom.xml 添加mysql依赖 <properties> <mysql.driver.version>5.1.46</mysql.driver.version> </properties> <dependencies> <!--数据库认证相关 start--> <dependency> <groupId>org.ape
cas-4.2.7搭建单点登录（5）---登录密码自定义加密规则（mongo数据库）
Dai_Haijiao的博客
02-28 652
cas-4.2.7搭建单点登录---登录密码自定义加密规则（mongo数据库）
CAS单点登录部署教程
"单点登录(CAS)是一种流行的解决方案，允许用户在访问多个相互信任的Web应用时只需登录一次。CAS是由耶鲁大学发起的开源项目，后来成为JA-SIG组织的一部分，旨在提供可靠的身份验证服务。CAS系统由CASServer和CAS...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值