开启辅助访问 切换到宽版

精易论坛

 找回密码
 注册

QQ登录

只需一步,快速开始

用微信号发送消息登录论坛

新人指南 邀请好友注册 - 我关注人的新帖 教你赚取精币 - 每日签到


求职/招聘- 论坛接单- 开发者大厅

论坛版规 总版规 - 建议/投诉 - 应聘版主 - 精华帖总集 积分说明 - 禁言标准 - 有奖举报

查看: 883|回复: 8
收起左侧

[已解决] 网页登录问题

 关闭 [复制链接]
结帖率:94% (17/18)
发表于 2022-1-18 18:07:23 | 显示全部楼层 |阅读模式   福建省漳州市
50精币
地址:https://bbs.aoshitang.com
我想写这个登录,有没有大佬能帮我算下这个网站的加密方式是什么,最好能写出完整点的代码 感谢各位啦!

最佳答案

查看完整内容

' tp ,encryptionExponent ,modulus 这3个值从网页上可以获得

回答提醒:如果本帖被关闭无法回复,您有更好的答案帮助楼主解决,请发表至 源码区 可获得加分喔。
友情提醒:本版被采纳的主题可在 申请荣誉值 页面申请荣誉值,获得 1点 荣誉值,荣誉值可兑换荣誉会员、终身vip用户组。
快捷通道:申请荣誉值无答案申请取消悬赏投诉有答案未采纳为最佳
结帖率:93% (85/91)
发表于 2022-1-18 18:07:24 | 显示全部楼层   新疆维吾尔自治区阿拉尔市
demo.jpg 加密.e (873.8 KB, 下载次数: 2)
回复

使用道具 举报

结帖率:100% (11/11)

签到天数: 28 天

发表于 2022-1-18 18:39:02 | 显示全部楼层   浙江省嘉兴市
既要别人帮你分析加密方式,又要别人帮你写代码?
回复

使用道具 举报

结帖率:79% (19/24)

签到天数: 1 天

发表于 2022-1-18 18:42:45 | 显示全部楼层   广东省揭阳市
需要定制可联系我  QQ3334805072
回复

使用道具 举报

结帖率:89% (24/27)

签到天数: 24 天

发表于 2022-1-18 18:46:08 | 显示全部楼层   阿拉伯联合酋长国
标准RSA加密
回复

使用道具 举报

签到天数: 2 天

发表于 2022-1-18 19:04:17 | 显示全部楼层   山东省泰安市
这已经很明显了  RSA加密

QQ图片20220118190338.png
回复

使用道具 举报

结帖率:100% (5/5)
发表于 2022-1-18 19:15:14 | 显示全部楼层   湖南省长沙市
这个帖子好像几天前见过
回复

使用道具 举报

结帖率:96% (71/74)

签到天数: 27 天

发表于 2022-1-18 19:18:53 | 显示全部楼层   江苏省常州市
花钱吧
回复

使用道具 举报

结帖率:93% (85/91)
发表于 2022-1-18 20:38:13 | 显示全部楼层   新疆维吾尔自治区阿拉尔市
// RSA, a suite of routines for performing RSA public-key computations in
// JavaScript.
//
// Requires BigInt.js and Barrett.js.
//
// Copyright 1998-2005 David Shapiro.
//
// You may use, re-use, abuse, copy, and modify this code to your liking, but
// please keep this header.
//
// Thanks!
//
// Dave Shapiro
// dave@ohdave.com

function RSAKeyPair(encryptionExponent, decryptionExponent, modulus) {
this.e = biFromHex(encryptionExponent);
this.d = biFromHex(decryptionExponent);
this.m = biFromHex(modulus);
// We can do two bytes per digit, so
// chunkSize = 2 * (number of digits in modulus - 1).
// Since biHighIndex returns the high index, not the number of digits, 1 has
// already been subtracted.
this.chunkSize = 2 * biHighIndex(this.m);
this.radix = 16;
this.barrett = new BarrettMu(this.m);
}

function twoDigit(n) {
return (n < 10 ? "0": "") + String(n);
}

