【蓝桥杯算法题】经典加解密函数Discuz authcode

已于 2023-06-26 21:06:01 修改
阅读量178 收藏
点赞数
分类专栏： 算法 JAVA 加密 文章标签： java 开发语言 算法 同态加密 蓝桥杯
于 2023-05-30 09:45:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43576565/article/details/130892791
版权
JAVA 同时被 3 个专栏收录
21 篇文章 0 订阅
订阅专栏
算法
10 篇文章 0 订阅
订阅专栏
加密
1 篇文章 0 订阅
订阅专栏

经典加解密函数Discuz authcode多语言实现

JSP实现

<%@ page import="java.util.Base64" %>
<%--传输加密--%>
<%!

//    public class AuthCode {

        public enum DiscuzAuthcodeMode {
            Encode, Decode
        };
        // private static MD5 md5 = new MD5();
        // private static BASE64 base64 = new BASE64();
        // / <summary>
        // / 从字符串的指定位置截取指定长度的子字符串
        // / </summary>
        // / <param name="str">原字符串</param>
        // / <param name="startIndex">子字符串的起始位置</param>
        // / <param name="length">子字符串的长度</param>
        // / <returns>子字符串</returns>
        public static String CutString(String str, int startIndex, int length) {
            if (startIndex >= 0) {
                if (length < 0) {
                    length = length * -1;
                    if (startIndex - length < 0) {
                        length = startIndex;
                        startIndex = 0;
                    } else {
                        startIndex = startIndex - length;
                    }
                }
                if (startIndex > str.length()) {
                    return "";
                }
            } else {
                if (length < 0) {
                    return "";
                } else {
                    if (length + startIndex > 0) {
                        length = length + startIndex;
                        startIndex = 0;
                    } else {
                        return "";
                    }
                }
            }
            if (str.length() - startIndex < length) {
                length = str.length() - startIndex;
            }
            return str.substring(startIndex, startIndex + length);
        }
        // / <summary>
        // / 从字符串的指定位置开始截取到字符串结尾的了符串
        // / </summary>
        // / <param name="str">原字符串</param>
        // / <param name="startIndex">子字符串的起始位置</param>
        // / <returns>子字符串</returns>
        public static String CutString(String str, int startIndex) {
            return CutString(str, startIndex, str.length());
        }
        // / <summary>
        // / 返回文件是否存在
        // / </summary>
        // / <param name="filename">文件名</param>
        // / <returns>是否存在</returns>
        public static boolean FileExists(String filename) {
            File f = new File(filename);
            return f.exists();
        }
        // / <summary>
        // / MD5函数
        // / </summary>
        // / <param name="str">原始字符串</param>
        // / <returns>MD5结果</returns>
        public static String MD5(String str) {
            // return md5.convert(str);
            StringBuffer sb = new StringBuffer();
            String part = null;
            try {
                MessageDigest md = MessageDigest.getInstance("MD5");
                byte[] md5 = md.digest(str.getBytes());
                for (int i = 0; i < md5.length; i++) {
                    part = Integer.toHexString(md5[i] & 0xFF);
                    if (part.length() == 1) {
                        part = "0" + part;
                    }
                    sb.append(part);
                }
            } catch (NoSuchAlgorithmException ex) {
            }
            return sb.toString();
        }
        // / <summary>
        // / 字段串是否为Null或为""(空)
        // / </summary>
        // / <param name="str"></param>
        // / <returns></returns>
        public static boolean StrIsNullOrEmpty(String str) {
            // #if NET1
            if (str == null || str.trim().equals("")) {
                return true;
            }
            return false;
        }
        // / <summary>
        // / 用于 RC4 处理密码
        // / </summary>
        // / <param name="pass">密码字串</param>
        // / <param name="kLen">密钥长度，一般为 256</param>
        // / <returns></returns>
        static private byte[] GetKey(byte[] pass, int kLen) {
            byte[] mBox = new byte[kLen];
            for (int i = 0; i < kLen; i++) {
                mBox[i] = (byte) i;
            }
            int j = 0;
            for (int i = 0; i < kLen; i++) {
                j = (j + (int) ((mBox[i] + 256) % 256) + pass[i % pass.length])
                        % kLen;
                byte temp = mBox[i];
                mBox[i] = mBox[j];
                mBox[j] = temp;
            }
            return mBox;
        }
        // / <summary>
        // / 生成随机字符
        // / </summary>
        // / <param name="lens">随机字符长度</param>
        // / <returns>随机字符</returns>
        public static String RandomString(int lens) {
            char[] CharArray = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'j', 'k',
                    'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
                    'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
            int clens = CharArray.length;
            String sCode = "";
            Random random = new Random();
            for (int i = 0; i < lens; i++) {
                sCode += CharArray[Math.abs(random.nextInt(clens))];
            }
            return sCode;
        }
        public static String authcodeEncode(String source, String key, int expiry) {
            return authcode(source, key, DiscuzAuthcodeMode.Encode, expiry);
        }

        public static String authcodeEncode(String source, String key) {
            return authcode(source, key, DiscuzAuthcodeMode.Encode, 0);
        }

        public static String authcodeDecode(String source, String key) {
            return authcode(source, key, DiscuzAuthcodeMode.Decode, 0);
        }

        private static String authcode(String source, String key,
                                       DiscuzAuthcodeMode operation, int expiry) {
            System.out.println("--------source:" + source);
            try {
                if (source == null || key == null) {
                    return "";
                }
                int ckey_length = 4;
                String keya, keyb, keyc, cryptkey, result;
                key = MD5(key);
                keya = MD5(CutString(key, 0, 16));
                keyb = MD5(CutString(key, 16, 16));
                keyc = ckey_length > 0 ? (operation == DiscuzAuthcodeMode.Decode ? CutString(
                        source, 0, ckey_length) : RandomString(ckey_length))
                        : "";
                cryptkey = keya + MD5(keya + keyc);

//                重写部分
                if (operation == DiscuzAuthcodeMode.Decode) {

                    byte[] temp;

                    String tstr = CutString(source, ckey_length);
                    System.out.println(" CutString(source, ckey_length):" +  CutString(source, ckey_length));
//                    temp = Base64.decodeBase64(CutString(source, ckey_length));
//                    Base64.getDecoder()方法来获取Base64解码器，getBytes()方法将字符串转换为字节数组，最后调用decode()方法进行解码。
                    temp = Base64.getDecoder().decode(CutString(source, ckey_length).getBytes());
                    result = new String(RC4(temp, cryptkey));
                    if (CutString(result, 10, 16).equals(
                            CutString(MD5(CutString(result, 26) + keyb), 0, 16))) {
                        return CutString(result, 26);
                    } else {
//                        temp = Base64.decodeBase64(CutString(source + "=", ckey_length));
                        temp = Base64.getDecoder().decode((source + "=").getBytes());
                        result = new String(RC4(temp, cryptkey));
                        if (CutString(result, 10, 16)
                                .equals(CutString(
                                        MD5(CutString(result, 26) + keyb), 0, 16))) {
                            return CutString(result, 26);
                        } else {
//                            temp = Base64.decodeBase64(CutString(source + "==",
//                                    ckey_length));
                            temp = Base64.getDecoder().decode((source + "==").getBytes());
                            result = new String(RC4(temp, cryptkey));
                            if (CutString(result, 10, 16).equals(
                                    CutString(MD5(CutString(result, 26) + keyb), 0,
                                            16))) {
                                return CutString(result, 26);
                            } else {
                                return "2";
                            }
                        }
                    }
                } else {
                    source = "0000000000" + CutString(MD5(source + keyb), 0, 16)
                            + source;
                    byte[] temp = RC4(source.getBytes("GBK"), cryptkey);
//                    return keyc + Base64.encodeBase64String(temp);
//                    用Base64.getEncoder()方法来获取编码器，并使用encode()方法将字节数组编码成Base64字符串。
                    return keyc + new String(Base64.getEncoder().encode(temp));
                }
            } catch (Exception e) {
                e.printStackTrace();
                return "==aaaa==";
            }
        }
        //  <summary>
        //  RC4 原始算法
        // </summary>
        //  <param name="input">原始字串数组</param>
        //  <param name="pass">密钥</param>
        //  <returns>处理后的字串数组</returns>
        private static byte[] RC4(byte[] input, String pass) {
            if (input == null || pass == null)
                return null;
            byte[] output = new byte[input.length];
            byte[] mBox = GetKey(pass.getBytes(), 256);
            // 加密
            int i = 0;
            int j = 0;
            for (int offset = 0; offset < input.length; offset++) {
                i = (i + 1) % mBox.length;
                j = (j + (int) ((mBox[i] + 256) % 256)) % mBox.length;
                byte temp = mBox[i];
                mBox[i] = mBox[j];
                mBox[j] = temp;
                byte a = input[offset];
                // byte b = mBox[(mBox[i] + mBox[j] % mBox.Length) % mBox.Length];
                // mBox[j] 一定比 mBox.Length 小，不需要在取模
                byte b = mBox[(toInt(mBox[i]) + toInt(mBox[j])) % mBox.length];
                output[offset] = (byte) ((int) a ^ (int) toInt(b));
            }
            return output;
        }
        public static int toInt(byte b) {
            return (int) ((b + 256) % 256);
        }
        public long getUnixTimestamp() {
            Calendar cal = Calendar.getInstance();
            return cal.getTimeInMillis() / 1000;
        }
        public static void main(String[] args) {
            String test = "111aaaaaaaaaaaaaaaaaaaf" +
                    "" +
                    "";
            String key = "UJsDgnkRGX4heWAy";
            String afStr = authcodeEncode(test, key);
            System.out.println("--------encode:" + afStr);
            long lStart = System.currentTimeMillis();
            System.out.println("解码后：" + authcodeDecode(afStr, key));
            long lUseTime = System.currentTimeMillis() - lStart;
            System.out.println("加解密耗时：" + lUseTime + "毫秒");
        }
