精华内容
下载资源
问答
  • 我们看到password是加密值,我们搜索一下,password,打断点触发一下 第一句很明显,获取密码, 第二句就是获取一个keypair,返回一个key, ...第四句就是加密字符串,我们看不到我们可以继续执行, ...

    在这里插入图片描述
    我们看到password是加密值,我们搜索一下,password,打断点触发一下

    在这里插入图片描述
    第一句很明显,获取密码,
    第二句就是获取一个keypair,返回一个key,
    第三句就是将密码反转一下,
    第四句就是加密字符串,我们看不到我们可以继续执行,
    我们进去之后发现是RSA加密,我们使用execjs执行js,把代码修改一下,getpair这个是一个接口获取key:https://ca.sdvcst.edu.cn/cas/v2/getPubKey,我们将这个json中两个参数加上密码传给js,最终会给我们最终的加密值
    在这里插入图片描述

    
    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 BigInt (flag) {
    	if (typeof flag == "boolean" && flag == true) {
    		this.digits = null;
    	} else {
    		this.digits = ZERO_ARRAY.slice(0);
    	}
    	this.isNeg = false;
    };
    
    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;
    
    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;
    };
    
    //lr10 = 10 ^ dpl10
    var lr10 = biFromNumber(1000000000000000);
    
    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 reverseStr (s) {
    	var result = "";
    	for (var i = s.length - 1; i > -1; --i) {
    		result += s.charAt(i);
    	}
    	return result;
    };
    
    var hexatrigesimalToChar = [
    	'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 = ['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[i]);
    	}
    	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[i] + y.digits[i] + c;
    			result.digits[i] = 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[i] - y.digits[i] + c;
    			result.digits[i] = n % biRadix;
    			// Stupid non-conforming modulus operation.
    			if (result.digits[i] < 0) result.digits[i] += 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[i] + c;
    				result.digits[i] = n % biRadix;
    				// Stupid non-conforming modulus operation.
    				if (result.digits[i] < 0) result.digits[i] += 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[i] + 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[i];
    	}
    };
    
    var highBitMasks = [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[i] = ((result.digits[i] << bits) & maxDigitVal) |
    		                   ((result.digits[i1] & highBitMasks[bits]) >>>
    		                    (rightBits));
    	}
    	result.digits[0] = ((result.digits[i] << bits) & maxDigitVal);
    	result.isNeg = x.isNeg;
    	return result;
    };
    
    var lowBitMasks = [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[i] = (result.digits[i] >>> 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[i] != y.digits[i]) {
    			if (x.isNeg) {
    				return 1 - 2 * Number(x.digits[i] > y.digits[i]);
    			} else {
    				return 1 - 2 * Number(x.digits[i] < y.digits[i]);
    			}
    		}
    	}
    	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 [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[i];
        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 [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) {
    	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 RSAKeyPair (encryptionExponent, decryptionExponent, modulus) {
    	this.e = biFromHex(encryptionExponent);
    	this.d = biFromHex(decryptionExponent);
    	this.m = biFromHex(modulus);
    	this.chunkSize = 2 * biHighIndex(this.m);
    	this.radix = 16;
    	this.barrett = new BarrettMu(this.m);
    };
    
    function getKeyPair(encryptionExponent, decryptionExponent, modulus) {
    	return new RSAKeyPair(encryptionExponent, decryptionExponent, modulus);
    };
    
    if(typeof twoDigit === 'undefined') {
    	twoDigit = function(n) {
    		return (n < 10 ? "0" : "") + String(n);
    	};
    }
    
    
    
    function encryptedString(key, s) {
    	var a = new Array();
    	var sl = s.length;
    	var i = 0;
    	while (i < sl) {
    		a[i] = 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[i]);
    		}
    		else {
    			bi = biFromString(blocks[i], 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);
    		}
    	}
    	if (result.charCodeAt(result.length - 1) == 0) {
    		result = result.substring(0, result.length - 1);
    	}
    	return result;
    };
    
    function getEncryptedPassword (password,PublicExponent,modulus) {
        setMaxDigits(130);
        var key = new RSAKeyPair(PublicExponent, "", modulus);
        return encryptedString(key, password);
    }
    // 7c24df7d383f1e66bee1796349d69d7b4ac1b710128bce5735f196d984a5c2737f58cc6e2ed47b4dc799de1670e631647551f01adcebe1fb7dd4df533dffd09d
    // 22a8703b0b6dff53d3baeffa3db1b8d948a241122d2d8ed50a569e2a72d45c6f51659293f14b89e681898f47084c56864d512ced4bface9c9444a41fc77c5df5
    

    Python代码:

    import execjs
    import requests
    
    # 设定密码
    def set_password():
        password = "123"
        pwd_rev = list(password)
        pwd_rev.reverse()
        s = "".join(pwd_rev)
        return s
    
    # 获取model pub值
    def get_model_and_pub(password):
        with open('js.js', 'r', encoding="utf-8") as f:
            js_data = f.read()
        modulus = requests.get(url='https://ca.sdvcst.edu.cn/cas/v2/getPubKey').json().get('modulus')
        PublicExponent = requests.get(url='https://ca.sdvcst.edu.cn/cas/v2/getPubKey').json().get('exponent')
        js = execjs.compile(js_data, cwd=r'D:\Program Files\node\node_modules')
        ret2 = js.call("getEncryptedPassword",password,PublicExponent,modulus)
        print(ret2)
    
    if __name__ == '__main__':
        password = set_password()
        key = get_model_and_pub(password)
    
    
    展开全文
  • 该项目可用各类java课程设计大作业中, 学生实训平台的系统架构分为前后台两部分, 最终实现在线上进行学生实训平台各项功能,实现了诸如用户管理, 登录注册, 权限管理等功能, 并实现对各类学生实训平台相关的实体进行...

    基于jsp+servlet+pojo+mysql实现一个javaee/javaweb的学生实训平台, 该项目可用各类java课程设计大作业中, 学生实训平台的系统架构分为前后台两部分, 最终实现在线上进行学生实训平台各项功能,实现了诸如用户管理, 登录注册, 权限管理等功能, 并实现对各类学生实训平台相关的实体进行管理。

    该学生实训平台为一个采用mvc设计模式进行开发B/S架构项目,并采用分层架构对项目进行架构, 分为pojo+action+service, 其中pojo表明该系统的各类数据库表对应的实体, 在对学生实训平台进行详细的需求分析后与数据库设计后, 设计实现了如下模块, 即登录模块,权限管理模块, 用户管理模块,学生实训平台信息管理模块等。并通过java抽象类对其实现

    开发环境

    java环境: Jdk1.8

    Ide: Eclipse EE或者jetbrains Idea

    数据库: mysql5.6以上

    依赖框架:javascript, css, jsp, servlet, filter

    系统需求分析与流程图

    一般而言, 此类的javaweb课程设计大作业都比较简单, 主要目的在于掌握基础的web开发知识, 所以在实现该学生实训平台的课程设计的时候, 需要首先收集其他的学生实训平台产品分析, 主要精力用于完成数据库表的设计, 以及基于mvc模式进行代码编写, 页面可以简单的利用bootstrap进行搭建, 进而完成学生实训平台各个模块的开发

    数据库课程设计

    数据库设计是整个学生实训平台系统能否正常运转的核心, 合理的数据库设计直接影响到学生实训平台是否能够正常运行, 本系统采用mysql数据库作为数据存储, 引擎采用innoddb

    系统演示视频

    运行截图

    d01198a72ae1fbc0b17d99c5eb17e7cb.png

    基于jsp的学生实训平台-登陆功能界面

    70d59d38969cd2a75750bf2550411c44.png

    基于jsp的学生实训平台-前台首页

    02ae7db5b5735c069aeb08d31b358e61.png

    基于jsp的学生实训平台-后台信息管理页面

    50020f769238bef6d526587f5d0847a8.png

    学生实训平台系统架构图

    cd05441a10eac1d6213ef6eabff769a3.png

    注意事项

    该基于jsp的学生实训平台项目自带源码, 论文, sql数据库, 答辩ppt, 中期检查报告

    项目首页登陆地址 https://localhost:8080/login.jsp

    项目后台陆地址 https://localhost:8080/admin/login.jsp

    测试用户 cswork 密码 123456

    测试管理员 admin 密码 admin

    功能列表

    学生实训平台系统登陆模块, 实现学生实训平台系统的登陆注册权限角色用户的增删改查

    学生实训平台用户管理模块, 实现学生实训平台系统的信息管理与增删改查

    前台信息管理模块, 面向普通用户, 实现普通用户对学生实训平台的录入 修改 删除 自定义查询

    超级管理员管理, 实现后台管理员对学生实训平台系统的各个模块管理功能, 各个子模块高内聚低耦合

    展开全文
  • 畅言作业平台学生

    2021-06-11 03:55:08
    畅言作业平台学生端是一款移动教学工具,畅言作业平台学生端潜心K12工作答疑解惑,畅言作业平台手机软件一对一在线指导,错题本自动生成,添加畅言作业平台中的学神圈给你随时轻轻松松学习培训。软件介绍畅言作业...

    畅言作业平台学生端是一款移动教学工具,畅言作业平台学生端潜心K12工作答疑解惑,畅言作业平台手机软件一对一在线指导,错题本自动生成,添加畅言作业平台中的学神圈给你随时轻轻松松学习培训。

    软件介绍

    畅言作业平台学生端最真正的北上广深一线名校优秀教师二十四小时线上任你选,一对一在线指导,解释你的各种各样难题,畅言作业平台也有大量名校优秀教师精彩纷呈微型课,每科教学设计一键查询,犯错的题型自动生成到每科错题本,快速提高学习

    畅言作业平台学生端是一款移动教学工具,畅言作业平台学生端潜心K12工作答疑解惑,畅言作业平台手机软件一对一在线指导,错题本自动生成,添加畅言作业平台中的学神圈给你随时轻轻松松学习培训。

    软件介绍

    畅言作业平台学生端最真正的北上广深一线名校优秀教师二十四小时线上任你选,一对一在线指导,解释你的各种各样难题,畅言作业平台也有大量名校优秀教师精彩纷呈微型课,每科教学设计一键查询,犯错的题型自动生成到每科错题本,快速提高学习培训升級。

    功能介绍

    1、一对一在线指导所有来源于真正的名校优秀教师,师资力量品质保证!畅言作业平台就是你迅速增分、高等院校学习培训的必需秘笈。

    2、教学中心:名校优秀教师精彩纷呈微型课一应俱全!校园女神教师讲解视频任你挑。

    3、错题本自动生成:仍在手抄错题集?太LOW啦!犯错的题型自动生成到每科错题本,还能够手动式加上,而且适用一键复印作用,高端大气有没有?

    4、教学设计:每科教学设计一键查询,共享资源无障!从此不必担心看不见注意力不集中没记全教学设计了!

    5、学神圈:和中国各省学神一起沟通交流PK,共享学习方法!助你变成更强的学霸君!

    软件优势

    畅言作业平台学生端是一款潜心K12工作答疑解惑的数字化学习手机客户端,是全国各地百所名校老师学生常态应用的学习的软件!

    畅言作业平台进驻了很多北上广深一线名校优秀教师!大量高品质教学资源任你选!随时,想问就问!

    一对一在线指导所有来源于最真正的名校优秀教师,师资力量品质肯定确保!畅言作业平台就是你迅速增分、高等院校学习培训的必需秘笈。

    本年度受欢迎学习的软件,走入百所名校,获得数百万学员的瘋狂青睐!畅言作业平台在手上,变成学神轻松!好分(da)数(an)是我!

    软件特色

    【班集体信息内容展现】

    班集体首页是一个信息内容汇聚、展现的服务平台,教师、学员、父母用户可查询系统信息、公告信息,另外公布升级自身的情况;老师学生、父母根据动态性、博闻等方法开展观念沟通交流、共享资源,学员以文本、多媒体系统等方法,对平时的生活的感悟、学习体会、课堂教学体会、课余学习方法、课余相处、兴趣爱好等发布自身的看法;

    【线上作业】

    老师用户根据该地区公布工作信息内容,学员和父母用户则根据该地区接纳、查询基本信息;老师用户网上公布工作,对学员开展消息推送;学员网上进行工作。

    【才艺表演】

    用户可在该版块公布文本系统日志,并在系统日志内加上多媒体系统联接;该控制模块另外对系统日志开展了书法艺术、美术绘画、歌曲、民族舞蹈小项的细分化;学员和父母公布的系统日志须经教师用户审批;

    【相片墙和视频区】

    适用用户提交、图片分享视频等多媒体系统資源,适用当地提交和百度云盘提交二种提交方法;

    【光荣榜】

    仿真模拟实际中的老师学生主题活动,以“班集体明星”、“荣誉墙”、“夸奖栏”等方法虚拟现实技术教学活动;老师用户根据服务平台对学员开展夸奖,而父母用户则能够及时查询基本信息。

    更新日志

    1.在新年大礼包吃了一半后,程序猿终于让新的大上线了!

    2.根据大家在课间十分钟的反馈,程序猿悄咪咪地做了些优化!

    [展开全部↓]

    展开全文
  • 国家中小学网络云平台登录入口_国家中小学网络云平台网,国家中小学网络云平台资源包括防疫教育、品德教育、专题教育、课程学习、电子教材、影视教育及有关地方教育资源。教育部利用国家中小学网络云平台和中国教育...

    国家中小学网络云平台登录入口_国家中小学网络云平台网,国家中小学网络云平台资源包括防疫教育、品德教育、专题教育、课程学习、电子教材、影视教育及有关地方教育资源。教育部利用国家中小学网络云平台和中国教育电视台提供优质学习资源,服务学生居家学习,供自主选择使用。

    51dc1f523edcae8e169388371e135987.png

    国家中小学网络云平台资源介绍

    一、为配合做好新冠肺炎防控工作,教育部利用国家中小学网络云平台和中国教育电视台提供优质学习资源,服务学生居家学习,供自主选择使用。

    二、平台资源包括:防疫教育、品德教育、专题教育、课程学习、电子教材、影视教育及有关地方教育资源。资源将陆续更新补充。

    三、平台提供的课程学习资源,不代替学校正常课堂教学。

    四、为尽量减少小学生上网时间,并防止网络“拥堵”,小学阶段课程学习资源由中国教育电视台4频道播出,本平台提供初中、普通高中课程学习资源。

    五、本平台所有学习资源均免费使用。

    以上就是国家中小学网络云平台登录入口_2020国家中小学网络云平台的内容介绍,​希望可以帮助到大家!

    温馨提示:控制上网时间,保护视力、锻炼身体!

    国家中小学网络云平台登录入口_国家中小学网络云平台网

    展开全文
  • 该项目可用各类java课程设计大作业中, 大学生家教平台的系统架构分为前后台两部分, 最终实现在线上进行大学生家教平台各项功能,实现了诸如用户管理, 登录注册, 权限管理等功能, 并实现对各类大学生家教平台相关的...
  • 教育部利用国家中小学网络云平台和中国教育电视台提供优质学习资源,服务学生居家学习,供自主选择使用。一、为配合做好新冠肺炎防控工作,教育部利用国家中小学网络云平台和中国教育电视台提供优质学习资源,服务...
  • 学生成长评价平台的下载 与 疫情申报 步骤1 下载app (注意是下载校园端) 安卓手机下载方法 苹果手机下载方法 步骤2.登录账户 学号 和 **初始密码Yoya123456 ** 登录 进入后需要修改账户名和密码 初始密码为:...
  • 项目运行截图 账户密码 admin/11111 技术描述 开发工具: idea/eclipse ...基于SpringBoot+SSM的大学生兼职平台,系统Spring,SpringMvc,Mybatis,SpringBoot框架,前端页面采用Html+Thymele
  • 1、用户模块:学生用户:登陆账号为学号,初始密码为学号前6位。教师(评委)登陆账号为学工号,初始密码为学工号前6位、管理员(账号密码指定)。 2、信息发布模块:用于发布竞赛举办的相关信息,包括竞赛的举办...
  • 基于PHP的学生选课管理平台(带后台管理) 一 项目介绍 前台学生选课+后台管理系统,前端基于html+css+javascript+jquery,后端原生php,mysql数据库,可搭建在phpstudy下快速部署。 二 主要功能 前台(学生) 1 注册...
  • 甘肃省教育云平台

    千次阅读 2020-12-31 09:47:49
    甘肃省教育云平台学生登录地址为大家分享,这是一款针对于甘肃省的高校打造的在线教育平台,可以不断的为用户们带来各种各样的学习资源,非常的实用,而且有什么不懂的还可以在线和专业导师互动提问,有需要的就感激...
  • 基于SSM的学生兼职平台JAVA MySQL

    千次阅读 2021-10-31 14:32:38
    10219-基于SSM的学生兼职平台 技术 SSM 开发工具 eclipse + tomact + mysql + jdk 功能详情: 前台: 系统登录 、系统注册 、论坛交流 、发布帖子 、个人中心 、平台公告 、收藏管理 后台 : 用户管理 、兼职管理 、...
  • 软件简介为襄阳地区的学生带来一个线上学习平台,在无法外出,不能去学校的时候,也不会耽误孩子的学习,里面都是名师授课,强大的师资力量,而且是在线上进行直播讲课的,学习的学生不受地点限制,甚至是全襄阳以及...
  • 主要分为三个角色,分别为学生、企业、管理员。 下面我们来看看功能。 系统登录: http://localhost:8088/SSM/index user表 系统注册 无账户情况下可以注册 首页 可以按照分类查看不同的兼职,也可以搜索...
  • } /** * 用户未登录异常 */ @ExceptionHandler(AuthenticationException.class) @ResponseStatus(HttpStatus.UNAUTHORIZED) public String unAuth(AuthenticationException e) { log.error("用户未登陆:", e);...
  • 安全教育平台登录失败是怎么回事 解决方法2020-12-18 16:22:21 来源:网络整理扫码可以:1.在手机上浏览2.分享给微信好友或朋友圈摘要:有很多的同学们反映说安全教育平台一直登录不上,但是自己账号和密码都是对的...
  • 平台通过对学生日常行为量化考评和班主任综合评价两种方式,形成学生成长过程中的综合考评结果,方便学校为学生的下一步成长提供指导。 2.平台特色 2.1.功能特色 l自定义量化考核指标,含扣分和加分项 l量化的...
  • 面向高校中所有的社团,建立一个使用便捷、可靠的社团活动平台,从而更方便地进行社团活动的申请、社团资源的申请及相应审批,并且提供一个全校社团活动的展示平台,方便学生了解查看社团活动且可进行线上报名。...
  • 安全教育平台登录注册游戏亮点1、提供张掖当地的学子们完成网络在线课程学习,以及网络家庭作业的安全教育学习平台,通过这款学习平台将快速的掌握各项安全教育知识!2、拥有着全面的系统化学习方式让你在学习安全...
  • 安全教育平台登录不上解决办法:1.第一种情况:要确定你输入的账号和密码是否正确。2.第二种情况:如果确定账号和密码无误的情况下,看下平台是否不兼容你目前使用的浏览器,更换浏览器试试。3.第三种情况:如果这个...
  • 通过电子健康档案管理系统这个平台,可以实现人员健康情况的信息化、网络化、系统化、规范化管理,从繁杂的数据查询和统计中解脱出来,更好的掌握人员健康状况。系统的主要功能包括:人员档案管理、体检管理与疾病...
  • 本中小学生学习平台主要包括系统用户管理模块、课程信息管理模块、图书信息管理、订单管理、登录模块、和退出模块等多个模块。它帮助学习平台实现了信息化、网络化,通过测试,实现了系统设计目标,相比传统的管理...
  • } public int recivice(String[][] a) { System.out.println("请输入你要修改的学生信息的学生学号!"); int id; int n=-1; id = sc.nextInt(); for(int i=0;i { if(Integer.parseInt(a[i][0]) == id) { n=i; break...
  • 申请加入社团,报名社团活动,在前台用户可以通过标题和类别进行前台信息的搜索,社团负责人可以登录个人中心进行个人资料管理、学生入团管理(学生入团审批、删除、修改)、社团公告管理(社团公告发...
  • 襄阳教育云平台学生空间官网登录入口就是最近通过优教信使客户来进行的直播在线工具,襄阳教育云平台也是为了本地的学生和老师可以在网上进行授课而开发的,希望对大家的学习有帮助!官网介绍为襄阳地区的学生带来一...
  • 4、系统主要模块设计与实现 4.1、登录 登录是使用该系统的第一个步骤, 系统共分4种角色, 分别为管理员、辅导员、班委、学生, 每种身份有不同的权限, 系统验证登录者身份后, 合法的身份将允许其进入本系统。登录过程...
  • 摘要:随着信息化技术的发展,社会各领域逐步实现信息化管理,在高校中表现为校内学生管理信息化系统... 本文源于贺州学院学生管理工作的实际需要,对教师在实际工作中的需求进行分析后,我们确定了基于安卓平台学生管...
  • 原标题:基于python的学生信息管理系统!听说好多人的作业都是这个完整代码import pymysqlindex='''+---------------------+首页欢迎来到学生信息管理系统1.登陆2.注册3.quit(按任意键退出)+---------------------+'...
  • 软件介绍学堂在线学生登录入口app是进入学习教室以了解该主题的关键知识的平台。各种优秀的学科资源将出现在这里,并且正常的学习进度不会因在线课程而延迟。教育方法相对科学有效,教师还将及时分配作业供大家完成...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,114
精华内容 10,845
关键字:

学生平台登录