function encryptedString(key, s)
// Altered by Rob Saunders (rob@robsaunders.net). New routine pads the
// string after it has been converted to an array. This fixes an
// incompatibility with Flash MX's ActionScript.
{
var a = new Array();
var sl = s.length;
var i = 0;
while (i < sl) {
    a = s.charCodeAt(i);
    i++;
}

while (a.length % key.chunkSize != 0) {
    a[i++] = 0;
}

var al = a.length;
var result = "";
var j, k, block;
for (i = 0; i < al; i += key.chunkSize) {
    block = new BigInt();
    j = 0;
    for (k = i; k < i + key.chunkSize; ++j) {
        block.digits[j] = a[k++];
        block.digits[j] += a[k++] << 8;
    }
    var crypt = key.barrett.powMod(block, key.e);
    var text = key.radix == 16 ? biToHex(crypt) : biToString(crypt, key.radix);
    result += text + " ";
}
return result.substring(0, result.length - 1); // Remove last space.
}

function decryptedString(key, s) {
var blocks = s.split(" ");
var result = "";
var i, j, block;
for (i = 0; i < blocks.length; ++i) {
    var bi;
    if (key.radix == 16) {
        bi = biFromHex(blocks);
    } else {
        bi = biFromString(blocks, key.radix);
    }
    block = key.barrett.powMod(bi, key.d);
    for (j = 0; j <= biHighIndex(block); ++j) {
        result += String.fromCharCode(block.digits[j] & 255, block.digits[j] >> 8);
    }
}
// Remove trailing null, if any.
if (result.charCodeAt(result.length - 1) == 0) {
    result = result.substring(0, result.length - 1);
}
return result;
}

var biRadixBase = 2;
var biRadixBits = 16;
var bitsPerDigit = biRadixBits;
var biRadix = 1 << 16; // = 2^16 = 65536
var biHalfRadix = biRadix >>> 1;
var biRadixSquared = biRadix * biRadix;
var maxDigitVal = biRadix - 1;
var maxInteger = 9999999999999998;
var maxDigits;
var ZERO_ARRAY;
var bigZero, bigOne;

function setMaxDigits(value) {
maxDigits = value;
ZERO_ARRAY = new Array(maxDigits);
for (var iza = 0; iza < ZERO_ARRAY.length; iza++) ZERO_ARRAY[iza] = 0;
bigZero = new BigInt();
bigOne = new BigInt();
bigOne.digits[0] = 1;
}

setMaxDigits(20);

// The maximum number of digits in base 10 you can convert to an
// integer without JavaScript throwing up on you.
var dpl10 = 15;
// lr10 = 10 ^ dpl10
var lr10 = biFromNumber(1000000000000000);

function BigInt(flag) {
if (typeof flag == "boolean" && flag == true) {
    this.digits = null;
} else {
    this.digits = ZERO_ARRAY.slice(0);
}
this.isNeg = false;
}

function biFromDecimal(s) {
var isNeg = s.charAt(0) == '-';
var i = isNeg ? 1 : 0;
var result;
// Skip leading zeros.
while (i < s.length && s.charAt(i) == '0')++i;
if (i == s.length) {
    result = new BigInt();
} else {
    var digitCount = s.length - i;
    var fgl = digitCount % dpl10;
    if (fgl == 0) fgl = dpl10;
    result = biFromNumber(Number(s.substr(i, fgl)));
    i += fgl;
    while (i < s.length) {
        result = biAdd(biMultiply(result, lr10), biFromNumber(Number(s.substr(i, dpl10))));
        i += dpl10;
    }
    result.isNeg = isNeg;
}
return result;
}

function biCopy(bi) {
var result = new BigInt(true);
result.digits = bi.digits.slice(0);
result.isNeg = bi.isNeg;
return result;
}

function biFromNumber(i) {
var result = new BigInt();
result.isNeg = i < 0;
i = Math.abs(i);
var j = 0;
while (i > 0) {
    result.digits[j++] = i & maxDigitVal;
    i = Math.floor(i / biRadix);
}
return result;
}

function reverseStr(s) {
var result = "";
for (var i = s.length - 1; i > -1; --i) {
    result += s.charAt(i);
}
return result;
}

var hexatrigesimalToChar = new Array('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z');