//    }

%>

Java实现

package com.example.library.controller;

import java.io.File;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;
import java.util.Calendar;
import java.util.Random;

public class AuthCode {
    public enum DiscuzAuthcodeMode {
        Encode, Decode
    };
    // private static MD5 md5 = new MD5();
    // private static BASE64 base64 = new BASE64();
    // / <summary>
    // / 从字符串的指定位置截取指定长度的子字符串
    // / </summary>
    // / <param name="str">原字符串</param>
    // / <param name="startIndex">子字符串的起始位置</param>
    // / <param name="length">子字符串的长度</param>
    // / <returns>子字符串</returns>
    public static String CutString(String str, int startIndex, int length) {
        if (startIndex >= 0) {
            if (length < 0) {
                length = length * -1;
                if (startIndex - length < 0) {
                    length = startIndex;
                    startIndex = 0;
                } else {
                    startIndex = startIndex - length;
                }
            }
            if (startIndex > str.length()) {
                return "";
            }
        } else {
            if (length < 0) {
                return "";
            } else {
                if (length + startIndex > 0) {
                    length = length + startIndex;
                    startIndex = 0;
                } else {
                    return "";
                }
            }
        }
        if (str.length() - startIndex < length) {
            length = str.length() - startIndex;
        }
        return str.substring(startIndex, startIndex + length);
    }
    // / <summary>
    // / 从字符串的指定位置开始截取到字符串结尾的了符串
    // / </summary>
    // / <param name="str">原字符串</param>
    // / <param name="startIndex">子字符串的起始位置</param>
    // / <returns>子字符串</returns>
    public static String CutString(String str, int startIndex) {
        return CutString(str, startIndex, str.length());
    }
    // / <summary>
    // / 返回文件是否存在
    // / </summary>
    // / <param name="filename">文件名</param>
    // / <returns>是否存在</returns>
    public static boolean FileExists(String filename) {
        File f = new File(filename);
        return f.exists();
    }
    // / <summary>
    // / MD5函数
    // / </summary>
    // / <param name="str">原始字符串</param>
    // / <returns>MD5结果</returns>
    public static String MD5(String str) {
        // return md5.convert(str);
        StringBuffer sb = new StringBuffer();
        String part = null;
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            byte[] md5 = md.digest(str.getBytes());
            for (int i = 0; i < md5.length; i++) {
                part = Integer.toHexString(md5[i] & 0xFF);
                if (part.length() == 1) {
                    part = "0" + part;
                }
                sb.append(part);
            }
        } catch (NoSuchAlgorithmException ex) {
        }
        return sb.toString();
    }
    // / <summary>
    // / 字段串是否为Null或为""(空)
    // / </summary>
    // / <param name="str"></param>
    // / <returns></returns>
    public static boolean StrIsNullOrEmpty(String str) {
        // #if NET1
        if (str == null || str.trim().equals("")) {
            return true;
        }
        return false;
    }
    // / <summary>
    // / 用于 RC4 处理密码
    // / </summary>
    // / <param name="pass">密码字串</param>
    // / <param name="kLen">密钥长度，一般为 256</param>
    // / <returns></returns>
    static private byte[] GetKey(byte[] pass, int kLen) {
        byte[] mBox = new byte[kLen];
        for (int i = 0; i < kLen; i++) {
            mBox[i] = (byte) i;
        }
        int j = 0;
        for (int i = 0; i < kLen; i++) {
            j = (j + (int) ((mBox[i] + 256) % 256) + pass[i % pass.length])
                    % kLen;
            byte temp = mBox[i];
            mBox[i] = mBox[j];
            mBox[j] = temp;
        }
        return mBox;
    }
    // / <summary>
    // / 生成随机字符
    // / </summary>
    // / <param name="lens">随机字符长度</param>
    // / <returns>随机字符</returns>
    public static String RandomString(int lens) {
        char[] CharArray = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'j', 'k',
                'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
                'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
        int clens = CharArray.length;
        String sCode = "";
        Random random = new Random();
        for (int i = 0; i < lens; i++) {
            sCode += CharArray[Math.abs(random.nextInt(clens))];
        }
        return sCode;
    }
    public static String authcodeEncode(String source, String key, int expiry) {
        return authcode(source, key, DiscuzAuthcodeMode.Encode, expiry);
    }

    public static String authcodeEncode(String source, String key) {
        return authcode(source, key, DiscuzAuthcodeMode.Encode, 0);
    }

    public static String authcodeDecode(String source, String key) {
        return authcode(source, key, DiscuzAuthcodeMode.Decode, 0);
    }

    private static String authcode(String source, String key,
                                   DiscuzAuthcodeMode operation, int expiry) {
        System.out.println("--------source:" + source);
        try {
            if (source == null || key == null) {
                return "";
            }
            int ckey_length = 4;
            String keya, keyb, keyc, cryptkey, result;
            key = MD5(key);
            keya = MD5(CutString(key, 0, 16));
            keyb = MD5(CutString(key, 16, 16));
            keyc = ckey_length > 0 ? (operation == DiscuzAuthcodeMode.Decode ? CutString(
                    source, 0, ckey_length) : RandomString(ckey_length))
                    : "";
            cryptkey = keya + MD5(keya + keyc);

//                重写部分
            if (operation == DiscuzAuthcodeMode.Decode) {

                byte[] temp;

                String tstr = CutString(source, ckey_length);
                System.out.println(" CutString(source, ckey_length):" +  CutString(source, ckey_length));
//                    temp = Base64.decodeBase64(CutString(source, ckey_length));
//                    Base64.getDecoder()方法来获取Base64解码器，getBytes()方法将字符串转换为字节数组，最后调用decode()方法进行解码。
                temp = Base64.getDecoder().decode(CutString(source, ckey_length).getBytes());
                result = new String(RC4(temp, cryptkey));
                if (CutString(result, 10, 16).equals(
                        CutString(MD5(CutString(result, 26) + keyb), 0, 16))) {
                    return CutString(result, 26);
                } else {
//                        temp = Base64.decodeBase64(CutString(source + "=", ckey_length));
                    temp = Base64.getDecoder().decode((source + "=").getBytes());
                    result = new String(RC4(temp, cryptkey));
                    if (CutString(result, 10, 16)
                            .equals(CutString(
                                    MD5(CutString(result, 26) + keyb), 0, 16))) {
                        return CutString(result, 26);
                    } else {
//                            temp = Base64.decodeBase64(CutString(source + "==",
//                                    ckey_length));
                        temp = Base64.getDecoder().decode((source + "==").getBytes());
                        result = new String(RC4(temp, cryptkey));
                        if (CutString(result, 10, 16).equals(
                                CutString(MD5(CutString(result, 26) + keyb), 0,
                                        16))) {
                            return CutString(result, 26);
                        } else {
                            return "2";
                        }
                    }
                }
            } else {
                source = "0000000000" + CutString(MD5(source + keyb), 0, 16)
                        + source;
                byte[] temp = RC4(source.getBytes("GBK"), cryptkey);
//                    return keyc + Base64.encodeBase64String(temp);
//                    用Base64.getEncoder()方法来获取编码器，并使用encode()方法将字节数组编码成Base64字符串。
                return keyc + new String(Base64.getEncoder().encode(temp));
            }
        } catch (Exception e) {
            e.printStackTrace();
            return "==aaaa==";
        }
    }
    //  <summary>
    //  RC4 原始算法
    // </summary>
    //  <param name="input">原始字串数组</param>
    //  <param name="pass">密钥</param>
    //  <returns>处理后的字串数组</returns>
    private static byte[] RC4(byte[] input, String pass) {
        if (input == null || pass == null)
            return null;
        byte[] output = new byte[input.length];
        byte[] mBox = GetKey(pass.getBytes(), 256);
        // 加密
        int i = 0;
        int j = 0;
        for (int offset = 0; offset < input.length; offset++) {
            i = (i + 1) % mBox.length;
            j = (j + (int) ((mBox[i] + 256) % 256)) % mBox.length;
            byte temp = mBox[i];
            mBox[i] = mBox[j];
            mBox[j] = temp;
            byte a = input[offset];
            // byte b = mBox[(mBox[i] + mBox[j] % mBox.Length) % mBox.Length];
            // mBox[j] 一定比 mBox.Length 小，不需要在取模
            byte b = mBox[(toInt(mBox[i]) + toInt(mBox[j])) % mBox.length];
            output[offset] = (byte) ((int) a ^ (int) toInt(b));
        }
        return output;
    }
    public static int toInt(byte b) {
        return (int) ((b + 256) % 256);
    }
    public long getUnixTimestamp() {
        Calendar cal = Calendar.getInstance();
        return cal.getTimeInMillis() / 1000;
    }
    public static void main(String[] args) {
    //加密前字符串
        String test = "111aaaaaaaaaaaaaaaaaaaf" +
                "" +
                "";
        String key = "UJsDgnkRGX4heWAy";//可以改为自己定义的key
        String afStr = authcodeEncode(test, key);
        System.out.println("--------encode:" + afStr);
        long lStart = System.currentTimeMillis();
        System.out.println("解码后：" + authcodeDecode(afStr, key));
//        System.out.println("解码后：" + authcodeDecode("ac9e7b3dd5kV-RSZculy19rG81AiWSGM1Yyw00Y5eavs1p797dEEpjYpopQN", key));
        long lUseTime = System.currentTimeMillis() - lStart;

        System.out.println("加解密耗时：" + lUseTime + "毫秒");
    }
