跳转至内容
0
  • 版块
  • 讨论
  • 最新
  • 标签
  • 热门
  • 顶端
  • 用户
  • 版块
  • 讨论
  • 最新
  • 标签
  • 热门
  • 顶端
  • 用户
皮肤
  • Light
  • Cerulean
  • Cosmo
  • Flatly
  • Journal
  • Litera
  • Lumen
  • Lux
  • Materia
  • Minty
  • Morph
  • Pulse
  • Sandstone
  • Simplex
  • Sketchy
  • Spacelab
  • United
  • Yeti
  • Zephyr
  • Dark
  • Cyborg
  • Darkly
  • Quartz
  • Slate
  • Solar
  • Superhero
  • Vapor

  • 默认(Zephyr)
  • 不使用皮肤
折叠
JIKE社区
  1. 首页
  2. 讨论区
  3. 技术专区
  4. 本社区终于可以向 @ChatGPT 提问了!

本社区终于可以向 @ChatGPT 提问了!

已定时 已固定 已锁定 已移动 技术专区
11.5k 帖子 326 发布者 49.5m 浏览
  • 从旧到新
  • 从新到旧
  • 最多赞同
回复
  • 在新帖中回复
登录后回复
此主题已被删除。只有拥有主题管理权限的用户可以查看。
  • 我是小马甲~M 我是小马甲~

    @ChatGPT
    NSQ 如何查看 发布Topic客户端IP

    ChatGPTC 离线
    ChatGPTC 离线
    ChatGPT
    写于 最后由 编辑
    #5701

    malaohu 说:

    @ChatGPT
    NSQ 如何查看 发布Topic客户端IP

    要查看发布NSQ Topic的客户端IP地址,可以使用NSQ的日志记录功能。

    可以在NSQ节点的日志文件中查找来自客户端的发布请求。当客户端发布消息时,其IP地址将记录在日志文件中。

    可以使用以下命令来查看NSQ节点的日志文件:

    tail -f /path/to/nsqd.log
    

    查看日志后,可以搜索字符串“PRODUCER client_id”的记录。在这个记录中,将显示该客户端的IP地址,以及该客户端发布的消息的内容和其他相关信息。

    需要注意的是,NSQ的日志中可能包含大量信息。因此,需要使用适当的搜索策略来快速找到所需的信息。

    帖子内容中 @ChatGPT(注意前后空格,发帖后名称变色才行)。必须@才会回答

    我是小马甲~M 1 条回复 最后回复
    0
    • ChatGPTC ChatGPT

      malaohu 说:

      @ChatGPT
      NSQ 如何查看 发布Topic客户端IP

      要查看发布NSQ Topic的客户端IP地址,可以使用NSQ的日志记录功能。

      可以在NSQ节点的日志文件中查找来自客户端的发布请求。当客户端发布消息时,其IP地址将记录在日志文件中。

      可以使用以下命令来查看NSQ节点的日志文件:

      tail -f /path/to/nsqd.log
      

      查看日志后,可以搜索字符串“PRODUCER client_id”的记录。在这个记录中,将显示该客户端的IP地址,以及该客户端发布的消息的内容和其他相关信息。

      需要注意的是,NSQ的日志中可能包含大量信息。因此,需要使用适当的搜索策略来快速找到所需的信息。

      我是小马甲~M 在线
      我是小马甲~M 在线
      我是小马甲~
      🤫
      写于 最后由 编辑
      #5702

      ChatGPT 说:

      malaohu 说:

      @ChatGPT
      NSQ 如何查看 发布Topic客户端IP

      要查看发布NSQ Topic的客户端IP地址,可以使用NSQ的日志记录功能。

      可以在NSQ节点的日志文件中查找来自客户端的发布请求。当客户端发布消息时,其IP地址将记录在日志文件中。

      可以使用以下命令来查看NSQ节点的日志文件:

      tail -f /path/to/nsqd.log
      

      查看日志后,可以搜索字符串“PRODUCER client_id”的记录。在这个记录中,将显示该客户端的IP地址,以及该客户端发布的消息的内容和其他相关信息。

      需要注意的是,NSQ的日志中可能包含大量信息。因此,需要使用适当的搜索策略来快速找到所需的信息。

      @ChatGPT 我的NSQ是Docker部署的,该怎么操作?

      唐宋元明清,连排小工兵!

      ChatGPTC 1 条回复 最后回复
      0
      • 我是小马甲~M 我是小马甲~

        ChatGPT 说:

        malaohu 说:

        @ChatGPT
        NSQ 如何查看 发布Topic客户端IP

        要查看发布NSQ Topic的客户端IP地址,可以使用NSQ的日志记录功能。

        可以在NSQ节点的日志文件中查找来自客户端的发布请求。当客户端发布消息时,其IP地址将记录在日志文件中。

        可以使用以下命令来查看NSQ节点的日志文件:

        tail -f /path/to/nsqd.log
        

        查看日志后,可以搜索字符串“PRODUCER client_id”的记录。在这个记录中,将显示该客户端的IP地址,以及该客户端发布的消息的内容和其他相关信息。

        需要注意的是,NSQ的日志中可能包含大量信息。因此,需要使用适当的搜索策略来快速找到所需的信息。

        @ChatGPT 我的NSQ是Docker部署的,该怎么操作?

        ChatGPTC 离线
        ChatGPTC 离线
        ChatGPT
        写于 最后由 编辑
        #5703

        malaohu 说:

        ChatGPT 说:

        malaohu 说:

        @ChatGPT
        NSQ 如何查看 发布Topic客户端IP

        要查看发布NSQ Topic的客户端IP地址,可以使用NSQ的日志记录功能。

        可以在NSQ节点的日志文件中查找来自客户端的发布请求。当客户端发布消息时,其IP地址将记录在日志文件中。

        可以使用以下命令来查看NSQ节点的日志文件:

        tail -f /path/to/nsqd.log
        

        查看日志后,可以搜索字符串“PRODUCER client_id”的记录。在这个记录中,将显示该客户端的IP地址,以及该客户端发布的消息的内容和其他相关信息。

        需要注意的是,NSQ的日志中可能包含大量信息。因此,需要使用适当的搜索策略来快速找到所需的信息。

        @ChatGPT 我的NSQ是Docker部署的,该怎么操作?

        如果您的NSQ是通过Docker部署的,您可以通过以下步骤来查找发布NSQ Topic的客户端IP地址。

        1. 查找NSQ节点的容器名称或ID。

        运行以下命令可以查找所有正在运行的NSQ节点的容器名称或ID:

        docker ps | grep nsq
        
        1. 进入NSQ节点的容器。

        使用以下命令进入正在运行的容器:

        docker exec -it  /bin/bash
        

        替换``为要进入的容器的名称或ID。

        1. 查看NSQ节点的日志文件。

        使用以下命令查看NSQ节点容器中的日志文件:

        tail -f /nsqd.log
        

        如果日志文件不在此位置,您需要找到正确的日志文件路径并将命令中的路径替换为正确的路径。

        1. 搜索关键字。

        使用grep命令来搜索NSQ日志文件。例如,以下命令可以搜索包含“PRODUCER client_id”的记录:

        grep "PRODUCER client_id" /nsqd.log
        

        该命令将返回所有包含该关键字的记录,其中将包括客户端IP地址以及发布的消息的内容和其他相关信息。

        重新调整以快速找到所需的信息。

        注意:如果为了安全性或其他原因,NSQ节点可能没有开放容器端口到外面,这时候需要连接到容器所在的主机并进入容器内部。如果您无法进入容器,您可以通过检查客户端程序的代码或添加更多日志以捕获所需的信息。

        帖子内容中 @ChatGPT(注意前后空格,发帖后名称变色才行)。必须@才会回答

        1 条回复 最后回复
        0
        • 我是小马甲~M 在线
          我是小马甲~M 在线
          我是小马甲~
          🤫
          写于 最后由 编辑
          #5704

          @ChatGPT 阿里云云服务器,CentOS系统内看不到公网网卡。那怎么查看外网访问我的服务的公网IP?

          唐宋元明清,连排小工兵!

          ChatGPTC 1 条回复 最后回复
          0
          • 我是小马甲~M 我是小马甲~

            @ChatGPT 阿里云云服务器,CentOS系统内看不到公网网卡。那怎么查看外网访问我的服务的公网IP?

            ChatGPTC 离线
            ChatGPTC 离线
            ChatGPT
            写于 最后由 编辑
            #5705

            malaohu 说:

            @ChatGPT 阿里云云服务器,CentOS系统内看不到公网网卡。那怎么查看外网访问我的服务的公网IP?

            在阿里云云服务器内部查看到的只是它的内网IP地址,若需要查看公网IP地址,可以尝试以下方法:

            1. 执行 curl ifconfig.me 命令,会返回服务器的公网IP地址。

            2. 登录阿里云控制台,在云服务器实例详情页中,可以看到公网IP地址。

            3. 在命令行下执行 ip addr 命令可以查看系统的所有网络接口信息,其中包括公网接口的IP地址。

            4. 在阿里云控制台内,通过云监控服务查看服务器的公网IP地址。

            以上方法其中一个就可以获取到你服务器的公网IP地址了。

            帖子内容中 @ChatGPT(注意前后空格,发帖后名称变色才行)。必须@才会回答

            1 条回复 最后回复
            0
            • 我是小马甲~M 在线
              我是小马甲~M 在线
              我是小马甲~
              🤫
              写于 最后由 编辑
              #5706

              @ChatGPT CentOS7 查看所以连接的IP

              唐宋元明清,连排小工兵!

              ChatGPTC 1 条回复 最后回复
              0
              • 我是小马甲~M 我是小马甲~

                @ChatGPT CentOS7 查看所以连接的IP

                ChatGPTC 离线
                ChatGPTC 离线
                ChatGPT
                写于 最后由 编辑
                #5707

                malaohu 说:

                @ChatGPT CentOS7 查看所以连接的IP

                你可以使用 ss 命令来查看当前所有连接的 IP。

                以下是如何使用 ss 命令:

                1. 打开终端,使用 root 用户或者 sudo 身份登录。

                2. 执行 ss 命令来查看所有连接的 IP 地址:

                  ss -tuan
                  

                  该命令将会显示所有当前 TCP 和 UDP 连接的详细信息。

                  你也可以使用 grep 命令来过滤结果来仅显示 IP 地址:

                  ss -tuan | grep -E "\.*\" | awk '{print $5}' | cut -d':' -f1
                  

                  该命令将会仅显示当前所有 TCP 和 UDP 连接的 IP 地址列表。

                  值得注意的是,你需要以 root 或者 sudo 身份运行该命令才能够查看所有连接的 IP。

                帖子内容中 @ChatGPT(注意前后空格,发帖后名称变色才行)。必须@才会回答

                1 条回复 最后回复
                0
                • 我是小马甲~M 在线
                  我是小马甲~M 在线
                  我是小马甲~
                  🤫
                  写于 最后由 编辑
                  #5708

                  @ChatGPT

                  netstat -ntu | grep tcp | awk '{print $5}'
                  

                  展示IP去重

                  唐宋元明清,连排小工兵!

                  ChatGPTC 1 条回复 最后回复
                  0
                  • 我是小马甲~M 我是小马甲~

                    @ChatGPT

                    netstat -ntu | grep tcp | awk '{print $5}'
                    

                    展示IP去重

                    ChatGPTC 离线
                    ChatGPTC 离线
                    ChatGPT
                    写于 最后由 编辑
                    #5709

                    malaohu 说:

                    @ChatGPT

                    netstat -ntu | grep tcp | awk '{print $5}'
                    

                    展示IP去重

                    可以将命令修改为:

                    netstat -ntu | grep tcp | awk '{print $5}' | cut -d: -f1 | sort | uniq
                    

                    这条命令的作用是:

                    1. 通过 netstat -ntu 命令获取所有 TCP 连接的信息;
                    2. 使用 grep tcp 过滤出 TCP 连接;
                    3. 使用 awk '{print $5}' 提取出每条连接的远程 IP 和端口;
                    4. 使用 cut -d: -f1 命令将每条连接的 IP 与端口分离,只保留 IP;
                    5. 使用 sort 命令按照 IP 排序;
                    6. 使用 uniq 命令删除重复的 IP。

                    这样修改后,就可以展示去重后的 IP 列表了。

                    帖子内容中 @ChatGPT(注意前后空格,发帖后名称变色才行)。必须@才会回答

                    1 条回复 最后回复
                    0
                    • J 离线
                      J 离线
                      Joe
                      🍌
                      写于 最后由 编辑
                      #5710

                      @ChatGPT 使用js写一个三级联动的效果

                      ChatGPTC 1 条回复 最后回复
                      0
                      • J Joe

                        @ChatGPT 使用js写一个三级联动的效果

                        ChatGPTC 离线
                        ChatGPTC 离线
                        ChatGPT
                        写于 最后由 编辑
                        #5711

                        Joe 说:

                        @ChatGPT 使用js写一个三级联动的效果

                        以下是一个简单的使用JavaScript实现三级联动效果的示例代码:

                        HTML代码:

                        
                        
                        
                        

                        JavaScript代码:

                        // 省市区联动数据
                        const data = {
                          '北京市': {
                            '市辖区': ['东城区', '西城区', '朝阳区', '丰台区', '石景山区', '海淀区', '门头沟区', '房山区', '通州区', '顺义区', '昌平区', '大兴区', '怀柔区', '平谷区', '密云区', '延庆区']
                          },
                          '天津市': {
                            '市辖区': ['和平区', '河东区', '河西区', '南开区', '河北区', '红桥区', '东丽区', '西青区', '津南区', '北辰区', '武清区', '宝坻区', '滨海新区', '宁河区', '静海区', '蓟州区']
                          },
                          '河北省': {
                            '石家庄市': ['长安区', '桥西区', '新华区', '井陉矿区', '裕华区', '藁城区', '鹿泉区', '栾城区', '井陉县', '正定县', '行唐县', '灵寿县', '高邑县', '深泽县', '赞皇县', '无极县', '平山县', '元氏县', '赵县', '辛集市', '晋州市', '新乐市'],
                            '唐山市': ['路南区', '路北区', '古冶区', '开平区', '丰南区', '丰润区', '曹妃甸区', '滦县', '滦南县', '乐亭县', '迁西县', '玉田县', '遵化市', '迁安市'],
                            '秦皇岛市': ['海港区', '山海关区', '北戴河区', '抚宁区', '青龙满族自治县', '昌黎县', '卢龙县'],
                            // 其他市区数据...
                          },
                          // 其他省份数据...
                        };
                        
                        // 初始化省份数据
                        for (let province in data) {
                          let option = document.createElement('option');
                          option.value = province;
                          option.innerHTML = province;
                          document.getElementById('province').appendChild(option);
                        }
                        
                        // 省份改变时更新市区数据
                        document.getElementById('province').addEventListener('change', () => {
                          let province = document.getElementById('province').value;
                          let city_select = document.getElementById('city');
                          let district_select = document.getElementById('district');
                          city_select.innerHTML = '请选择市';
                          district_select.innerHTML = '请选择区/县';
                          for (let city in data[province]) {
                            let option = document.createElement('option');
                            option.value = city;
                            option.innerHTML = city;
                            city_select.appendChild(option);
                          }
                        });
                        
                        // 市改变时更新区县数据
                        document.getElementById('city').addEventListener('change', () => {
                          let province = document.getElementById('province').value;
                          let city = document.getElementById('city').value;
                          let district_select = document.getElementById('district');
                          district_select.innerHTML = '请选择区/县';
                          for (let district of data[province][city]) {
                            let option = document.createElement('option');
                            option.value = district;
                            option.innerHTML = district;
                            district_select.appendChild(option);
                          }
                        });
                        

                        这段代码实现了三级联动的效果,基本思路是初始化省份数据,当省份改变时更新市区数据,当市改变时更新区县数据。因为数据较多,所以采用了对象来存储,其中省份数据为对象的属性,每个市区及县数据为对象的值。

                        帖子内容中 @ChatGPT(注意前后空格,发帖后名称变色才行)。必须@才会回答

                        1 条回复 最后回复
                        0
                        • 我是小马甲~M 在线
                          我是小马甲~M 在线
                          我是小马甲~
                          🤫
                          写于 最后由 编辑
                          #5712
                          // KeyGen-editplus.cpp : 定义控制台应用程序的入口点。
                          //
                          #include "stdafx.h"
                          #include <windows.h>
                          #include <time.h>
                          char ReChar(char ch);
                          char DeCodeChar(char ch);
                          void GetDReg05Code(char* pUserName, int ulen);
                          unsigned short* CreateTable();
                          void RandonRegCode(char* pRegCode, int rLen, char* pAsc, int aLen);
                          char* FomartStr(char* str, WORD sNum);
                          WORD  SearchTable(int nNum, char* pCUserName, int len);
                          int  SprintfChars(char* pUserName, int len, char* pCUserName, int nNum);
                          
                          
                          char ch5 = {};
                          unsigned short* pTable = {};
                          int _tmain(int argc, _TCHAR* argv[])
                          {
                          	srand((unsigned)time(NULL));
                          	char AscArry[36] = { 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
                          		0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A,
                          		0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54,
                          		0x55, 0x56, 0x57, 0x58, 0x59, 0x5A };
                          	char RegCode[29] = {};
                          	char DRegCode[29] = {};
                          	char UserName[10] = {};
                          
                          	RandonRegCode(RegCode, 29, AscArry, 36);
                          	printf("input Name:");
                          	scanf_s("%s", UserName, 10);
                          	int ulen = strlen(UserName);
                          	int rlen = _countof(RegCode);
                          	pTable = CreateTable();
                          	char* pAscii = (char*)malloc(sizeof(char) * 3000);
                          
                          	int slen = SprintfChars(UserName, ulen, pAscii, 3000);
                          	WORD sNum = SearchTable(0, pAscii, slen);
                          	char* pCNum = (char*)malloc(sizeof(char) * 10);
                          	FomartStr(pCNum, sNum);
                          	GetDReg05Code(UserName, ulen);
                          	RegCode[2] = ReChar(pCNum[0]);
                          	RegCode[3] = ReChar(pCNum[1]);
                          	RegCode[4] = ReChar(ch5);
                          	for (int i = 0; i < 29; i++)
                          	{
                          		if ((i + 1) % 6)
                          		{
                          			char ret = DeCodeChar(RegCode[i]);
                          			ret >>= 1;
                          			if (ret >= 10)
                          				DRegCode[i] = ret + 55;
                          			else
                          				DRegCode[i] = ret + 48;
                          		}
                          		else
                          			DRegCode[i] = 0x2D;
                          	}
                          	slen = SprintfChars(DRegCode + 2, rlen - 2, pAscii, 3000);
                          	sNum = SearchTable(0, pAscii, slen);
                          	FomartStr(pCNum, sNum);
                          	RegCode[0] = ReChar(pCNum[0]);
                          	RegCode[1] = ReChar(pCNum[1]);
                          	printf("RegCode:");
                          	for (int i = 0; i < 29; i++)
                          	{
                          		printf("%C", RegCode[i]);
                          	}
                          	system("pause");
                          	return 0;
                          }
                          int SprintfChars(char* pUserName, int len, char* pCUserName, int nNum)
                          {
                          	int ret;
                          	int i = 0;
                          	int j = 0;
                          	if (len <= 0)
                          	{
                          		pCUserName = NULL;
                          		ret = 0;
                          	}
                          	else
                          	{
                          		while (j < len)
                          		{
                          			sprintf_s(&pCUserName[i], nNum - i, "%04X", pUserName[j++]);
                          			i += 4;
                          		}
                          		pCUserName[i] = 0;
                          		ret = i;
                          	}
                          	return ret;
                          }
                          WORD SearchTable(int nNum, char* pCUserName, int len)
                          {
                          	WORD ret;
                          	int index;
                          	char* p = pCUserName;
                          	if (len <= 0)
                          	{
                          		ret = nNum;
                          	}
                          	else
                          	{
                          		ret = nNum;
                          		while (p < pCUserName + len)
                          		{
                          			index = *p++^LOBYTE(ret);
                          			ret = pTable[index] ^ (ret >> 8);
                          		}
                          	}
                          	return ret;
                          }
                          char* FomartStr(char* str, WORD sNum)
                          {
                          	sprintf_s(str, 10, "%04X", sNum);
                          	return str;
                          }
                          unsigned short* CreateTable()
                          {
                          	unsigned short * pTable = (unsigned short *)malloc(0x200);
                          	memset(pTable, 0, 0x200);
                          	for (int i = 0; i < 0x100; i++)
                          	{
                          		int j = 1;
                          		unsigned short eax = 0xC0C1;
                          		while (j < 0x100)
                          		{
                          			//test edx,ecx;
                          			if (i&j)
                          				pTable[i] ^= eax;
                          			eax += eax;
                          			eax ^= 0x4003;
                          			j += j;
                          		}
                          	}
                          	return pTable;
                          }
                          
                          char ReChar(char ch)
                          {
                          	char arr[] = { 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
                          		0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
                          		0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A };
                          	int len = _countof(arr);
                          	for (int i = 0; i < len; i++)
                          	{
                          		char tmp;
                          		char ret = DeCodeChar(arr[i]);
                          		ret >>= 1;
                          		if (ret >= 10)
                          			tmp = ret + 55;
                          		else
                          			tmp = ret + 48;
                          		if (tmp == ch)
                          		{
                          			return arr[i];
                          		}
                          	}
                          }
                          char DeCodeChar(char ch)
                          {
                          	//except:I/O
                          	char chArry[] =
                          	{
                          		50, 51, 52, 53,//	2,3,4,5,
                          		54, 55, 56, 57,//	6,7,8,9,
                          		65, 66, 67, 68,//	A,B,C,D,
                          		69, 70, 71, 72,//	E,F,G,H,
                          		74, 75, 76, 77,//	J,K,L,M,
                          		78, 80, 81, 82,//	N,P,Q,R,
                          		83, 84, 85, 86,//	S,T,U,V,
                          		87, 88, 89, 90 //	W,X,Y,Z		
                          	};
                          
                          	char ret = 0;
                          	int v1 = 2;
                          	char* p = &chArry[1];
                          	while (v1 - 2 < 32)
                          	{
                          		if (ch == *(p - 1))
                          			ret = v1 - 2;
                          		if (ch == *(p))
                          			ret = v1 - 1;
                          		if (ch == *(p + 1))
                          			ret = v1;
                          		if (ch == *(p + 2))
                          			ret = v1 + 1;
                          		p += 4;
                          		v1 += 4;
                          	}
                          	return ret;
                          }
                          
                          
                          void GetDReg05Code(char* pUserName, int ulen)
                          {
                          	int nNum01 = 0;
                          	int nNum02 = 0;
                          	int nNum03 = 1;
                          	int i = 0;
                          	while (i < ulen - 1)
                          	{
                          		nNum01 += pUserName[i];
                          		nNum02 += pUserName[i + 1];
                          		i += 2;
                          	}
                          	if (i < ulen)
                          		nNum03 = pUserName[i] + 1;
                          	sprintf_s(&ch5, 2, "%01X", ((9 * (nNum01 + nNum02 + nNum03) + 0xA) / 3 + 36) % 16);
                          }
                          void RandonRegCode(char* pRegCode, int rLen, char* pAsc, int aLen)
                          {
                          	for (int i = 0; i < rLen; i++)
                          	{
                          		if ((i + 1) % 6 == 0)
                          			pRegCode[i] = 0x2D;
                          		else
                          			pRegCode[i] = pAsc[rand() % aLen];
                          	}
                          }
                          
                          

                          @ChatGPT 以上代码请用javascript 实现一下

                          唐宋元明清,连排小工兵!

                          ChatGPTC 我是小马甲~M 2 条回复 最后回复
                          0
                          • 我是小马甲~M 我是小马甲~
                            // KeyGen-editplus.cpp : 定义控制台应用程序的入口点。
                            //
                            #include "stdafx.h"
                            #include <windows.h>
                            #include <time.h>
                            char ReChar(char ch);
                            char DeCodeChar(char ch);
                            void GetDReg05Code(char* pUserName, int ulen);
                            unsigned short* CreateTable();
                            void RandonRegCode(char* pRegCode, int rLen, char* pAsc, int aLen);
                            char* FomartStr(char* str, WORD sNum);
                            WORD  SearchTable(int nNum, char* pCUserName, int len);
                            int  SprintfChars(char* pUserName, int len, char* pCUserName, int nNum);
                            
                            
                            char ch5 = {};
                            unsigned short* pTable = {};
                            int _tmain(int argc, _TCHAR* argv[])
                            {
                            	srand((unsigned)time(NULL));
                            	char AscArry[36] = { 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
                            		0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A,
                            		0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54,
                            		0x55, 0x56, 0x57, 0x58, 0x59, 0x5A };
                            	char RegCode[29] = {};
                            	char DRegCode[29] = {};
                            	char UserName[10] = {};
                            
                            	RandonRegCode(RegCode, 29, AscArry, 36);
                            	printf("input Name:");
                            	scanf_s("%s", UserName, 10);
                            	int ulen = strlen(UserName);
                            	int rlen = _countof(RegCode);
                            	pTable = CreateTable();
                            	char* pAscii = (char*)malloc(sizeof(char) * 3000);
                            
                            	int slen = SprintfChars(UserName, ulen, pAscii, 3000);
                            	WORD sNum = SearchTable(0, pAscii, slen);
                            	char* pCNum = (char*)malloc(sizeof(char) * 10);
                            	FomartStr(pCNum, sNum);
                            	GetDReg05Code(UserName, ulen);
                            	RegCode[2] = ReChar(pCNum[0]);
                            	RegCode[3] = ReChar(pCNum[1]);
                            	RegCode[4] = ReChar(ch5);
                            	for (int i = 0; i < 29; i++)
                            	{
                            		if ((i + 1) % 6)
                            		{
                            			char ret = DeCodeChar(RegCode[i]);
                            			ret >>= 1;
                            			if (ret >= 10)
                            				DRegCode[i] = ret + 55;
                            			else
                            				DRegCode[i] = ret + 48;
                            		}
                            		else
                            			DRegCode[i] = 0x2D;
                            	}
                            	slen = SprintfChars(DRegCode + 2, rlen - 2, pAscii, 3000);
                            	sNum = SearchTable(0, pAscii, slen);
                            	FomartStr(pCNum, sNum);
                            	RegCode[0] = ReChar(pCNum[0]);
                            	RegCode[1] = ReChar(pCNum[1]);
                            	printf("RegCode:");
                            	for (int i = 0; i < 29; i++)
                            	{
                            		printf("%C", RegCode[i]);
                            	}
                            	system("pause");
                            	return 0;
                            }
                            int SprintfChars(char* pUserName, int len, char* pCUserName, int nNum)
                            {
                            	int ret;
                            	int i = 0;
                            	int j = 0;
                            	if (len <= 0)
                            	{
                            		pCUserName = NULL;
                            		ret = 0;
                            	}
                            	else
                            	{
                            		while (j < len)
                            		{
                            			sprintf_s(&pCUserName[i], nNum - i, "%04X", pUserName[j++]);
                            			i += 4;
                            		}
                            		pCUserName[i] = 0;
                            		ret = i;
                            	}
                            	return ret;
                            }
                            WORD SearchTable(int nNum, char* pCUserName, int len)
                            {
                            	WORD ret;
                            	int index;
                            	char* p = pCUserName;
                            	if (len <= 0)
                            	{
                            		ret = nNum;
                            	}
                            	else
                            	{
                            		ret = nNum;
                            		while (p < pCUserName + len)
                            		{
                            			index = *p++^LOBYTE(ret);
                            			ret = pTable[index] ^ (ret >> 8);
                            		}
                            	}
                            	return ret;
                            }
                            char* FomartStr(char* str, WORD sNum)
                            {
                            	sprintf_s(str, 10, "%04X", sNum);
                            	return str;
                            }
                            unsigned short* CreateTable()
                            {
                            	unsigned short * pTable = (unsigned short *)malloc(0x200);
                            	memset(pTable, 0, 0x200);
                            	for (int i = 0; i < 0x100; i++)
                            	{
                            		int j = 1;
                            		unsigned short eax = 0xC0C1;
                            		while (j < 0x100)
                            		{
                            			//test edx,ecx;
                            			if (i&j)
                            				pTable[i] ^= eax;
                            			eax += eax;
                            			eax ^= 0x4003;
                            			j += j;
                            		}
                            	}
                            	return pTable;
                            }
                            
                            char ReChar(char ch)
                            {
                            	char arr[] = { 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
                            		0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
                            		0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A };
                            	int len = _countof(arr);
                            	for (int i = 0; i < len; i++)
                            	{
                            		char tmp;
                            		char ret = DeCodeChar(arr[i]);
                            		ret >>= 1;
                            		if (ret >= 10)
                            			tmp = ret + 55;
                            		else
                            			tmp = ret + 48;
                            		if (tmp == ch)
                            		{
                            			return arr[i];
                            		}
                            	}
                            }
                            char DeCodeChar(char ch)
                            {
                            	//except:I/O
                            	char chArry[] =
                            	{
                            		50, 51, 52, 53,//	2,3,4,5,
                            		54, 55, 56, 57,//	6,7,8,9,
                            		65, 66, 67, 68,//	A,B,C,D,
                            		69, 70, 71, 72,//	E,F,G,H,
                            		74, 75, 76, 77,//	J,K,L,M,
                            		78, 80, 81, 82,//	N,P,Q,R,
                            		83, 84, 85, 86,//	S,T,U,V,
                            		87, 88, 89, 90 //	W,X,Y,Z		
                            	};
                            
                            	char ret = 0;
                            	int v1 = 2;
                            	char* p = &chArry[1];
                            	while (v1 - 2 < 32)
                            	{
                            		if (ch == *(p - 1))
                            			ret = v1 - 2;
                            		if (ch == *(p))
                            			ret = v1 - 1;
                            		if (ch == *(p + 1))
                            			ret = v1;
                            		if (ch == *(p + 2))
                            			ret = v1 + 1;
                            		p += 4;
                            		v1 += 4;
                            	}
                            	return ret;
                            }
                            
                            
                            void GetDReg05Code(char* pUserName, int ulen)
                            {
                            	int nNum01 = 0;
                            	int nNum02 = 0;
                            	int nNum03 = 1;
                            	int i = 0;
                            	while (i < ulen - 1)
                            	{
                            		nNum01 += pUserName[i];
                            		nNum02 += pUserName[i + 1];
                            		i += 2;
                            	}
                            	if (i < ulen)
                            		nNum03 = pUserName[i] + 1;
                            	sprintf_s(&ch5, 2, "%01X", ((9 * (nNum01 + nNum02 + nNum03) + 0xA) / 3 + 36) % 16);
                            }
                            void RandonRegCode(char* pRegCode, int rLen, char* pAsc, int aLen)
                            {
                            	for (int i = 0; i < rLen; i++)
                            	{
                            		if ((i + 1) % 6 == 0)
                            			pRegCode[i] = 0x2D;
                            		else
                            			pRegCode[i] = pAsc[rand() % aLen];
                            	}
                            }
                            
                            

                            @ChatGPT 以上代码请用javascript 实现一下

                            ChatGPTC 离线
                            ChatGPTC 离线
                            ChatGPT
                            写于 最后由 编辑
                            #5713

                            malaohu 说:

                            // KeyGen-editplus.cpp : 定义控制台应用程序的入口点。
                            //
                            #include "stdafx.h"
                            #include 
                            #include 
                            char ReChar(char ch);
                            char DeCodeChar(char ch);
                            void GetDReg05Code(char* pUserName, int ulen);
                            unsigned short* CreateTable();
                            void RandonRegCode(char* pRegCode, int rLen, char* pAsc, int aLen);
                            char* FomartStr(char* str, WORD sNum);
                            WORD  SearchTable(int nNum, char* pCUserName, int len);
                            int  SprintfChars(char* pUserName, int len, char* pCUserName, int nNum);
                            
                            
                            char ch5 = {};
                            unsigned short* pTable = {};
                            int _tmain(int argc, _TCHAR* argv[])
                            {
                            	srand((unsigned)time(NULL));
                            	char AscArry[36] = { 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
                            		0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A,
                            		0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54,
                            		0x55, 0x56, 0x57, 0x58, 0x59, 0x5A };
                            	char RegCode[29] = {};
                            	char DRegCode[29] = {};
                            	char UserName[10] = {};
                            
                            	RandonRegCode(RegCode, 29, AscArry, 36);
                            	printf("input Name:");
                            	scanf_s("%s", UserName, 10);
                            	int ulen = strlen(UserName);
                            	int rlen = _countof(RegCode);
                            	pTable = CreateTable();
                            	char* pAscii = (char*)malloc(sizeof(char) * 3000);
                            
                            	int slen = SprintfChars(UserName, ulen, pAscii, 3000);
                            	WORD sNum = SearchTable(0, pAscii, slen);
                            	char* pCNum = (char*)malloc(sizeof(char) * 10);
                            	FomartStr(pCNum, sNum);
                            	GetDReg05Code(UserName, ulen);
                            	RegCode[2] = ReChar(pCNum[0]);
                            	RegCode[3] = ReChar(pCNum[1]);
                            	RegCode[4] = ReChar(ch5);
                            	for (int i = 0; i  	{
                            		if ((i + 1) % 6)
                            		{
                            			char ret = DeCodeChar(RegCode[i]);
                            			ret >>= 1;
                            			if (ret >= 10)
                            				DRegCode[i] = ret + 55;
                            			else
                            				DRegCode[i] = ret + 48;
                            		}
                            		else
                            			DRegCode[i] = 0x2D;
                            	}
                            	slen = SprintfChars(DRegCode + 2, rlen - 2, pAscii, 3000);
                            	sNum = SearchTable(0, pAscii, slen);
                            	FomartStr(pCNum, sNum);
                            	RegCode[0] = ReChar(pCNum[0]);
                            	RegCode[1] = ReChar(pCNum[1]);
                            	printf("RegCode:");
                            	for (int i = 0; i  	{
                            		printf("%C", RegCode[i]);
                            	}
                            	system("pause");
                            	return 0;
                            }
                            int SprintfChars(char* pUserName, int len, char* pCUserName, int nNum)
                            {
                            	int ret;
                            	int i = 0;
                            	int j = 0;
                            	if (len  	{
                            		pCUserName = NULL;
                            		ret = 0;
                            	}
                            	else
                            	{
                            		while (j  		{
                            			sprintf_s(&pCUserName[i], nNum - i, "%04X", pUserName[j++]);
                            			i += 4;
                            		}
                            		pCUserName[i] = 0;
                            		ret = i;
                            	}
                            	return ret;
                            }
                            WORD SearchTable(int nNum, char* pCUserName, int len)
                            {
                            	WORD ret;
                            	int index;
                            	char* p = pCUserName;
                            	if (len  	{
                            		ret = nNum;
                            	}
                            	else
                            	{
                            		ret = nNum;
                            		while (p  		{
                            			index = *p++^LOBYTE(ret);
                            			ret = pTable[index] ^ (ret >> 8);
                            		}
                            	}
                            	return ret;
                            }
                            char* FomartStr(char* str, WORD sNum)
                            {
                            	sprintf_s(str, 10, "%04X", sNum);
                            	return str;
                            }
                            unsigned short* CreateTable()
                            {
                            	unsigned short * pTable = (unsigned short *)malloc(0x200);
                            	memset(pTable, 0, 0x200);
                            	for (int i = 0; i  	{
                            		int j = 1;
                            		unsigned short eax = 0xC0C1;
                            		while (j  		{
                            			//test edx,ecx;
                            			if (i&j)
                            				pTable[i] ^= eax;
                            			eax += eax;
                            			eax ^= 0x4003;
                            			j += j;
                            		}
                            	}
                            	return pTable;
                            }
                            
                            char ReChar(char ch)
                            {
                            	char arr[] = { 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
                            		0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
                            		0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A };
                            	int len = _countof(arr);
                            	for (int i = 0; i  	{
                            		char tmp;
                            		char ret = DeCodeChar(arr[i]);
                            		ret >>= 1;
                            		if (ret >= 10)
                            			tmp = ret + 55;
                            		else
                            			tmp = ret + 48;
                            		if (tmp == ch)
                            		{
                            			return arr[i];
                            		}
                            	}
                            }
                            char DeCodeChar(char ch)
                            {
                            	//except:I/O
                            	char chArry[] =
                            	{
                            		50, 51, 52, 53,//	2,3,4,5,
                            		54, 55, 56, 57,//	6,7,8,9,
                            		65, 66, 67, 68,//	A,B,C,D,
                            		69, 70, 71, 72,//	E,F,G,H,
                            		74, 75, 76, 77,//	J,K,L,M,
                            		78, 80, 81, 82,//	N,P,Q,R,
                            		83, 84, 85, 86,//	S,T,U,V,
                            		87, 88, 89, 90 //	W,X,Y,Z		
                            	};
                            
                            	char ret = 0;
                            	int v1 = 2;
                            	char* p = &chArry[1];
                            	while (v1 - 2  	{
                            		if (ch == *(p - 1))
                            			ret = v1 - 2;
                            		if (ch == *(p))
                            			ret = v1 - 1;
                            		if (ch == *(p + 1))
                            			ret = v1;
                            		if (ch == *(p + 2))
                            			ret = v1 + 1;
                            		p += 4;
                            		v1 += 4;
                            	}
                            	return ret;
                            }
                            
                            
                            void GetDReg05Code(char* pUserName, int ulen)
                            {
                            	int nNum01 = 0;
                            	int nNum02 = 0;
                            	int nNum03 = 1;
                            	int i = 0;
                            	while (i  	{
                            		nNum01 += pUserName[i];
                            		nNum02 += pUserName[i + 1];
                            		i += 2;
                            	}
                            	if (i  		nNum03 = pUserName[i] + 1;
                            	sprintf_s(&ch5, 2, "%01X", ((9 * (nNum01 + nNum02 + nNum03) + 0xA) / 3 + 36) % 16);
                            }
                            void RandonRegCode(char* pRegCode, int rLen, char* pAsc, int aLen)
                            {
                            	for (int i = 0; i  	{
                            		if ((i + 1) % 6 == 0)
                            			pRegCode[i] = 0x2D;
                            		else
                            			pRegCode[i] = pAsc[rand() % aLen];
                            	}
                            }
                            
                            

                            @ChatGPT 以上代码请用javascript 实现一下

                            哎呀, OpenAI接口可能出问题了,请稍后再试!我这就PM站长~ @malaohu

                            帖子内容中 @ChatGPT(注意前后空格,发帖后名称变色才行)。必须@才会回答

                            1 条回复 最后回复
                            0
                            • 我是小马甲~M 我是小马甲~
                              // KeyGen-editplus.cpp : 定义控制台应用程序的入口点。
                              //
                              #include "stdafx.h"
                              #include <windows.h>
                              #include <time.h>
                              char ReChar(char ch);
                              char DeCodeChar(char ch);
                              void GetDReg05Code(char* pUserName, int ulen);
                              unsigned short* CreateTable();
                              void RandonRegCode(char* pRegCode, int rLen, char* pAsc, int aLen);
                              char* FomartStr(char* str, WORD sNum);
                              WORD  SearchTable(int nNum, char* pCUserName, int len);
                              int  SprintfChars(char* pUserName, int len, char* pCUserName, int nNum);
                              
                              
                              char ch5 = {};
                              unsigned short* pTable = {};
                              int _tmain(int argc, _TCHAR* argv[])
                              {
                              	srand((unsigned)time(NULL));
                              	char AscArry[36] = { 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
                              		0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A,
                              		0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54,
                              		0x55, 0x56, 0x57, 0x58, 0x59, 0x5A };
                              	char RegCode[29] = {};
                              	char DRegCode[29] = {};
                              	char UserName[10] = {};
                              
                              	RandonRegCode(RegCode, 29, AscArry, 36);
                              	printf("input Name:");
                              	scanf_s("%s", UserName, 10);
                              	int ulen = strlen(UserName);
                              	int rlen = _countof(RegCode);
                              	pTable = CreateTable();
                              	char* pAscii = (char*)malloc(sizeof(char) * 3000);
                              
                              	int slen = SprintfChars(UserName, ulen, pAscii, 3000);
                              	WORD sNum = SearchTable(0, pAscii, slen);
                              	char* pCNum = (char*)malloc(sizeof(char) * 10);
                              	FomartStr(pCNum, sNum);
                              	GetDReg05Code(UserName, ulen);
                              	RegCode[2] = ReChar(pCNum[0]);
                              	RegCode[3] = ReChar(pCNum[1]);
                              	RegCode[4] = ReChar(ch5);
                              	for (int i = 0; i < 29; i++)
                              	{
                              		if ((i + 1) % 6)
                              		{
                              			char ret = DeCodeChar(RegCode[i]);
                              			ret >>= 1;
                              			if (ret >= 10)
                              				DRegCode[i] = ret + 55;
                              			else
                              				DRegCode[i] = ret + 48;
                              		}
                              		else
                              			DRegCode[i] = 0x2D;
                              	}
                              	slen = SprintfChars(DRegCode + 2, rlen - 2, pAscii, 3000);
                              	sNum = SearchTable(0, pAscii, slen);
                              	FomartStr(pCNum, sNum);
                              	RegCode[0] = ReChar(pCNum[0]);
                              	RegCode[1] = ReChar(pCNum[1]);
                              	printf("RegCode:");
                              	for (int i = 0; i < 29; i++)
                              	{
                              		printf("%C", RegCode[i]);
                              	}
                              	system("pause");
                              	return 0;
                              }
                              int SprintfChars(char* pUserName, int len, char* pCUserName, int nNum)
                              {
                              	int ret;
                              	int i = 0;
                              	int j = 0;
                              	if (len <= 0)
                              	{
                              		pCUserName = NULL;
                              		ret = 0;
                              	}
                              	else
                              	{
                              		while (j < len)
                              		{
                              			sprintf_s(&pCUserName[i], nNum - i, "%04X", pUserName[j++]);
                              			i += 4;
                              		}
                              		pCUserName[i] = 0;
                              		ret = i;
                              	}
                              	return ret;
                              }
                              WORD SearchTable(int nNum, char* pCUserName, int len)
                              {
                              	WORD ret;
                              	int index;
                              	char* p = pCUserName;
                              	if (len <= 0)
                              	{
                              		ret = nNum;
                              	}
                              	else
                              	{
                              		ret = nNum;
                              		while (p < pCUserName + len)
                              		{
                              			index = *p++^LOBYTE(ret);
                              			ret = pTable[index] ^ (ret >> 8);
                              		}
                              	}
                              	return ret;
                              }
                              char* FomartStr(char* str, WORD sNum)
                              {
                              	sprintf_s(str, 10, "%04X", sNum);
                              	return str;
                              }
                              unsigned short* CreateTable()
                              {
                              	unsigned short * pTable = (unsigned short *)malloc(0x200);
                              	memset(pTable, 0, 0x200);
                              	for (int i = 0; i < 0x100; i++)
                              	{
                              		int j = 1;
                              		unsigned short eax = 0xC0C1;
                              		while (j < 0x100)
                              		{
                              			//test edx,ecx;
                              			if (i&j)
                              				pTable[i] ^= eax;
                              			eax += eax;
                              			eax ^= 0x4003;
                              			j += j;
                              		}
                              	}
                              	return pTable;
                              }
                              
                              char ReChar(char ch)
                              {
                              	char arr[] = { 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
                              		0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
                              		0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A };
                              	int len = _countof(arr);
                              	for (int i = 0; i < len; i++)
                              	{
                              		char tmp;
                              		char ret = DeCodeChar(arr[i]);
                              		ret >>= 1;
                              		if (ret >= 10)
                              			tmp = ret + 55;
                              		else
                              			tmp = ret + 48;
                              		if (tmp == ch)
                              		{
                              			return arr[i];
                              		}
                              	}
                              }
                              char DeCodeChar(char ch)
                              {
                              	//except:I/O
                              	char chArry[] =
                              	{
                              		50, 51, 52, 53,//	2,3,4,5,
                              		54, 55, 56, 57,//	6,7,8,9,
                              		65, 66, 67, 68,//	A,B,C,D,
                              		69, 70, 71, 72,//	E,F,G,H,
                              		74, 75, 76, 77,//	J,K,L,M,
                              		78, 80, 81, 82,//	N,P,Q,R,
                              		83, 84, 85, 86,//	S,T,U,V,
                              		87, 88, 89, 90 //	W,X,Y,Z		
                              	};
                              
                              	char ret = 0;
                              	int v1 = 2;
                              	char* p = &chArry[1];
                              	while (v1 - 2 < 32)
                              	{
                              		if (ch == *(p - 1))
                              			ret = v1 - 2;
                              		if (ch == *(p))
                              			ret = v1 - 1;
                              		if (ch == *(p + 1))
                              			ret = v1;
                              		if (ch == *(p + 2))
                              			ret = v1 + 1;
                              		p += 4;
                              		v1 += 4;
                              	}
                              	return ret;
                              }
                              
                              
                              void GetDReg05Code(char* pUserName, int ulen)
                              {
                              	int nNum01 = 0;
                              	int nNum02 = 0;
                              	int nNum03 = 1;
                              	int i = 0;
                              	while (i < ulen - 1)
                              	{
                              		nNum01 += pUserName[i];
                              		nNum02 += pUserName[i + 1];
                              		i += 2;
                              	}
                              	if (i < ulen)
                              		nNum03 = pUserName[i] + 1;
                              	sprintf_s(&ch5, 2, "%01X", ((9 * (nNum01 + nNum02 + nNum03) + 0xA) / 3 + 36) % 16);
                              }
                              void RandonRegCode(char* pRegCode, int rLen, char* pAsc, int aLen)
                              {
                              	for (int i = 0; i < rLen; i++)
                              	{
                              		if ((i + 1) % 6 == 0)
                              			pRegCode[i] = 0x2D;
                              		else
                              			pRegCode[i] = pAsc[rand() % aLen];
                              	}
                              }
                              
                              

                              @ChatGPT 以上代码请用javascript 实现一下

                              我是小马甲~M 在线
                              我是小马甲~M 在线
                              我是小马甲~
                              🤫
                              写于 最后由 编辑
                              #5714

                              malaohu 说:

                              // KeyGen-editplus.cpp : 定义控制台应用程序的入口点。
                              //
                              #include "stdafx.h"
                              #include <windows.h>
                              #include <time.h>
                              char ReChar(char ch);
                              char DeCodeChar(char ch);
                              void GetDReg05Code(char* pUserName, int ulen);
                              unsigned short* CreateTable();
                              void RandonRegCode(char* pRegCode, int rLen, char* pAsc, int aLen);
                              char* FomartStr(char* str, WORD sNum);
                              WORD  SearchTable(int nNum, char* pCUserName, int len);
                              int  SprintfChars(char* pUserName, int len, char* pCUserName, int nNum);
                              
                              
                              char ch5 = {};
                              unsigned short* pTable = {};
                              int _tmain(int argc, _TCHAR* argv[])
                              {
                              	srand((unsigned)time(NULL));
                              	char AscArry[36] = { 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
                              		0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A,
                              		0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54,
                              		0x55, 0x56, 0x57, 0x58, 0x59, 0x5A };
                              	char RegCode[29] = {};
                              	char DRegCode[29] = {};
                              	char UserName[10] = {};
                              
                              	RandonRegCode(RegCode, 29, AscArry, 36);
                              	printf("input Name:");
                              	scanf_s("%s", UserName, 10);
                              	int ulen = strlen(UserName);
                              	int rlen = _countof(RegCode);
                              	pTable = CreateTable();
                              	char* pAscii = (char*)malloc(sizeof(char) * 3000);
                              
                              	int slen = SprintfChars(UserName, ulen, pAscii, 3000);
                              	WORD sNum = SearchTable(0, pAscii, slen);
                              	char* pCNum = (char*)malloc(sizeof(char) * 10);
                              	FomartStr(pCNum, sNum);
                              	GetDReg05Code(UserName, ulen);
                              	RegCode[2] = ReChar(pCNum[0]);
                              	RegCode[3] = ReChar(pCNum[1]);
                              	RegCode[4] = ReChar(ch5);
                              	for (int i = 0; i < 29; i++)
                              	{
                              		if ((i + 1) % 6)
                              		{
                              			char ret = DeCodeChar(RegCode[i]);
                              			ret >>= 1;
                              			if (ret >= 10)
                              				DRegCode[i] = ret + 55;
                              			else
                              				DRegCode[i] = ret + 48;
                              		}
                              		else
                              			DRegCode[i] = 0x2D;
                              	}
                              	slen = SprintfChars(DRegCode + 2, rlen - 2, pAscii, 3000);
                              	sNum = SearchTable(0, pAscii, slen);
                              	FomartStr(pCNum, sNum);
                              	RegCode[0] = ReChar(pCNum[0]);
                              	RegCode[1] = ReChar(pCNum[1]);
                              	printf("RegCode:");
                              	for (int i = 0; i < 29; i++)
                              	{
                              		printf("%C", RegCode[i]);
                              	}
                              	system("pause");
                              	return 0;
                              }
                              int SprintfChars(char* pUserName, int len, char* pCUserName, int nNum)
                              {
                              	int ret;
                              	int i = 0;
                              	int j = 0;
                              	if (len <= 0)
                              	{
                              		pCUserName = NULL;
                              		ret = 0;
                              	}
                              	else
                              	{
                              		while (j < len)
                              		{
                              			sprintf_s(&pCUserName[i], nNum - i, "%04X", pUserName[j++]);
                              			i += 4;
                              		}
                              		pCUserName[i] = 0;
                              		ret = i;
                              	}
                              	return ret;
                              }
                              WORD SearchTable(int nNum, char* pCUserName, int len)
                              {
                              	WORD ret;
                              	int index;
                              	char* p = pCUserName;
                              	if (len <= 0)
                              	{
                              		ret = nNum;
                              	}
                              	else
                              	{
                              		ret = nNum;
                              		while (p < pCUserName + len)
                              		{
                              			index = *p++^LOBYTE(ret);
                              			ret = pTable[index] ^ (ret >> 8);
                              		}
                              	}
                              	return ret;
                              }
                              char* FomartStr(char* str, WORD sNum)
                              {
                              	sprintf_s(str, 10, "%04X", sNum);
                              	return str;
                              }
                              unsigned short* CreateTable()
                              {
                              	unsigned short * pTable = (unsigned short *)malloc(0x200);
                              	memset(pTable, 0, 0x200);
                              	for (int i = 0; i < 0x100; i++)
                              	{
                              		int j = 1;
                              		unsigned short eax = 0xC0C1;
                              		while (j < 0x100)
                              		{
                              			//test edx,ecx;
                              			if (i&j)
                              				pTable[i] ^= eax;
                              			eax += eax;
                              			eax ^= 0x4003;
                              			j += j;
                              		}
                              	}
                              	return pTable;
                              }
                              
                              char ReChar(char ch)
                              {
                              	char arr[] = { 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
                              		0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
                              		0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A };
                              	int len = _countof(arr);
                              	for (int i = 0; i < len; i++)
                              	{
                              		char tmp;
                              		char ret = DeCodeChar(arr[i]);
                              		ret >>= 1;
                              		if (ret >= 10)
                              			tmp = ret + 55;
                              		else
                              			tmp = ret + 48;
                              		if (tmp == ch)
                              		{
                              			return arr[i];
                              		}
                              	}
                              }
                              char DeCodeChar(char ch)
                              {
                              	//except:I/O
                              	char chArry[] =
                              	{
                              		50, 51, 52, 53,//	2,3,4,5,
                              		54, 55, 56, 57,//	6,7,8,9,
                              		65, 66, 67, 68,//	A,B,C,D,
                              		69, 70, 71, 72,//	E,F,G,H,
                              		74, 75, 76, 77,//	J,K,L,M,
                              		78, 80, 81, 82,//	N,P,Q,R,
                              		83, 84, 85, 86,//	S,T,U,V,
                              		87, 88, 89, 90 //	W,X,Y,Z		
                              	};
                              
                              	char ret = 0;
                              	int v1 = 2;
                              	char* p = &chArry[1];
                              	while (v1 - 2 < 32)
                              	{
                              		if (ch == *(p - 1))
                              			ret = v1 - 2;
                              		if (ch == *(p))
                              			ret = v1 - 1;
                              		if (ch == *(p + 1))
                              			ret = v1;
                              		if (ch == *(p + 2))
                              			ret = v1 + 1;
                              		p += 4;
                              		v1 += 4;
                              	}
                              	return ret;
                              }
                              
                              
                              void GetDReg05Code(char* pUserName, int ulen)
                              {
                              	int nNum01 = 0;
                              	int nNum02 = 0;
                              	int nNum03 = 1;
                              	int i = 0;
                              	while (i < ulen - 1)
                              	{
                              		nNum01 += pUserName[i];
                              		nNum02 += pUserName[i + 1];
                              		i += 2;
                              	}
                              	if (i < ulen)
                              		nNum03 = pUserName[i] + 1;
                              	sprintf_s(&ch5, 2, "%01X", ((9 * (nNum01 + nNum02 + nNum03) + 0xA) / 3 + 36) % 16);
                              }
                              void RandonRegCode(char* pRegCode, int rLen, char* pAsc, int aLen)
                              {
                              	for (int i = 0; i < rLen; i++)
                              	{
                              		if ((i + 1) % 6 == 0)
                              			pRegCode[i] = 0x2D;
                              		else
                              			pRegCode[i] = pAsc[rand() % aLen];
                              	}
                              }
                              
                              

                              @ChatGPT 以上代码请用javascript 实现一下

                              唐宋元明清,连排小工兵!

                              ChatGPTC 1 条回复 最后回复
                              0
                              • 我是小马甲~M 我是小马甲~

                                malaohu 说:

                                // KeyGen-editplus.cpp : 定义控制台应用程序的入口点。
                                //
                                #include "stdafx.h"
                                #include <windows.h>
                                #include <time.h>
                                char ReChar(char ch);
                                char DeCodeChar(char ch);
                                void GetDReg05Code(char* pUserName, int ulen);
                                unsigned short* CreateTable();
                                void RandonRegCode(char* pRegCode, int rLen, char* pAsc, int aLen);
                                char* FomartStr(char* str, WORD sNum);
                                WORD  SearchTable(int nNum, char* pCUserName, int len);
                                int  SprintfChars(char* pUserName, int len, char* pCUserName, int nNum);
                                
                                
                                char ch5 = {};
                                unsigned short* pTable = {};
                                int _tmain(int argc, _TCHAR* argv[])
                                {
                                	srand((unsigned)time(NULL));
                                	char AscArry[36] = { 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
                                		0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A,
                                		0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54,
                                		0x55, 0x56, 0x57, 0x58, 0x59, 0x5A };
                                	char RegCode[29] = {};
                                	char DRegCode[29] = {};
                                	char UserName[10] = {};
                                
                                	RandonRegCode(RegCode, 29, AscArry, 36);
                                	printf("input Name:");
                                	scanf_s("%s", UserName, 10);
                                	int ulen = strlen(UserName);
                                	int rlen = _countof(RegCode);
                                	pTable = CreateTable();
                                	char* pAscii = (char*)malloc(sizeof(char) * 3000);
                                
                                	int slen = SprintfChars(UserName, ulen, pAscii, 3000);
                                	WORD sNum = SearchTable(0, pAscii, slen);
                                	char* pCNum = (char*)malloc(sizeof(char) * 10);
                                	FomartStr(pCNum, sNum);
                                	GetDReg05Code(UserName, ulen);
                                	RegCode[2] = ReChar(pCNum[0]);
                                	RegCode[3] = ReChar(pCNum[1]);
                                	RegCode[4] = ReChar(ch5);
                                	for (int i = 0; i < 29; i++)
                                	{
                                		if ((i + 1) % 6)
                                		{
                                			char ret = DeCodeChar(RegCode[i]);
                                			ret >>= 1;
                                			if (ret >= 10)
                                				DRegCode[i] = ret + 55;
                                			else
                                				DRegCode[i] = ret + 48;
                                		}
                                		else
                                			DRegCode[i] = 0x2D;
                                	}
                                	slen = SprintfChars(DRegCode + 2, rlen - 2, pAscii, 3000);
                                	sNum = SearchTable(0, pAscii, slen);
                                	FomartStr(pCNum, sNum);
                                	RegCode[0] = ReChar(pCNum[0]);
                                	RegCode[1] = ReChar(pCNum[1]);
                                	printf("RegCode:");
                                	for (int i = 0; i < 29; i++)
                                	{
                                		printf("%C", RegCode[i]);
                                	}
                                	system("pause");
                                	return 0;
                                }
                                int SprintfChars(char* pUserName, int len, char* pCUserName, int nNum)
                                {
                                	int ret;
                                	int i = 0;
                                	int j = 0;
                                	if (len <= 0)
                                	{
                                		pCUserName = NULL;
                                		ret = 0;
                                	}
                                	else
                                	{
                                		while (j < len)
                                		{
                                			sprintf_s(&pCUserName[i], nNum - i, "%04X", pUserName[j++]);
                                			i += 4;
                                		}
                                		pCUserName[i] = 0;
                                		ret = i;
                                	}
                                	return ret;
                                }
                                WORD SearchTable(int nNum, char* pCUserName, int len)
                                {
                                	WORD ret;
                                	int index;
                                	char* p = pCUserName;
                                	if (len <= 0)
                                	{
                                		ret = nNum;
                                	}
                                	else
                                	{
                                		ret = nNum;
                                		while (p < pCUserName + len)
                                		{
                                			index = *p++^LOBYTE(ret);
                                			ret = pTable[index] ^ (ret >> 8);
                                		}
                                	}
                                	return ret;
                                }
                                char* FomartStr(char* str, WORD sNum)
                                {
                                	sprintf_s(str, 10, "%04X", sNum);
                                	return str;
                                }
                                unsigned short* CreateTable()
                                {
                                	unsigned short * pTable = (unsigned short *)malloc(0x200);
                                	memset(pTable, 0, 0x200);
                                	for (int i = 0; i < 0x100; i++)
                                	{
                                		int j = 1;
                                		unsigned short eax = 0xC0C1;
                                		while (j < 0x100)
                                		{
                                			//test edx,ecx;
                                			if (i&j)
                                				pTable[i] ^= eax;
                                			eax += eax;
                                			eax ^= 0x4003;
                                			j += j;
                                		}
                                	}
                                	return pTable;
                                }
                                
                                char ReChar(char ch)
                                {
                                	char arr[] = { 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
                                		0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
                                		0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A };
                                	int len = _countof(arr);
                                	for (int i = 0; i < len; i++)
                                	{
                                		char tmp;
                                		char ret = DeCodeChar(arr[i]);
                                		ret >>= 1;
                                		if (ret >= 10)
                                			tmp = ret + 55;
                                		else
                                			tmp = ret + 48;
                                		if (tmp == ch)
                                		{
                                			return arr[i];
                                		}
                                	}
                                }
                                char DeCodeChar(char ch)
                                {
                                	//except:I/O
                                	char chArry[] =
                                	{
                                		50, 51, 52, 53,//	2,3,4,5,
                                		54, 55, 56, 57,//	6,7,8,9,
                                		65, 66, 67, 68,//	A,B,C,D,
                                		69, 70, 71, 72,//	E,F,G,H,
                                		74, 75, 76, 77,//	J,K,L,M,
                                		78, 80, 81, 82,//	N,P,Q,R,
                                		83, 84, 85, 86,//	S,T,U,V,
                                		87, 88, 89, 90 //	W,X,Y,Z		
                                	};
                                
                                	char ret = 0;
                                	int v1 = 2;
                                	char* p = &chArry[1];
                                	while (v1 - 2 < 32)
                                	{
                                		if (ch == *(p - 1))
                                			ret = v1 - 2;
                                		if (ch == *(p))
                                			ret = v1 - 1;
                                		if (ch == *(p + 1))
                                			ret = v1;
                                		if (ch == *(p + 2))
                                			ret = v1 + 1;
                                		p += 4;
                                		v1 += 4;
                                	}
                                	return ret;
                                }
                                
                                
                                void GetDReg05Code(char* pUserName, int ulen)
                                {
                                	int nNum01 = 0;
                                	int nNum02 = 0;
                                	int nNum03 = 1;
                                	int i = 0;
                                	while (i < ulen - 1)
                                	{
                                		nNum01 += pUserName[i];
                                		nNum02 += pUserName[i + 1];
                                		i += 2;
                                	}
                                	if (i < ulen)
                                		nNum03 = pUserName[i] + 1;
                                	sprintf_s(&ch5, 2, "%01X", ((9 * (nNum01 + nNum02 + nNum03) + 0xA) / 3 + 36) % 16);
                                }
                                void RandonRegCode(char* pRegCode, int rLen, char* pAsc, int aLen)
                                {
                                	for (int i = 0; i < rLen; i++)
                                	{
                                		if ((i + 1) % 6 == 0)
                                			pRegCode[i] = 0x2D;
                                		else
                                			pRegCode[i] = pAsc[rand() % aLen];
                                	}
                                }
                                
                                

                                @ChatGPT 以上代码请用javascript 实现一下

                                ChatGPTC 离线
                                ChatGPTC 离线
                                ChatGPT
                                写于 最后由 编辑
                                #5715

                                malaohu 说:

                                malaohu 说:

                                // KeyGen-editplus.cpp : 定义控制台应用程序的入口点。
                                //
                                #include "stdafx.h"
                                #include 
                                #include 
                                char ReChar(char ch);
                                char DeCodeChar(char ch);
                                void GetDReg05Code(char* pUserName, int ulen);
                                unsigned short* CreateTable();
                                void RandonRegCode(char* pRegCode, int rLen, char* pAsc, int aLen);
                                char* FomartStr(char* str, WORD sNum);
                                WORD  SearchTable(int nNum, char* pCUserName, int len);
                                int  SprintfChars(char* pUserName, int len, char* pCUserName, int nNum);
                                
                                
                                char ch5 = {};
                                unsigned short* pTable = {};
                                int _tmain(int argc, _TCHAR* argv[])
                                {
                                	srand((unsigned)time(NULL));
                                	char AscArry[36] = { 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
                                		0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A,
                                		0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54,
                                		0x55, 0x56, 0x57, 0x58, 0x59, 0x5A };
                                	char RegCode[29] = {};
                                	char DRegCode[29] = {};
                                	char UserName[10] = {};
                                
                                	RandonRegCode(RegCode, 29, AscArry, 36);
                                	printf("input Name:");
                                	scanf_s("%s", UserName, 10);
                                	int ulen = strlen(UserName);
                                	int rlen = _countof(RegCode);
                                	pTable = CreateTable();
                                	char* pAscii = (char*)malloc(sizeof(char) * 3000);
                                
                                	int slen = SprintfChars(UserName, ulen, pAscii, 3000);
                                	WORD sNum = SearchTable(0, pAscii, slen);
                                	char* pCNum = (char*)malloc(sizeof(char) * 10);
                                	FomartStr(pCNum, sNum);
                                	GetDReg05Code(UserName, ulen);
                                	RegCode[2] = ReChar(pCNum[0]);
                                	RegCode[3] = ReChar(pCNum[1]);
                                	RegCode[4] = ReChar(ch5);
                                	for (int i = 0; i  > 	{
                                		if ((i + 1) % 6)
                                		{
                                			char ret = DeCodeChar(RegCode[i]);
                                			ret >>= 1;
                                			if (ret >= 10)
                                				DRegCode[i] = ret + 55;
                                			else
                                				DRegCode[i] = ret + 48;
                                		}
                                		else
                                			DRegCode[i] = 0x2D;
                                	}
                                	slen = SprintfChars(DRegCode + 2, rlen - 2, pAscii, 3000);
                                	sNum = SearchTable(0, pAscii, slen);
                                	FomartStr(pCNum, sNum);
                                	RegCode[0] = ReChar(pCNum[0]);
                                	RegCode[1] = ReChar(pCNum[1]);
                                	printf("RegCode:");
                                	for (int i = 0; i  > 	{
                                		printf("%C", RegCode[i]);
                                	}
                                	system("pause");
                                	return 0;
                                }
                                int SprintfChars(char* pUserName, int len, char* pCUserName, int nNum)
                                {
                                	int ret;
                                	int i = 0;
                                	int j = 0;
                                	if (len  > 	{
                                		pCUserName = NULL;
                                		ret = 0;
                                	}
                                	else
                                	{
                                		while (j  > 		{
                                			sprintf_s(&pCUserName[i], nNum - i, "%04X", pUserName[j++]);
                                			i += 4;
                                		}
                                		pCUserName[i] = 0;
                                		ret = i;
                                	}
                                	return ret;
                                }
                                WORD SearchTable(int nNum, char* pCUserName, int len)
                                {
                                	WORD ret;
                                	int index;
                                	char* p = pCUserName;
                                	if (len  > 	{
                                		ret = nNum;
                                	}
                                	else
                                	{
                                		ret = nNum;
                                		while (p  > 		{
                                			index = *p++^LOBYTE(ret);
                                			ret = pTable[index] ^ (ret >> 8);
                                		}
                                	}
                                	return ret;
                                }
                                char* FomartStr(char* str, WORD sNum)
                                {
                                	sprintf_s(str, 10, "%04X", sNum);
                                	return str;
                                }
                                unsigned short* CreateTable()
                                {
                                	unsigned short * pTable = (unsigned short *)malloc(0x200);
                                	memset(pTable, 0, 0x200);
                                	for (int i = 0; i  > 	{
                                		int j = 1;
                                		unsigned short eax = 0xC0C1;
                                		while (j  > 		{
                                			//test edx,ecx;
                                			if (i&j)
                                				pTable[i] ^= eax;
                                			eax += eax;
                                			eax ^= 0x4003;
                                			j += j;
                                		}
                                	}
                                	return pTable;
                                }
                                
                                char ReChar(char ch)
                                {
                                	char arr[] = { 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
                                		0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
                                		0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A };
                                	int len = _countof(arr);
                                	for (int i = 0; i  > 	{
                                		char tmp;
                                		char ret = DeCodeChar(arr[i]);
                                		ret >>= 1;
                                		if (ret >= 10)
                                			tmp = ret + 55;
                                		else
                                			tmp = ret + 48;
                                		if (tmp == ch)
                                		{
                                			return arr[i];
                                		}
                                	}
                                }
                                char DeCodeChar(char ch)
                                {
                                	//except:I/O
                                	char chArry[] =
                                	{
                                		50, 51, 52, 53,//	2,3,4,5,
                                		54, 55, 56, 57,//	6,7,8,9,
                                		65, 66, 67, 68,//	A,B,C,D,
                                		69, 70, 71, 72,//	E,F,G,H,
                                		74, 75, 76, 77,//	J,K,L,M,
                                		78, 80, 81, 82,//	N,P,Q,R,
                                		83, 84, 85, 86,//	S,T,U,V,
                                		87, 88, 89, 90 //	W,X,Y,Z		
                                	};
                                
                                	char ret = 0;
                                	int v1 = 2;
                                	char* p = &chArry[1];
                                	while (v1 - 2  > 	{
                                		if (ch == *(p - 1))
                                			ret = v1 - 2;
                                		if (ch == *(p))
                                			ret = v1 - 1;
                                		if (ch == *(p + 1))
                                			ret = v1;
                                		if (ch == *(p + 2))
                                			ret = v1 + 1;
                                		p += 4;
                                		v1 += 4;
                                	}
                                	return ret;
                                }
                                
                                
                                void GetDReg05Code(char* pUserName, int ulen)
                                {
                                	int nNum01 = 0;
                                	int nNum02 = 0;
                                	int nNum03 = 1;
                                	int i = 0;
                                	while (i  > 	{
                                		nNum01 += pUserName[i];
                                		nNum02 += pUserName[i + 1];
                                		i += 2;
                                	}
                                	if (i  > 		nNum03 = pUserName[i] + 1;
                                	sprintf_s(&ch5, 2, "%01X", ((9 * (nNum01 + nNum02 + nNum03) + 0xA) / 3 + 36) % 16);
                                }
                                void RandonRegCode(char* pRegCode, int rLen, char* pAsc, int aLen)
                                {
                                	for (int i = 0; i  > 	{
                                		if ((i + 1) % 6 == 0)
                                			pRegCode[i] = 0x2D;
                                		else
                                			pRegCode[i] = pAsc[rand() % aLen];
                                	}
                                }
                                
                                

                                @ChatGPT 以上代码请用javascript 实现一下

                                哎呀, OpenAI接口可能出问题了,请稍后再试!我这就PM站长~ @malaohu

                                帖子内容中 @ChatGPT(注意前后空格,发帖后名称变色才行)。必须@才会回答

                                1 条回复 最后回复
                                0
                                • 6 离线
                                  6 离线
                                  690779301gagacui
                                  🍌
                                  写于 最后由 编辑
                                  #5716

                                  @ChatGPT 资产证券化增信需要2A平台来增信?在中国哪部法律中有所规定

                                  ChatGPTC 1 条回复 最后回复
                                  0
                                  • 6 690779301gagacui

                                    @ChatGPT 资产证券化增信需要2A平台来增信?在中国哪部法律中有所规定

                                    ChatGPTC 离线
                                    ChatGPTC 离线
                                    ChatGPT
                                    写于 最后由 编辑
                                    #5717

                                    690779301gagacui 说:

                                    @ChatGPT 资产证券化增信需要2A平台来增信?在中国哪部法律中有所规定

                                    资产证券化是一种通过将现有的资产打包成可交易的证券来满足投资者需求的金融工具。在资产证券化过程中,确保证券化的资产质量和可信度非常重要,而2A评级平台是为此提供增信服务的一种机构。然而,对于增信的具体要求和规范在不同国家可能有所不同。

                                    在中国,资产证券化的发展还相对较为年轻,相关法律法规也比较分散和灵活。目前,有些专门针对资产证券化的监管指引类文件中,提到了增信机构的角色和相关规定。例如:

                                    • 《证券期货投资基金资产支持专项计划管理办法》规定,专项计划应当聘请正规资格的第三方机构对计划资产进行评估、估值、审计和评级等工作。
                                    • 《关于加强债券市场风险管理的指导意见》明确,发行商和承销商应当获取权威的信用评级,并在信息披露中充分披露与评级相关的信息。

                                    此外,China Securities Regulatory Commission(中国证券监督管理委员会)也发布过多个文件,强调加强资产证券化市场的监管和风险控制,其中也涉及到评级机构的审批、认证等问题。因此,在中国的资产证券化市场中,2A评级平台的增信作用是有一定法律依据和相关指引的。

                                    帖子内容中 @ChatGPT(注意前后空格,发帖后名称变色才行)。必须@才会回答

                                    1 条回复 最后回复
                                    0
                                    • F 离线
                                      F 离线
                                      for culture
                                      🍌
                                      写于 最后由 编辑
                                      #5718

                                      @ChatGPT selenium.common.exceptions.ElementNotInteractableException: Message: element not interactable: [object HTMLSpanElement] has no size and location 这个报错怎么处理

                                      ChatGPTC 1 条回复 最后回复
                                      0
                                      • F for culture

                                        @ChatGPT selenium.common.exceptions.ElementNotInteractableException: Message: element not interactable: [object HTMLSpanElement] has no size and location 这个报错怎么处理

                                        ChatGPTC 离线
                                        ChatGPTC 离线
                                        ChatGPT
                                        写于 最后由 编辑
                                        #5719

                                        for culture 说:

                                        @ChatGPT selenium.common.exceptions.ElementNotInteractableException: Message: element not interactable: [object HTMLSpanElement] has no size and location 这个报错怎么处理

                                        哎呀, OpenAI接口可能出问题了,请稍后再试!我这就PM站长~ @malaohu

                                        帖子内容中 @ChatGPT(注意前后空格,发帖后名称变色才行)。必须@才会回答

                                        1 条回复 最后回复
                                        0
                                        • F 离线
                                          F 离线
                                          for culture
                                          🍌
                                          写于 最后由 编辑
                                          #5720

                                          @ChatGPT selenium.common.exceptions.ElementNotInteractableException: Message: element not interactable: [object HTMLSpanElement] has no size and location 这个报错怎么处理

                                          ChatGPTC 1 条回复 最后回复
                                          0
                                          回复
                                          • 在新帖中回复
                                          登录后回复
                                          • 从旧到新
                                          • 从新到旧
                                          • 最多赞同


                                          • 1
                                          • 2
                                          • 284
                                          • 285
                                          • 286
                                          • 287
                                          • 288
                                          • 576
                                          • 577
                                          Popular Topics - 热门主题
                                          • Bug! Bug !Google One 学生优惠 可无门槛验证
                                            mztcM
                                            mztc
                                            3
                                            14
                                            4.8k

                                          • MySQL 8.0 OCP 限时免费考
                                            HebutMrLiuH
                                            HebutMrLiu
                                            1
                                            5
                                            195

                                          • 阿里云国际站轻量应用服务器 2C+1G+200M带宽 仅9.9美元一年!
                                            T
                                            Test
                                            1
                                            4
                                            1.0k

                                          • <海外剧>行尸走肉:死城 第二季[2025][惊悚 恐怖 冒险][附行尸走肉 系列全部]
                                            我是小马甲~M
                                            我是小马甲~
                                            1
                                            3
                                            23

                                          • 京东冲100明天送一张25-20外卖卷
                                            我是小马甲~M
                                            我是小马甲~
                                            1
                                            2
                                            658

                                          • giffgaff免流教程
                                            建军建
                                            建军
                                            1
                                            2
                                            568

                                          • 登录

                                          • 没有帐号? 注册

                                          • 登录或注册以进行搜索。
                                          百度网盘
                                          1,173 个主题
                                          连续剧
                                          698 个主题
                                          国产剧
                                          564 个主题
                                          美剧
                                          338 个主题
                                          中国移动
                                          307 个主题
                                          动画片
                                          231 个主题
                                          中国电信
                                          222 个主题
                                          动作片
                                          206 个主题

                                          262

                                          在线

                                          39.9k

                                          用户

                                          40.1k

                                          主题

                                          110.4k

                                          帖子
                                          • 第一个帖子
                                            最后一个帖子