function biToString(x, radix)
// 2 <= radix <= 36
{
var b = new BigInt();
b.digits[0] = radix;
var qr = biDivideModulo(x, b);
var result = hexatrigesimalToChar[qr[1].digits[0]];
while (biCompare(qr[0], bigZero) == 1) {
    qr = biDivideModulo(qr[0], b);
    digit = qr[1].digits[0];
    result += hexatrigesimalToChar[qr[1].digits[0]];
}
return (x.isNeg ? "-": "") + reverseStr(result);
}

function biToDecimal(x) {
var b = new BigInt();
b.digits[0] = 10;
var qr = biDivideModulo(x, b);
var result = String(qr[1].digits[0]);
while (biCompare(qr[0], bigZero) == 1) {
    qr = biDivideModulo(qr[0], b);
    result += String(qr[1].digits[0]);
}
return (x.isNeg ? "-": "") + reverseStr(result);
}

var hexToChar = new Array('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f');

function digitToHex(n) {
var mask = 0xf;
var result = "";
for (i = 0; i < 4; ++i) {
    result += hexToChar[n & mask];
    n >>>= 4;
}
return reverseStr(result);
}

function biToHex(x) {
var result = "";
var n = biHighIndex(x);
for (var i = biHighIndex(x); i > -1; --i) {
    result += digitToHex(x.digits);
}
return result;
}

function charToHex(c) {
var ZERO = 48;
var NINE = ZERO + 9;
var littleA = 97;
var littleZ = littleA + 25;
var bigA = 65;
var bigZ = 65 + 25;
var result;

if (c >= ZERO && c <= NINE) {
    result = c - ZERO;
} else if (c >= bigA && c <= bigZ) {
    result = 10 + c - bigA;
} else if (c >= littleA && c <= littleZ) {
    result = 10 + c - littleA;
} else {
    result = 0;
}
return result;
}

function hexToDigit(s) {
var result = 0;
var sl = Math.min(s.length, 4);
for (var i = 0; i < sl; ++i) {
    result <<= 4;
    result |= charToHex(s.charCodeAt(i))
}
return result;
}

function biFromHex(s) {
var result = new BigInt();
var sl = s.length;
for (var i = sl,
j = 0; i > 0; i -= 4, ++j) {
    result.digits[j] = hexToDigit(s.substr(Math.max(i - 4, 0), Math.min(i, 4)));
}
return result;
}

function biFromString(s, radix) {
var isNeg = s.charAt(0) == '-';
var istop = isNeg ? 1 : 0;
var result = new BigInt();
var place = new BigInt();
place.digits[0] = 1; // radix^0
for (var i = s.length - 1; i >= istop; i--) {
    var c = s.charCodeAt(i);
    var digit = charToHex(c);
    var biDigit = biMultiplyDigit(place, digit);
    result = biAdd(result, biDigit);
    place = biMultiplyDigit(place, radix);
}
result.isNeg = isNeg;
return result;
}

function biDump(b) {
return (b.isNeg ? "-": "") + b.digits.join(" ");
}

function biAdd(x, y) {
var result;

if (x.isNeg != y.isNeg) {
    y.isNeg = !y.isNeg;
    result = biSubtract(x, y);
    y.isNeg = !y.isNeg;
} else {
    result = new BigInt();
    var c = 0;
    var n;
    for (var i = 0; i < x.digits.length; ++i) {
        n = x.digits + y.digits + c;
        result.digits = n % biRadix;
        c = Number(n >= biRadix);
    }
    result.isNeg = x.isNeg;
}
return result;
}

function biSubtract(x, y) {
var result;
if (x.isNeg != y.isNeg) {
    y.isNeg = !y.isNeg;
    result = biAdd(x, y);
    y.isNeg = !y.isNeg;
} else {
    result = new BigInt();
    var n, c;
    c = 0;
    for (var i = 0; i < x.digits.length; ++i) {
        n = x.digits - y.digits + c;
        result.digits = n % biRadix;
        // Stupid non-conforming modulus operation.
        if (result.digits < 0) result.digits += biRadix;
        c = 0 - Number(n < 0);
    }
    // Fix up the negative sign, if any.
    if (c == -1) {
        c = 0;
        for (var i = 0; i < x.digits.length; ++i) {
            n = 0 - result.digits + c;
            result.digits = n % biRadix;
            // Stupid non-conforming modulus operation.
            if (result.digits < 0) result.digits += biRadix;
            c = 0 - Number(n < 0);
        }
        // Result is opposite sign of arguments.
        result.isNeg = !x.isNeg;
    } else {
        // Result is same sign.
        result.isNeg = x.isNeg;
    }
}
return result;
}