//    }

}

PHP实现

  function authcode($string, $operation = 'DECODE', $key = '', $expiry = 0) {


    $ckey_length = 4;


    $key = md5($key ? $key : UC_KEY);
    $keya = md5(substr($key, 0, 16));
    $keyb = md5(substr($key, 16, 16));
    $keyc = $ckey_length ? ($operation == 'DECODE' ? substr($string, 0, $ckey_length): substr(md5(microtime()), -$ckey_length)) : '';


    $cryptkey = $keya.md5($keya.$keyc);
    $key_length = strlen($cryptkey);


    $string = $operation == 'DECODE' ? base64_decode(substr($string, $ckey_length)) : sprintf('%010d', $expiry ? $expiry + time() : 0).substr(md5($string.$keyb), 0, 16).$string;
    $string_length = strlen($string);


    $result = '';
    $box = range(0, 255);


    $rndkey = array();
    for($i = 0; $i <= 255; $i++) {
      $rndkey[$i] = ord($cryptkey[$i % $key_length]);
    }


    for($j = $i = 0; $i < 256; $i++) {
      $j = ($j + $box[$i] + $rndkey[$i]) % 256;
      $tmp = $box[$i];
      $box[$i] = $box[$j];
      $box[$j] = $tmp;
    }


    for($a = $j = $i = 0; $i < $string_length; $i++) {
      $a = ($a + 1) % 256;
      $j = ($j + $box[$a]) % 256;
      $tmp = $box[$a];
      $box[$a] = $box[$j];
      $box[$j] = $tmp;
      $result .= chr(ord($string[$i]) ^ ($box[($box[$a] + $box[$j]) % 256]));
    }


    if($operation == 'DECODE') {
      if((substr($result, 0, 10) == 0 || substr($result, 0, 10) - time() > 0) && substr($result, 10, 16) == substr(md5(substr($result, 26).$keyb), 0, 16)) {
        return substr($result, 26);
      } else {
        return '';
      }
    } else {
      return $keyc.str_replace('=', '', base64_encode($result));
    }


  }