function biHighIndex(x) {
var result = x.digits.length - 1;
while (result > 0 && x.digits[result] == 0)--result;
return result;
}

function biNumBits(x) {
var n = biHighIndex(x);
var d = x.digits[n];
var m = (n + 1) * bitsPerDigit;
var result;
for (result = m; result > m - bitsPerDigit; --result) {
    if ((d & 0x8000) != 0) break;
    d <<= 1;
}
return result;
}

function biMultiply(x, y) {
var result = new BigInt();
var c;
var n = biHighIndex(x);
var t = biHighIndex(y);
var u, uv, k;

for (var i = 0; i <= t; ++i) {
    c = 0;
    k = i;
    for (j = 0; j <= n; ++j, ++k) {
        uv = result.digits[k] + x.digits[j] * y.digits + c;
        result.digits[k] = uv & maxDigitVal;
        c = uv >>> biRadixBits;
        //c = Math.floor(uv / biRadix);
    }
    result.digits[i + n + 1] = c;
}
// Someone give me a logical xor, please.
result.isNeg = x.isNeg != y.isNeg;
return result;
}

function biMultiplyDigit(x, y) {
var n, c, uv;

result = new BigInt();
n = biHighIndex(x);
c = 0;
for (var j = 0; j <= n; ++j) {
    uv = result.digits[j] + x.digits[j] * y + c;
    result.digits[j] = uv & maxDigitVal;
    c = uv >>> biRadixBits;
    //c = Math.floor(uv / biRadix);
}
result.digits[1 + n] = c;
return result;
}

function arrayCopy(src, srcStart, dest, destStart, n) {
var m = Math.min(srcStart + n, src.length);
for (var i = srcStart,
j = destStart; i < m; ++i, ++j) {
    dest[j] = src;
}
}

var highBitMasks = new Array(0x0000, 0x8000, 0xC000, 0xE000, 0xF000, 0xF800, 0xFC00, 0xFE00, 0xFF00, 0xFF80, 0xFFC0, 0xFFE0, 0xFFF0, 0xFFF8, 0xFFFC, 0xFFFE, 0xFFFF);

function biShiftLeft(x, n) {
var digitCount = Math.floor(n / bitsPerDigit);
var result = new BigInt();
arrayCopy(x.digits, 0, result.digits, digitCount, result.digits.length - digitCount);
var bits = n % bitsPerDigit;
var rightBits = bitsPerDigit - bits;
for (var i = result.digits.length - 1,
i1 = i - 1; i > 0; --i, --i1) {
    result.digits = ((result.digits << bits) & maxDigitVal) | ((result.digits[i1] & highBitMasks[bits]) >>> (rightBits));
}
result.digits[0] = ((result.digits << bits) & maxDigitVal);
result.isNeg = x.isNeg;
return result;
}

var lowBitMasks = new Array(0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF, 0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF);

function biShiftRight(x, n) {
var digitCount = Math.floor(n / bitsPerDigit);
var result = new BigInt();
arrayCopy(x.digits, digitCount, result.digits, 0, x.digits.length - digitCount);
var bits = n % bitsPerDigit;
var leftBits = bitsPerDigit - bits;
for (var i = 0,
i1 = i + 1; i < result.digits.length - 1; ++i, ++i1) {
    result.digits = (result.digits >>> bits) | ((result.digits[i1] & lowBitMasks[bits]) << leftBits);
}
result.digits[result.digits.length - 1] >>>= bits;
result.isNeg = x.isNeg;
return result;
}

function biMultiplyByRadixPower(x, n) {
var result = new BigInt();
arrayCopy(x.digits, 0, result.digits, n, result.digits.length - n);
return result;
}

function biDivideByRadixPower(x, n) {
var result = new BigInt();
arrayCopy(x.digits, n, result.digits, 0, result.digits.length - n);
return result;
}

function biModuloByRadixPower(x, n) {
var result = new BigInt();
arrayCopy(x.digits, 0, result.digits, 0, n);
return result;
}