SmallFatMan
关注
专栏目录
解析discuz authcode(加，解密函数)
phphot
01-07 2653
这两天心血来潮，研究下discuz 5.0,看到authcode时，在网上没有找到相关的解析，如是把自己的见解写下来，如有错误，欢迎指教。转载请注：来自http://hi.baidu.com/studyphpfunction authcode ($string, $operation, $key = ) {#string 为需加、解密字符串#operation DECODE时解密$key =
经典PHP加密解密函数Authcode()修复版代码
10-24
Authcode函数源自知名的Discuz论坛系统，它的功能包括设置自定义的密钥（key）以及设定解密后的过期时间。原始的Authcode函数存在一个问题，即在加密过程中可能生成`+`、`/`、`&`等特殊字符，这些字符在URL中传输时...
discuz加密解密函数使用方法和中文注释
01-20
复制代码 代码如下:<?php/** * $string 明文或密文 * $operation 加密ENCODE或解密DECODE * $key 密钥 * $expiry 密钥有效期 */ function authcode($string, $operation = ‘DECODE’, $key = ”, $expiry = 0) {    // 动态密匙长度，相同的明文会生成不同密文就是依靠动态密匙    // 加入随机密钥，可以令密文无任何规律，即便是原文和密钥完全相同，加密结果也会每次不同，增大破解难度。    // 取值越大，密文变动规律越大，密文变化 = 16 的 $ckey_le
discuz 经典php加密解密函数 authcode 解析
Willko's Blog
02-08 407
康盛的 authcode 函数可以说对中国的PHP界作出了重大贡献。包括康盛自己的产品，以及大部分中国使用PHP的公司都用这个函数进行加密，authcode 是使用异或运算进行加密和解密。 原理如下，假如： 加密 明文：1010 1001 密匙：1110 0011 密文：0100 1010 得出密文0100 1010，解密之需和密匙异或下就可以了 解密 密文：0100 10...
互联网开发之神器：经典加解密函数Discuz authcode
weixin_45727359的博客
07-25 582
肉眼品世界导读：互联网开发里有一个很重要的业务，就是数据的安全性，而有的数据真正处理的时候又需要明文出现，那么安全的加解密就是一个非常重要的常见场景了，api 的token,关键数据的加...
Discuz 的加密与解密函数authcode
dabao1989的专栏
10-11 1094
Discuz 的加密与解密函数authcode 分类:Discuz| 浏览:705 分享到：0       authcode()并不是PHP的内置函数,它是康盛开发的一个使用异或运算进行加密和解密的函数，可以说这是康盛对中国的PHP界作出的重大贡献。康盛自己的产品如Discuz，UCenter等以及许多使用PHP的中国公司都用这个函数进行加密。在前面的
discuz authcode 经典php加密解密函数解析
10-29
AuthCode是康盛公司提供的一种基于PHP的加密解密函数，广泛应用于中国的PHP社区。AuthCode的加密和解密过程基于异或运算，其核心在于密匙的动态生成和使用，保证了即使是相同的明文，在不同的时间点也会产生不同的...
php加密解密函数authcode的用法详细解析
12-19
4. **加解密过程**：采用固定算法打乱密钥簿，然后对明文逐字节进行异或操作，同时考虑到密钥簿的变化，使得解密时可以恢复原始数据。 5. **数据校验**：解密时，会检查前10位的时间戳和数据完整性，确保数据在有效...
经典PHP加密解密函数Authcode()修复版代码_.docx
10-10
`Authcode()` 是一个经典的PHP自定义加密解密函数，它来源于知名的Discuz论坛程序，适用于对字符串进行加密和解密操作，并允许设置自定义密钥（key）以及设置过期时间。然而，原版`Authcode()`函数存在一个小问题：...
使用discuz加密函数authcode对cookie进行加密
weixin_34087503的博客
08-02 182
为什么80%的码农都做不了架构师？>>> ...
php动态密码和加密解密函数的使用(动态密码、Discuz核心函数AuthCode、任意输入密码验证）
漏刻有时数据可视化大屏（PHP&ECHARTS智能化开源软件系统）
04-24 1041
在同步登录（从项目登录到UCenter）的过程中，authcode()把用户的登录信息进行加密，因为没有加密的数据在传递过程中容易被截取，会暴露了用户的信息，authcode()的作用就是给传递的数据提供加密保护作用。输入年时间作为动态密码，在后端验证时，任意输入密码字符串，只要包含当前符合规则的联系数字即可。但是本次的项目需求是，没有数据库存储密码，且希望每次密码都不相同，最好是动态密码。下面的加密解密函数是一段比较简单的算法，仅限于数字、字母和大小写，在对保密性要求不高的情形下，可以使用。
php数据加密解密
u014626424的专栏
02-17 482
/** * 数据加密 / 解密 * @param $string： 明文 或 密文 * @param $operation：DECODE表示解密,其它表示加密 * @param $key： 密匙 * @param $expiry：密文有效期 * $str = '3412eafrmlcjS8g75DgHXRlehynzjp0Yw40fPYCl'; * $key = 'walle'; *
php 162 x69 144,DiscuzX中uc_authcode函数js版本，配合php版双向加密解密
weixin_39923157的博客
03-20 255
上周准备写一个js版的uc_authcode函数，根据网上整理的资料：http://bbs.csdn.net/topics/390310377?page=1中Frogant的源码(纯JS版)进行相关测试。同时引入了md5.js和base64.js库。测试结果的准确率不到一半，于是根据DX中的uc_authcode源码进行跟踪调试，发现问题出在base64的编码上，可能是中外对字符串的编码不一致导致...
discuz authcode详解
cnbird's blog
03-12 2776
discuz的 authcode 函数可以说对中国的PHP界作出了重大贡献。包括康盛自己的产品，以及大部分中国使用PHP的公司都用这个函数进行加密，authcode 是使用异或运算进行加密和解密。 原理如下，假如： 加密 明文：1010 1001 密匙：1110 0011 密文：0100 1010 得出密文0100 1010，解密之需和密匙异或下就可以了 解密 密文：0100 10
Discuz! 经典加密解密函数(带详解)
09-16 1747
// $string： 明文 或 密文 // $operation：DECODE表示解密,其它表示加密 // $key： 密匙 // $expiry：密文有效期 function authcode($string, $operation = 'DECODE', $key = '', $expiry = 0) { // 动态密匙长度，相同的明文会生成不同密文就是依靠动态密
discuz加解密function authcode用法
wuxing164的博客
05-18 1096
authcode第三个参数和 key的规则是动态生成的 if(empty($this->var['cookie']['saltkey'])) { $this->var['cookie']['saltkey'] = random(8); dsetcookie('saltkey', $this->var['cookie']['saltkey'], 86400 * 30, 1, 1);
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1114
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
最新发布
xiaocaij_icai的博客
09-15 156
");
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 920
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
java authcode 一个经典的PHP加密解密算法authcode
05-13
Java中也有类似的加密解密算法可以实现类似PHP的authcode功能。常见的加密解密算法有AES、DES、RSA等。 以AES算法为例，可以使用Java内置的javax.crypto库中的AES算法实现加密解密。 加密示例代码： ``` import ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

SmallFatMan

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值