function biCompare(x, y) {
if (x.isNeg != y.isNeg) {
    return 1 - 2 * Number(x.isNeg);
}
for (var i = x.digits.length - 1; i >= 0; --i) {
    if (x.digits != y.digits) {
        if (x.isNeg) {
            return 1 - 2 * Number(x.digits > y.digits);
        } else {
            return 1 - 2 * Number(x.digits < y.digits);
        }
    }
}
return 0;
}

function biDivideModulo(x, y) {
var nb = biNumBits(x);
var tb = biNumBits(y);
var origYIsNeg = y.isNeg;
var q, r;
if (nb < tb) {
    // |x| < |y|
    if (x.isNeg) {
        q = biCopy(bigOne);
        q.isNeg = !y.isNeg;
        x.isNeg = false;
        y.isNeg = false;
        r = biSubtract(y, x);
        // Restore signs, 'cause they're references.
        x.isNeg = true;
        y.isNeg = origYIsNeg;
    } else {
        q = new BigInt();
        r = biCopy(x);
    }
    return new Array(q, r);
}

q = new BigInt();
r = x;

// Normalize Y.
var t = Math.ceil(tb / bitsPerDigit) - 1;
var lambda = 0;
while (y.digits[t] < biHalfRadix) {
    y = biShiftLeft(y, 1); ++lambda; ++tb;
    t = Math.ceil(tb / bitsPerDigit) - 1;
}
// Shift r over to keep the quotient constant. We'll shift the
// remainder back at the end.
r = biShiftLeft(r, lambda);
nb += lambda; // Update the bit count for x.
var n = Math.ceil(nb / bitsPerDigit) - 1;

var b = biMultiplyByRadixPower(y, n - t);
while (biCompare(r, b) != -1) {++q.digits[n - t];
    r = biSubtract(r, b);
}
for (var i = n; i > t; --i) {
    var ri = (i >= r.digits.length) ? 0 : r.digits;
    var ri1 = (i - 1 >= r.digits.length) ? 0 : r.digits[i - 1];
    var ri2 = (i - 2 >= r.digits.length) ? 0 : r.digits[i - 2];
    var yt = (t >= y.digits.length) ? 0 : y.digits[t];
    var yt1 = (t - 1 >= y.digits.length) ? 0 : y.digits[t - 1];
    if (ri == yt) {
        q.digits[i - t - 1] = maxDigitVal;
    } else {
        q.digits[i - t - 1] = Math.floor((ri * biRadix + ri1) / yt);
    }

    var c1 = q.digits[i - t - 1] * ((yt * biRadix) + yt1);
    var c2 = (ri * biRadixSquared) + ((ri1 * biRadix) + ri2);
    while (c1 > c2) {--q.digits[i - t - 1];
        c1 = q.digits[i - t - 1] * ((yt * biRadix) | yt1);
        c2 = (ri * biRadix * biRadix) + ((ri1 * biRadix) + ri2);
    }

    b = biMultiplyByRadixPower(y, i - t - 1);
    r = biSubtract(r, biMultiplyDigit(b, q.digits[i - t - 1]));
    if (r.isNeg) {
        r = biAdd(r, b); --q.digits[i - t - 1];
    }
}
r = biShiftRight(r, lambda);
// Fiddle with the signs and stuff to make sure that 0 <= r < y.
q.isNeg = x.isNeg != origYIsNeg;
if (x.isNeg) {
    if (origYIsNeg) {
        q = biAdd(q, bigOne);
    } else {
        q = biSubtract(q, bigOne);
    }
    y = biShiftRight(y, lambda);
    r = biSubtract(y, r);
}
// Check for the unbelievably stupid degenerate case of r == -0.
if (r.digits[0] == 0 && biHighIndex(r) == 0) r.isNeg = false;

return new Array(q, r);
}

function biDivide(x, y) {
return biDivideModulo(x, y)[0];
}

function biModulo(x, y) {
return biDivideModulo(x, y)[1];
}

function biMultiplyMod(x, y, m) {
return biModulo(biMultiply(x, y), m);
}

function biPow(x, y) {
var result = bigOne;
var a = x;
while (true) {
    if ((y & 1) != 0) result = biMultiply(result, a);
    y >>= 1;
    if (y == 0) break;
    a = biMultiply(a, a);
}
return result;
}

function biPowMod(x, y, m) {
var result = bigOne;
var a = x;
var k = y;
while (true) {
    if ((k.digits[0] & 1) != 0) result = biMultiplyMod(result, a, m);
    k = biShiftRight(k, 1);
    if (k.digits[0] == 0 && biHighIndex(k) == 0) break;
    a = biMultiplyMod(a, a, m);
}
return result;
}

function BarrettMu(m) {
this.modulus = biCopy(m);
this.k = biHighIndex(this.modulus) + 1;
var b2k = new BigInt();
b2k.digits[2 * this.k] = 1; // b2k = b^(2k)
this.mu = biDivide(b2k, this.modulus);
this.bkplus1 = new BigInt();
this.bkplus1.digits[this.k + 1] = 1; // bkplus1 = b^(k+1)
this.modulo = BarrettMu_modulo;
this.multiplyMod = BarrettMu_multiplyMod;
this.powMod = BarrettMu_powMod;
}

function BarrettMu_modulo(x) {
var q1 = biDivideByRadixPower(x, this.k - 1);
var q2 = biMultiply(q1, this.mu);
var q3 = biDivideByRadixPower(q2, this.k + 1);
var r1 = biModuloByRadixPower(x, this.k + 1);
var r2term = biMultiply(q3, this.modulus);
var r2 = biModuloByRadixPower(r2term, this.k + 1);
var r = biSubtract(r1, r2);
if (r.isNeg) {
    r = biAdd(r, this.bkplus1);
}
var rgtem = biCompare(r, this.modulus) >= 0;
while (rgtem) {
    r = biSubtract(r, this.modulus);
    rgtem = biCompare(r, this.modulus) >= 0;
}
return r;
}

function BarrettMu_multiplyMod(x, y) {
/*
        x = this.modulo(x);
        y = this.modulo(y);
        */
var xy = biMultiply(x, y);
return this.modulo(xy);
}

function BarrettMu_powMod(x, y) {
var result = new BigInt();
result.digits[0] = 1;
var a = x;
var k = y;
while (true) {
    if ((k.digits[0] & 1) != 0) result = this.multiplyMod(result, a);
    k = biShiftRight(k, 1);
    if (k.digits[0] == 0 && biHighIndex(k) == 0) break;
    a = this.multiplyMod(a, a);
}
return result;
}

function pass(p){
var tp = 1642508818;
encryptionExponent = '233AB';
modulus = '6B10B24CC6E905A54785043FF36B85CFB2C25D995244255B02A0A4F225BDCCCB51F86114F7C56E826283FFD0BA3D594D9219C716EE1ABD70E2FB0C2C8821947385FA0AE0448EA9CBD5F40EDAACBD4C287C337FDC19D7F2D9713378C94F798F6052077DC097D714CDF2F97D25EB068DAC7733F61F3A0B47364A41066E2708BE29';

var str = "tp=" + tp + "&password=" + encodeURIComponent(p);
setMaxDigits(130);
var token = encryptedString(new RSAKeyPair(encryptionExponent, '', modulus), encodeURIComponent(str));

return token


}
加密函数为:pass  里面的3(tp ,encryptionExponent ,modulus)个值网页返回可以获得。
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 注册

本版积分规则 致发广告者

发布主题 收藏帖子 返回列表

sitemap| 易语言源码| 易语言教程| 易语言论坛| 诚聘英才| 易语言模块| 手机版| 广告投放| 精易论坛
拒绝任何人以任何形式在本论坛发表与中华人民共和国法律相抵触的言论,本站内容均为会员发表,并不代表精易立场!
论坛帖子内容仅用于技术交流学习和研究的目的,严禁用于非法目的,否则造成一切后果自负!如帖子内容侵害到你的权益,请联系我们!
防范网络诈骗,远离网络犯罪 违法和不良信息举报电话0663-3422125,QQ: 800073686,邮箱:800073686@b.qq.com
Powered by Discuz! X3.4 揭阳市揭东区精易科技有限公司 ( 粤ICP备12094385号-1) 粤公网安备 44522102000125 增值电信业务经营许可证 粤B2-20192173

快速回复 返回顶部 返回列表