0) {
+ if(p < this.DB && (d = this[i]>>p) > 0) { m = true; r = int2char(d); }
+ while(i >= 0) {
+ if(p < k) {
+ d = (this[i]&((1<>(p+=this.DB-k);
+ }
+ else {
+ d = (this[i]>>(p-=k))&km;
+ if(p <= 0) { p += this.DB; --i; }
+ }
+ if(d > 0) m = true;
+ if(m) r += int2char(d);
+ }
+ }
+ return m?r:"0";
+}
+
+// (public) -this
+function bnNegate() { var r = nbi(); BigInteger.ZERO.subTo(this,r); return r; }
+
+// (public) |this|
+function bnAbs() { return (this.s<0)?this.negate():this; }
+
+// (public) return + if this > a, - if this < a, 0 if equal
+function bnCompareTo(a) {
+ var r = this.s-a.s;
+ if(r != 0) return r;
+ var i = this.t;
+ r = i-a.t;
+ if(r != 0) return (this.s<0)?-r:r;
+ while(--i >= 0) if((r=this[i]-a[i]) != 0) return r;
+ return 0;
+}
+
+// returns bit length of the integer x
+function nbits(x) {
+ var r = 1, t;
+ if((t=x>>>16) != 0) { x = t; r += 16; }
+ if((t=x>>8) != 0) { x = t; r += 8; }
+ if((t=x>>4) != 0) { x = t; r += 4; }
+ if((t=x>>2) != 0) { x = t; r += 2; }
+ if((t=x>>1) != 0) { x = t; r += 1; }
+ return r;
+}
+
+// (public) return the number of bits in "this"
+function bnBitLength() {
+ if(this.t <= 0) return 0;
+ return this.DB*(this.t-1)+nbits(this[this.t-1]^(this.s&this.DM));
+}
+
+// (protected) r = this << n*DB
+function bnpDLShiftTo(n,r) {
+ var i;
+ for(i = this.t-1; i >= 0; --i) r[i+n] = this[i];
+ for(i = n-1; i >= 0; --i) r[i] = 0;
+ r.t = this.t+n;
+ r.s = this.s;
+}
+
+// (protected) r = this >> n*DB
+function bnpDRShiftTo(n,r) {
+ for(var i = n; i < this.t; ++i) r[i-n] = this[i];
+ r.t = Math.max(this.t-n,0);
+ r.s = this.s;
+}
+
+// (protected) r = this << n
+function bnpLShiftTo(n,r) {
+ var bs = n%this.DB;
+ var cbs = this.DB-bs;
+ var bm = (1<= 0; --i) {
+ r[i+ds+1] = (this[i]>>cbs)|c;
+ c = (this[i]&bm)<= 0; --i) r[i] = 0;
+ r[ds] = c;
+ r.t = this.t+ds+1;
+ r.s = this.s;
+ r.clamp();
+}
+
+// (protected) r = this >> n
+function bnpRShiftTo(n,r) {
+ r.s = this.s;
+ var ds = Math.floor(n/this.DB);
+ if(ds >= this.t) { r.t = 0; return; }
+ var bs = n%this.DB;
+ var cbs = this.DB-bs;
+ var bm = (1<>bs;
+ for(var i = ds+1; i < this.t; ++i) {
+ r[i-ds-1] |= (this[i]&bm)<>bs;
+ }
+ if(bs > 0) r[this.t-ds-1] |= (this.s&bm)<>= this.DB;
+ }
+ if(a.t < this.t) {
+ c -= a.s;
+ while(i < this.t) {
+ c += this[i];
+ r[i++] = c&this.DM;
+ c >>= this.DB;
+ }
+ c += this.s;
+ }
+ else {
+ c += this.s;
+ while(i < a.t) {
+ c -= a[i];
+ r[i++] = c&this.DM;
+ c >>= this.DB;
+ }
+ c -= a.s;
+ }
+ r.s = (c<0)?-1:0;
+ if(c < -1) r[i++] = this.DV+c;
+ else if(c > 0) r[i++] = c;
+ r.t = i;
+ r.clamp();
+}
+
+// (protected) r = this * a, r != this,a (HAC 14.12)
+// "this" should be the larger one if appropriate.
+function bnpMultiplyTo(a,r) {
+ var x = this.abs(), y = a.abs();
+ var i = x.t;
+ r.t = i+y.t;
+ while(--i >= 0) r[i] = 0;
+ for(i = 0; i < y.t; ++i) r[i+x.t] = x.am(0,y[i],r,i,0,x.t);
+ r.s = 0;
+ r.clamp();
+ if(this.s != a.s) BigInteger.ZERO.subTo(r,r);
+}
+
+// (protected) r = this^2, r != this (HAC 14.16)
+function bnpSquareTo(r) {
+ var x = this.abs();
+ var i = r.t = 2*x.t;
+ while(--i >= 0) r[i] = 0;
+ for(i = 0; i < x.t-1; ++i) {
+ var c = x.am(i,x[i],r,2*i,0,1);
+ if((r[i+x.t]+=x.am(i+1,2*x[i],r,2*i+1,c,x.t-i-1)) >= x.DV) {
+ r[i+x.t] -= x.DV;
+ r[i+x.t+1] = 1;
+ }
+ }
+ if(r.t > 0) r[r.t-1] += x.am(i,x[i],r,2*i,0,1);
+ r.s = 0;
+ r.clamp();
+}
+
+// (protected) divide this by m, quotient and remainder to q, r (HAC 14.20)
+// r != q, this != m. q or r may be null.
+function bnpDivRemTo(m,q,r) {
+ var pm = m.abs();
+ if(pm.t <= 0) return;
+ var pt = this.abs();
+ if(pt.t < pm.t) {
+ if(q != null) q.fromInt(0);
+ if(r != null) this.copyTo(r);
+ return;
+ }
+ if(r == null) r = nbi();
+ var y = nbi(), ts = this.s, ms = m.s;
+ var nsh = this.DB-nbits(pm[pm.t-1]); // normalize modulus
+ if(nsh > 0) { pm.lShiftTo(nsh,y); pt.lShiftTo(nsh,r); }
+ else { pm.copyTo(y); pt.copyTo(r); }
+ var ys = y.t;
+ var y0 = y[ys-1];
+ if(y0 == 0) return;
+ var yt = y0*(1<1)?y[ys-2]>>this.F2:0);
+ var d1 = this.FV/yt, d2 = (1<= 0) {
+ r[r.t++] = 1;
+ r.subTo(t,r);
+ }
+ BigInteger.ONE.dlShiftTo(ys,t);
+ t.subTo(y,y); // "negative" y so we can replace sub with am later
+ while(y.t < ys) y[y.t++] = 0;
+ while(--j >= 0) {
+ // Estimate quotient digit
+ var qd = (r[--i]==y0)?this.DM:Math.floor(r[i]*d1+(r[i-1]+e)*d2);
+ if((r[i]+=y.am(0,qd,r,j,0,ys)) < qd) { // Try it out
+ y.dlShiftTo(j,t);
+ r.subTo(t,r);
+ while(r[i] < --qd) r.subTo(t,r);
+ }
+ }
+ if(q != null) {
+ r.drShiftTo(ys,q);
+ if(ts != ms) BigInteger.ZERO.subTo(q,q);
+ }
+ r.t = ys;
+ r.clamp();
+ if(nsh > 0) r.rShiftTo(nsh,r); // Denormalize remainder
+ if(ts < 0) BigInteger.ZERO.subTo(r,r);
+}
+
+// (public) this mod a
+function bnMod(a) {
+ var r = nbi();
+ this.abs().divRemTo(a,null,r);
+ if(this.s < 0 && r.compareTo(BigInteger.ZERO) > 0) a.subTo(r,r);
+ return r;
+}
+
+// Modular reduction using "classic" algorithm
+function Classic(m) { this.m = m; }
+function cConvert(x) {
+ if(x.s < 0 || x.compareTo(this.m) >= 0) return x.mod(this.m);
+ else return x;
+}
+function cRevert(x) { return x; }
+function cReduce(x) { x.divRemTo(this.m,null,x); }
+function cMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }
+function cSqrTo(x,r) { x.squareTo(r); this.reduce(r); }
+
+Classic.prototype.convert = cConvert;
+Classic.prototype.revert = cRevert;
+Classic.prototype.reduce = cReduce;
+Classic.prototype.mulTo = cMulTo;
+Classic.prototype.sqrTo = cSqrTo;
+
+// (protected) return "-1/this % 2^DB"; useful for Mont. reduction
+// justification:
+// xy == 1 (mod m)
+// xy = 1+km
+// xy(2-xy) = (1+km)(1-km)
+// x[y(2-xy)] = 1-k^2m^2
+// x[y(2-xy)] == 1 (mod m^2)
+// if y is 1/x mod m, then y(2-xy) is 1/x mod m^2
+// should reduce x and y(2-xy) by m^2 at each step to keep size bounded.
+// JS multiply "overflows" differently from C/C++, so care is needed here.
+function bnpInvDigit() {
+ if(this.t < 1) return 0;
+ var x = this[0];
+ if((x&1) == 0) return 0;
+ var y = x&3; // y == 1/x mod 2^2
+ y = (y*(2-(x&0xf)*y))&0xf; // y == 1/x mod 2^4
+ y = (y*(2-(x&0xff)*y))&0xff; // y == 1/x mod 2^8
+ y = (y*(2-(((x&0xffff)*y)&0xffff)))&0xffff; // y == 1/x mod 2^16
+ // last step - calculate inverse mod DV directly;
+ // assumes 16 < DB <= 32 and assumes ability to handle 48-bit ints
+ y = (y*(2-x*y%this.DV))%this.DV; // y == 1/x mod 2^dbits
+ // we really want the negative inverse, and -DV < y < DV
+ return (y>0)?this.DV-y:-y;
+}
+
+// Montgomery reduction
+function Montgomery(m) {
+ this.m = m;
+ this.mp = m.invDigit();
+ this.mpl = this.mp&0x7fff;
+ this.mph = this.mp>>15;
+ this.um = (1<<(m.DB-15))-1;
+ this.mt2 = 2*m.t;
+}
+
+// xR mod m
+function montConvert(x) {
+ var r = nbi();
+ x.abs().dlShiftTo(this.m.t,r);
+ r.divRemTo(this.m,null,r);
+ if(x.s < 0 && r.compareTo(BigInteger.ZERO) > 0) this.m.subTo(r,r);
+ return r;
+}
+
+// x/R mod m
+function montRevert(x) {
+ var r = nbi();
+ x.copyTo(r);
+ this.reduce(r);
+ return r;
+}
+
+// x = x/R mod m (HAC 14.32)
+function montReduce(x) {
+ while(x.t <= this.mt2) // pad x so am has enough room later
+ x[x.t++] = 0;
+ for(var i = 0; i < this.m.t; ++i) {
+ // faster way of calculating u0 = x[i]*mp mod DV
+ var j = x[i]&0x7fff;
+ var u0 = (j*this.mpl+(((j*this.mph+(x[i]>>15)*this.mpl)&this.um)<<15))&x.DM;
+ // use am to combine the multiply-shift-add into one call
+ j = i+this.m.t;
+ x[j] += this.m.am(0,u0,x,i,0,this.m.t);
+ // propagate carry
+ while(x[j] >= x.DV) { x[j] -= x.DV; x[++j]++; }
+ }
+ x.clamp();
+ x.drShiftTo(this.m.t,x);
+ if(x.compareTo(this.m) >= 0) x.subTo(this.m,x);
+}
+
+// r = "x^2/R mod m"; x != r
+function montSqrTo(x,r) { x.squareTo(r); this.reduce(r); }
+
+// r = "xy/R mod m"; x,y != r
+function montMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }
+
+Montgomery.prototype.convert = montConvert;
+Montgomery.prototype.revert = montRevert;
+Montgomery.prototype.reduce = montReduce;
+Montgomery.prototype.mulTo = montMulTo;
+Montgomery.prototype.sqrTo = montSqrTo;
+
+// (protected) true iff this is even
+function bnpIsEven() { return ((this.t>0)?(this[0]&1):this.s) == 0; }
+
+// (protected) this^e, e < 2^32, doing sqr and mul with "r" (HAC 14.79)
+function bnpExp(e,z) {
+ if(e > 0xffffffff || e < 1) return BigInteger.ONE;
+ var r = nbi(), r2 = nbi(), g = z.convert(this), i = nbits(e)-1;
+ g.copyTo(r);
+ while(--i >= 0) {
+ z.sqrTo(r,r2);
+ if((e&(1< 0) z.mulTo(r2,g,r);
+ else { var t = r; r = r2; r2 = t; }
+ }
+ return z.revert(r);
+}
+
+// (public) this^e % m, 0 <= e < 2^32
+function bnModPowInt(e,m) {
+ var z;
+ if(e < 256 || m.isEven()) z = new Classic(m); else z = new Montgomery(m);
+ return this.exp(e,z);
+}
+
+// protected
+BigInteger.prototype.copyTo = bnpCopyTo;
+BigInteger.prototype.fromInt = bnpFromInt;
+BigInteger.prototype.fromString = bnpFromString;
+BigInteger.prototype.clamp = bnpClamp;
+BigInteger.prototype.dlShiftTo = bnpDLShiftTo;
+BigInteger.prototype.drShiftTo = bnpDRShiftTo;
+BigInteger.prototype.lShiftTo = bnpLShiftTo;
+BigInteger.prototype.rShiftTo = bnpRShiftTo;
+BigInteger.prototype.subTo = bnpSubTo;
+BigInteger.prototype.multiplyTo = bnpMultiplyTo;
+BigInteger.prototype.squareTo = bnpSquareTo;
+BigInteger.prototype.divRemTo = bnpDivRemTo;
+BigInteger.prototype.invDigit = bnpInvDigit;
+BigInteger.prototype.isEven = bnpIsEven;
+BigInteger.prototype.exp = bnpExp;
+
+// public
+BigInteger.prototype.toString = bnToString;
+BigInteger.prototype.negate = bnNegate;
+BigInteger.prototype.abs = bnAbs;
+BigInteger.prototype.compareTo = bnCompareTo;
+BigInteger.prototype.bitLength = bnBitLength;
+BigInteger.prototype.mod = bnMod;
+BigInteger.prototype.modPowInt = bnModPowInt;
+
+// "constants"
+BigInteger.ZERO = nbv(0);
+BigInteger.ONE = nbv(1);
+
+module.exports.BigInteger = BigInteger;
diff --git a/jslib/jsbn2.js b/jslib/jsbn2.js
new file mode 100644
index 0000000..5b2b725
--- /dev/null
+++ b/jslib/jsbn2.js
@@ -0,0 +1,656 @@
+// Copyright (c) 2005-2009 Tom Wu
+// All Rights Reserved.
+// See "LICENSE" for details.
+
+// Extended JavaScript BN functions, required for RSA private ops.
+
+// Version 1.1: new BigInteger("0", 10) returns "proper" zero
+// Version 1.2: square() API, isProbablePrime fix
+
+// (public)
+function bnClone() { var r = nbi(); this.copyTo(r); return r; }
+
+// (public) return value as integer
+function bnIntValue() {
+ if(this.s < 0) {
+ if(this.t == 1) return this[0]-this.DV;
+ else if(this.t == 0) return -1;
+ }
+ else if(this.t == 1) return this[0];
+ else if(this.t == 0) return 0;
+ // assumes 16 < DB < 32
+ return ((this[1]&((1<<(32-this.DB))-1))<>24; }
+
+// (public) return value as short (assumes DB>=16)
+function bnShortValue() { return (this.t==0)?this.s:(this[0]<<16)>>16; }
+
+// (protected) return x s.t. r^x < DV
+function bnpChunkSize(r) { return Math.floor(Math.LN2*this.DB/Math.log(r)); }
+
+// (public) 0 if this == 0, 1 if this > 0
+function bnSigNum() {
+ if(this.s < 0) return -1;
+ else if(this.t <= 0 || (this.t == 1 && this[0] <= 0)) return 0;
+ else return 1;
+}
+
+// (protected) convert to radix string
+function bnpToRadix(b) {
+ if(b == null) b = 10;
+ if(this.signum() == 0 || b < 2 || b > 36) return "0";
+ var cs = this.chunkSize(b);
+ var a = Math.pow(b,cs);
+ var d = nbv(a), y = nbi(), z = nbi(), r = "";
+ this.divRemTo(d,y,z);
+ while(y.signum() > 0) {
+ r = (a+z.intValue()).toString(b).substr(1) + r;
+ y.divRemTo(d,y,z);
+ }
+ return z.intValue().toString(b) + r;
+}
+
+// (protected) convert from radix string
+function bnpFromRadix(s,b) {
+ this.fromInt(0);
+ if(b == null) b = 10;
+ var cs = this.chunkSize(b);
+ var d = Math.pow(b,cs), mi = false, j = 0, w = 0;
+ for(var i = 0; i < s.length; ++i) {
+ var x = intAt(s,i);
+ if(x < 0) {
+ if(s.charAt(i) == "-" && this.signum() == 0) mi = true;
+ continue;
+ }
+ w = b*w+x;
+ if(++j >= cs) {
+ this.dMultiply(d);
+ this.dAddOffset(w,0);
+ j = 0;
+ w = 0;
+ }
+ }
+ if(j > 0) {
+ this.dMultiply(Math.pow(b,j));
+ this.dAddOffset(w,0);
+ }
+ if(mi) BigInteger.ZERO.subTo(this,this);
+}
+
+// (protected) alternate constructor
+function bnpFromNumber(a,b,c) {
+ if("number" == typeof b) {
+ // new BigInteger(int,int,RNG)
+ if(a < 2) this.fromInt(1);
+ else {
+ this.fromNumber(a,c);
+ if(!this.testBit(a-1)) // force MSB set
+ this.bitwiseTo(BigInteger.ONE.shiftLeft(a-1),op_or,this);
+ if(this.isEven()) this.dAddOffset(1,0); // force odd
+ while(!this.isProbablePrime(b)) {
+ this.dAddOffset(2,0);
+ if(this.bitLength() > a) this.subTo(BigInteger.ONE.shiftLeft(a-1),this);
+ }
+ }
+ }
+ else {
+ // new BigInteger(int,RNG)
+ var x = new Array(), t = a&7;
+ x.length = (a>>3)+1;
+ b.nextBytes(x);
+ if(t > 0) x[0] &= ((1< 0) {
+ if(p < this.DB && (d = this[i]>>p) != (this.s&this.DM)>>p)
+ r[k++] = d|(this.s<<(this.DB-p));
+ while(i >= 0) {
+ if(p < 8) {
+ d = (this[i]&((1<>(p+=this.DB-8);
+ }
+ else {
+ d = (this[i]>>(p-=8))&0xff;
+ if(p <= 0) { p += this.DB; --i; }
+ }
+ if((d&0x80) != 0) d |= -256;
+ if(k == 0 && (this.s&0x80) != (d&0x80)) ++k;
+ if(k > 0 || d != this.s) r[k++] = d;
+ }
+ }
+ return r;
+}
+
+function bnEquals(a) { return(this.compareTo(a)==0); }
+function bnMin(a) { return(this.compareTo(a)<0)?this:a; }
+function bnMax(a) { return(this.compareTo(a)>0)?this:a; }
+
+// (protected) r = this op a (bitwise)
+function bnpBitwiseTo(a,op,r) {
+ var i, f, m = Math.min(a.t,this.t);
+ for(i = 0; i < m; ++i) r[i] = op(this[i],a[i]);
+ if(a.t < this.t) {
+ f = a.s&this.DM;
+ for(i = m; i < this.t; ++i) r[i] = op(this[i],f);
+ r.t = this.t;
+ }
+ else {
+ f = this.s&this.DM;
+ for(i = m; i < a.t; ++i) r[i] = op(f,a[i]);
+ r.t = a.t;
+ }
+ r.s = op(this.s,a.s);
+ r.clamp();
+}
+
+// (public) this & a
+function op_and(x,y) { return x&y; }
+function bnAnd(a) { var r = nbi(); this.bitwiseTo(a,op_and,r); return r; }
+
+// (public) this | a
+function op_or(x,y) { return x|y; }
+function bnOr(a) { var r = nbi(); this.bitwiseTo(a,op_or,r); return r; }
+
+// (public) this ^ a
+function op_xor(x,y) { return x^y; }
+function bnXor(a) { var r = nbi(); this.bitwiseTo(a,op_xor,r); return r; }
+
+// (public) this & ~a
+function op_andnot(x,y) { return x&~y; }
+function bnAndNot(a) { var r = nbi(); this.bitwiseTo(a,op_andnot,r); return r; }
+
+// (public) ~this
+function bnNot() {
+ var r = nbi();
+ for(var i = 0; i < this.t; ++i) r[i] = this.DM&~this[i];
+ r.t = this.t;
+ r.s = ~this.s;
+ return r;
+}
+
+// (public) this << n
+function bnShiftLeft(n) {
+ var r = nbi();
+ if(n < 0) this.rShiftTo(-n,r); else this.lShiftTo(n,r);
+ return r;
+}
+
+// (public) this >> n
+function bnShiftRight(n) {
+ var r = nbi();
+ if(n < 0) this.lShiftTo(-n,r); else this.rShiftTo(n,r);
+ return r;
+}
+
+// return index of lowest 1-bit in x, x < 2^31
+function lbit(x) {
+ if(x == 0) return -1;
+ var r = 0;
+ if((x&0xffff) == 0) { x >>= 16; r += 16; }
+ if((x&0xff) == 0) { x >>= 8; r += 8; }
+ if((x&0xf) == 0) { x >>= 4; r += 4; }
+ if((x&3) == 0) { x >>= 2; r += 2; }
+ if((x&1) == 0) ++r;
+ return r;
+}
+
+// (public) returns index of lowest 1-bit (or -1 if none)
+function bnGetLowestSetBit() {
+ for(var i = 0; i < this.t; ++i)
+ if(this[i] != 0) return i*this.DB+lbit(this[i]);
+ if(this.s < 0) return this.t*this.DB;
+ return -1;
+}
+
+// return number of 1 bits in x
+function cbit(x) {
+ var r = 0;
+ while(x != 0) { x &= x-1; ++r; }
+ return r;
+}
+
+// (public) return number of set bits
+function bnBitCount() {
+ var r = 0, x = this.s&this.DM;
+ for(var i = 0; i < this.t; ++i) r += cbit(this[i]^x);
+ return r;
+}
+
+// (public) true iff nth bit is set
+function bnTestBit(n) {
+ var j = Math.floor(n/this.DB);
+ if(j >= this.t) return(this.s!=0);
+ return((this[j]&(1<<(n%this.DB)))!=0);
+}
+
+// (protected) this op (1<>= this.DB;
+ }
+ if(a.t < this.t) {
+ c += a.s;
+ while(i < this.t) {
+ c += this[i];
+ r[i++] = c&this.DM;
+ c >>= this.DB;
+ }
+ c += this.s;
+ }
+ else {
+ c += this.s;
+ while(i < a.t) {
+ c += a[i];
+ r[i++] = c&this.DM;
+ c >>= this.DB;
+ }
+ c += a.s;
+ }
+ r.s = (c<0)?-1:0;
+ if(c > 0) r[i++] = c;
+ else if(c < -1) r[i++] = this.DV+c;
+ r.t = i;
+ r.clamp();
+}
+
+// (public) this + a
+function bnAdd(a) { var r = nbi(); this.addTo(a,r); return r; }
+
+// (public) this - a
+function bnSubtract(a) { var r = nbi(); this.subTo(a,r); return r; }
+
+// (public) this * a
+function bnMultiply(a) { var r = nbi(); this.multiplyTo(a,r); return r; }
+
+// (public) this^2
+function bnSquare() { var r = nbi(); this.squareTo(r); return r; }
+
+// (public) this / a
+function bnDivide(a) { var r = nbi(); this.divRemTo(a,r,null); return r; }
+
+// (public) this % a
+function bnRemainder(a) { var r = nbi(); this.divRemTo(a,null,r); return r; }
+
+// (public) [this/a,this%a]
+function bnDivideAndRemainder(a) {
+ var q = nbi(), r = nbi();
+ this.divRemTo(a,q,r);
+ return new Array(q,r);
+}
+
+// (protected) this *= n, this >= 0, 1 < n < DV
+function bnpDMultiply(n) {
+ this[this.t] = this.am(0,n-1,this,0,0,this.t);
+ ++this.t;
+ this.clamp();
+}
+
+// (protected) this += n << w words, this >= 0
+function bnpDAddOffset(n,w) {
+ if(n == 0) return;
+ while(this.t <= w) this[this.t++] = 0;
+ this[w] += n;
+ while(this[w] >= this.DV) {
+ this[w] -= this.DV;
+ if(++w >= this.t) this[this.t++] = 0;
+ ++this[w];
+ }
+}
+
+// A "null" reducer
+function NullExp() {}
+function nNop(x) { return x; }
+function nMulTo(x,y,r) { x.multiplyTo(y,r); }
+function nSqrTo(x,r) { x.squareTo(r); }
+
+NullExp.prototype.convert = nNop;
+NullExp.prototype.revert = nNop;
+NullExp.prototype.mulTo = nMulTo;
+NullExp.prototype.sqrTo = nSqrTo;
+
+// (public) this^e
+function bnPow(e) { return this.exp(e,new NullExp()); }
+
+// (protected) r = lower n words of "this * a", a.t <= n
+// "this" should be the larger one if appropriate.
+function bnpMultiplyLowerTo(a,n,r) {
+ var i = Math.min(this.t+a.t,n);
+ r.s = 0; // assumes a,this >= 0
+ r.t = i;
+ while(i > 0) r[--i] = 0;
+ var j;
+ for(j = r.t-this.t; i < j; ++i) r[i+this.t] = this.am(0,a[i],r,i,0,this.t);
+ for(j = Math.min(a.t,n); i < j; ++i) this.am(0,a[i],r,i,0,n-i);
+ r.clamp();
+}
+
+// (protected) r = "this * a" without lower n words, n > 0
+// "this" should be the larger one if appropriate.
+function bnpMultiplyUpperTo(a,n,r) {
+ --n;
+ var i = r.t = this.t+a.t-n;
+ r.s = 0; // assumes a,this >= 0
+ while(--i >= 0) r[i] = 0;
+ for(i = Math.max(n-this.t,0); i < a.t; ++i)
+ r[this.t+i-n] = this.am(n-i,a[i],r,0,0,this.t+i-n);
+ r.clamp();
+ r.drShiftTo(1,r);
+}
+
+// Barrett modular reduction
+function Barrett(m) {
+ // setup Barrett
+ this.r2 = nbi();
+ this.q3 = nbi();
+ BigInteger.ONE.dlShiftTo(2*m.t,this.r2);
+ this.mu = this.r2.divide(m);
+ this.m = m;
+}
+
+function barrettConvert(x) {
+ if(x.s < 0 || x.t > 2*this.m.t) return x.mod(this.m);
+ else if(x.compareTo(this.m) < 0) return x;
+ else { var r = nbi(); x.copyTo(r); this.reduce(r); return r; }
+}
+
+function barrettRevert(x) { return x; }
+
+// x = x mod m (HAC 14.42)
+function barrettReduce(x) {
+ x.drShiftTo(this.m.t-1,this.r2);
+ if(x.t > this.m.t+1) { x.t = this.m.t+1; x.clamp(); }
+ this.mu.multiplyUpperTo(this.r2,this.m.t+1,this.q3);
+ this.m.multiplyLowerTo(this.q3,this.m.t+1,this.r2);
+ while(x.compareTo(this.r2) < 0) x.dAddOffset(1,this.m.t+1);
+ x.subTo(this.r2,x);
+ while(x.compareTo(this.m) >= 0) x.subTo(this.m,x);
+}
+
+// r = x^2 mod m; x != r
+function barrettSqrTo(x,r) { x.squareTo(r); this.reduce(r); }
+
+// r = x*y mod m; x,y != r
+function barrettMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }
+
+Barrett.prototype.convert = barrettConvert;
+Barrett.prototype.revert = barrettRevert;
+Barrett.prototype.reduce = barrettReduce;
+Barrett.prototype.mulTo = barrettMulTo;
+Barrett.prototype.sqrTo = barrettSqrTo;
+
+// (public) this^e % m (HAC 14.85)
+function bnModPow(e,m) {
+ var i = e.bitLength(), k, r = nbv(1), z;
+ if(i <= 0) return r;
+ else if(i < 18) k = 1;
+ else if(i < 48) k = 3;
+ else if(i < 144) k = 4;
+ else if(i < 768) k = 5;
+ else k = 6;
+ if(i < 8)
+ z = new Classic(m);
+ else if(m.isEven())
+ z = new Barrett(m);
+ else
+ z = new Montgomery(m);
+
+ // precomputation
+ var g = new Array(), n = 3, k1 = k-1, km = (1< 1) {
+ var g2 = nbi();
+ z.sqrTo(g[1],g2);
+ while(n <= km) {
+ g[n] = nbi();
+ z.mulTo(g2,g[n-2],g[n]);
+ n += 2;
+ }
+ }
+
+ var j = e.t-1, w, is1 = true, r2 = nbi(), t;
+ i = nbits(e[j])-1;
+ while(j >= 0) {
+ if(i >= k1) w = (e[j]>>(i-k1))&km;
+ else {
+ w = (e[j]&((1<<(i+1))-1))<<(k1-i);
+ if(j > 0) w |= e[j-1]>>(this.DB+i-k1);
+ }
+
+ n = k;
+ while((w&1) == 0) { w >>= 1; --n; }
+ if((i -= n) < 0) { i += this.DB; --j; }
+ if(is1) { // ret == 1, don't bother squaring or multiplying it
+ g[w].copyTo(r);
+ is1 = false;
+ }
+ else {
+ while(n > 1) { z.sqrTo(r,r2); z.sqrTo(r2,r); n -= 2; }
+ if(n > 0) z.sqrTo(r,r2); else { t = r; r = r2; r2 = t; }
+ z.mulTo(r2,g[w],r);
+ }
+
+ while(j >= 0 && (e[j]&(1< 0) {
+ x.rShiftTo(g,x);
+ y.rShiftTo(g,y);
+ }
+ while(x.signum() > 0) {
+ if((i = x.getLowestSetBit()) > 0) x.rShiftTo(i,x);
+ if((i = y.getLowestSetBit()) > 0) y.rShiftTo(i,y);
+ if(x.compareTo(y) >= 0) {
+ x.subTo(y,x);
+ x.rShiftTo(1,x);
+ }
+ else {
+ y.subTo(x,y);
+ y.rShiftTo(1,y);
+ }
+ }
+ if(g > 0) y.lShiftTo(g,y);
+ return y;
+}
+
+// (protected) this % n, n < 2^26
+function bnpModInt(n) {
+ if(n <= 0) return 0;
+ var d = this.DV%n, r = (this.s<0)?n-1:0;
+ if(this.t > 0)
+ if(d == 0) r = this[0]%n;
+ else for(var i = this.t-1; i >= 0; --i) r = (d*r+this[i])%n;
+ return r;
+}
+
+// (public) 1/this % m (HAC 14.61)
+function bnModInverse(m) {
+ var ac = m.isEven();
+ if((this.isEven() && ac) || m.signum() == 0) return BigInteger.ZERO;
+ var u = m.clone(), v = this.clone();
+ var a = nbv(1), b = nbv(0), c = nbv(0), d = nbv(1);
+ while(u.signum() != 0) {
+ while(u.isEven()) {
+ u.rShiftTo(1,u);
+ if(ac) {
+ if(!a.isEven() || !b.isEven()) { a.addTo(this,a); b.subTo(m,b); }
+ a.rShiftTo(1,a);
+ }
+ else if(!b.isEven()) b.subTo(m,b);
+ b.rShiftTo(1,b);
+ }
+ while(v.isEven()) {
+ v.rShiftTo(1,v);
+ if(ac) {
+ if(!c.isEven() || !d.isEven()) { c.addTo(this,c); d.subTo(m,d); }
+ c.rShiftTo(1,c);
+ }
+ else if(!d.isEven()) d.subTo(m,d);
+ d.rShiftTo(1,d);
+ }
+ if(u.compareTo(v) >= 0) {
+ u.subTo(v,u);
+ if(ac) a.subTo(c,a);
+ b.subTo(d,b);
+ }
+ else {
+ v.subTo(u,v);
+ if(ac) c.subTo(a,c);
+ d.subTo(b,d);
+ }
+ }
+ if(v.compareTo(BigInteger.ONE) != 0) return BigInteger.ZERO;
+ if(d.compareTo(m) >= 0) return d.subtract(m);
+ if(d.signum() < 0) d.addTo(m,d); else return d;
+ if(d.signum() < 0) return d.add(m); else return d;
+}
+
+var lowprimes = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997];
+var lplim = (1<<26)/lowprimes[lowprimes.length-1];
+
+// (public) test primality with certainty >= 1-.5^t
+function bnIsProbablePrime(t) {
+ var i, x = this.abs();
+ if(x.t == 1 && x[0] <= lowprimes[lowprimes.length-1]) {
+ for(i = 0; i < lowprimes.length; ++i)
+ if(x[0] == lowprimes[i]) return true;
+ return false;
+ }
+ if(x.isEven()) return false;
+ i = 1;
+ while(i < lowprimes.length) {
+ var m = lowprimes[i], j = i+1;
+ while(j < lowprimes.length && m < lplim) m *= lowprimes[j++];
+ m = x.modInt(m);
+ while(i < j) if(m%lowprimes[i++] == 0) return false;
+ }
+ return x.millerRabin(t);
+}
+
+// (protected) true if probably prime (HAC 4.24, Miller-Rabin)
+function bnpMillerRabin(t) {
+ var n1 = this.subtract(BigInteger.ONE);
+ var k = n1.getLowestSetBit();
+ if(k <= 0) return false;
+ var r = n1.shiftRight(k);
+ t = (t+1)>>1;
+ if(t > lowprimes.length) t = lowprimes.length;
+ var a = nbi();
+ for(var i = 0; i < t; ++i) {
+ //Pick bases at random, instead of starting at 2
+ a.fromInt(lowprimes[Math.floor(Math.random()*lowprimes.length)]);
+ var y = a.modPow(r,this);
+ if(y.compareTo(BigInteger.ONE) != 0 && y.compareTo(n1) != 0) {
+ var j = 1;
+ while(j++ < k && y.compareTo(n1) != 0) {
+ y = y.modPowInt(2,this);
+ if(y.compareTo(BigInteger.ONE) == 0) return false;
+ }
+ if(y.compareTo(n1) != 0) return false;
+ }
+ }
+ return true;
+}
+
+// protected
+BigInteger.prototype.chunkSize = bnpChunkSize;
+BigInteger.prototype.toRadix = bnpToRadix;
+BigInteger.prototype.fromRadix = bnpFromRadix;
+BigInteger.prototype.fromNumber = bnpFromNumber;
+BigInteger.prototype.bitwiseTo = bnpBitwiseTo;
+BigInteger.prototype.changeBit = bnpChangeBit;
+BigInteger.prototype.addTo = bnpAddTo;
+BigInteger.prototype.dMultiply = bnpDMultiply;
+BigInteger.prototype.dAddOffset = bnpDAddOffset;
+BigInteger.prototype.multiplyLowerTo = bnpMultiplyLowerTo;
+BigInteger.prototype.multiplyUpperTo = bnpMultiplyUpperTo;
+BigInteger.prototype.modInt = bnpModInt;
+BigInteger.prototype.millerRabin = bnpMillerRabin;
+
+// public
+BigInteger.prototype.clone = bnClone;
+BigInteger.prototype.intValue = bnIntValue;
+BigInteger.prototype.byteValue = bnByteValue;
+BigInteger.prototype.shortValue = bnShortValue;
+BigInteger.prototype.signum = bnSigNum;
+BigInteger.prototype.toByteArray = bnToByteArray;
+BigInteger.prototype.equals = bnEquals;
+BigInteger.prototype.min = bnMin;
+BigInteger.prototype.max = bnMax;
+BigInteger.prototype.and = bnAnd;
+BigInteger.prototype.or = bnOr;
+BigInteger.prototype.xor = bnXor;
+BigInteger.prototype.andNot = bnAndNot;
+BigInteger.prototype.not = bnNot;
+BigInteger.prototype.shiftLeft = bnShiftLeft;
+BigInteger.prototype.shiftRight = bnShiftRight;
+BigInteger.prototype.getLowestSetBit = bnGetLowestSetBit;
+BigInteger.prototype.bitCount = bnBitCount;
+BigInteger.prototype.testBit = bnTestBit;
+BigInteger.prototype.setBit = bnSetBit;
+BigInteger.prototype.clearBit = bnClearBit;
+BigInteger.prototype.flipBit = bnFlipBit;
+BigInteger.prototype.add = bnAdd;
+BigInteger.prototype.subtract = bnSubtract;
+BigInteger.prototype.multiply = bnMultiply;
+BigInteger.prototype.divide = bnDivide;
+BigInteger.prototype.remainder = bnRemainder;
+BigInteger.prototype.divideAndRemainder = bnDivideAndRemainder;
+BigInteger.prototype.modPow = bnModPow;
+BigInteger.prototype.modInverse = bnModInverse;
+BigInteger.prototype.pow = bnPow;
+BigInteger.prototype.gcd = bnGCD;
+BigInteger.prototype.isProbablePrime = bnIsProbablePrime;
+
+// JSBN-specific extension
+BigInteger.prototype.square = bnSquare;
+
+// BigInteger interfaces not implemented in jsbn:
+
+// BigInteger(int signum, byte[] magnitude)
+// double doubleValue()
+// float floatValue()
+// int hashCode()
+// long longValue()
+// static BigInteger valueOf(long val)
diff --git a/jslib/prng4.js b/jslib/prng4.js
new file mode 100644
index 0000000..43c4b49
--- /dev/null
+++ b/jslib/prng4.js
@@ -0,0 +1,49 @@
+// prng4.js - uses Arcfour as a PRNG
+
+function Arcfour() {
+ this.i = 0;
+ this.j = 0;
+ this.S = new Array();
+}
+
+// Initialize arcfour context from key, an array of ints, each from [0..255]
+function ARC4init(key) {
+ var i, j, t;
+ for(i = 0; i < 256; ++i)
+ this.S[i] = i;
+ j = 0;
+ for(i = 0; i < 256; ++i) {
+ j = (j + this.S[i] + key[i % key.length]) & 255;
+ t = this.S[i];
+ this.S[i] = this.S[j];
+ this.S[j] = t;
+ }
+ this.i = 0;
+ this.j = 0;
+}
+
+function ARC4next() {
+ var t;
+ this.i = (this.i + 1) & 255;
+ this.j = (this.j + this.S[this.i]) & 255;
+ t = this.S[this.i];
+ this.S[this.i] = this.S[this.j];
+ this.S[this.j] = t;
+ return this.S[(t + this.S[this.i]) & 255];
+}
+
+Arcfour.prototype.init = ARC4init;
+Arcfour.prototype.next = ARC4next;
+
+// Plug in your RNG constructor here
+function prng_newstate() {
+ return new Arcfour();
+}
+
+// Pool size must be a multiple of 4 and greater than 32.
+// An array of bytes the size of the pool will be passed to init()
+var rng_psize = 256;
+
+module.exports.Arcfour = Arcfour;
+module.exports.rng_psize = rng_psize;
+module.exports.prng_newstate = prng_newstate;
diff --git a/jslib/public.js b/jslib/public.js
new file mode 100644
index 0000000..df6a443
--- /dev/null
+++ b/jslib/public.js
@@ -0,0 +1,282 @@
+/* eslint-disable */
+
+const {restCalls} = require("../src/utils/DefaultRestCalls");
+const parser = require('xml2json');
+const CryptoJS = require('crypto-js');
+const {RSAKey} = require('./rsa');
+
+
+var C = CryptoJS;
+var C_lib = C.lib;
+var WordArray = C_lib.WordArray;
+var C_algo = C.algo;
+
+var SHA2 = C_algo.SHA256;
+var HmacSHA2 = C.HmacSHA256;
+var Base = C_lib.Base;
+
+var SCRAM = C_algo.SCRAM = Base.extend({
+ cfg: Base.extend({
+ keySize: 8,
+ hasher: SHA2,
+ hmac: HmacSHA2
+ }),
+
+ init: function (cfg) {
+ this.cfg = this.cfg.extend(cfg);
+ },
+ /**
+ * return client nonce
+ */
+ nonce: function () {
+ lastNonce = WordArray.random(this.cfg.keySize * 4);
+ return lastNonce;
+ },
+ /**
+ * pbkdf2
+ */
+ saltedPassword: function (password, salt, iterations) {
+ return CryptoJS.PBKDF2(password, salt, {
+ keySize: this.cfg.keySize,
+ iterations: iterations,
+ hasher: this.cfg.hasher
+ });
+ },
+ /**
+ * ClientKey = HMAC(saltPwd, "Client Key")
+ */
+ clientKey: function (saltPwd) {
+ return this.cfg.hmac(saltPwd, "Client Key");
+ },
+ /**
+ * ServerKey = HMAC(saltPwd, "Server Key")
+ */
+ serverKey: function (saltPwd) {
+ return this.cfg.hmac(saltPwd, "Server Key");
+ },
+ /**
+ * StoredKey = HASH(ClientKey)
+ */
+ storedKey: function (clientKey) {
+ var hasher = this.cfg.hasher.create();
+ hasher.update(clientKey);
+
+ return hasher.finalize();
+ },
+ /**
+ * Signature = HMAC(StoredKey, AuthMessage)
+ */
+ signature: function (storedKey, authMessage) {
+ return this.cfg.hmac(storedKey, authMessage);
+ },
+ /**
+ * ClientProof = ClientKey ^ ClientSignature
+ */
+ clientProof: function (password, salt, iterations, authMessage) {
+ var spwd = this.saltedPassword(password, salt, iterations);
+ var ckey = this.clientKey(spwd);
+ var skey = this.storedKey(ckey);
+ var csig = this.signature(skey, authMessage);
+
+ for (var i = 0; i < ckey.sigBytes / 4; i += 1) {
+ ckey.words[i] = ckey.words[i] ^ csig.words[i]
+ }
+ return ckey.toString();
+ },
+ /**
+ * ServerProof = HMAC(ServerKey, AuthMessage)
+ */
+ serverProof: function (password, salt, iterations, authMessage) {
+ var spwd = this.saltedPassword(password, salt, iterations);
+ var skey = this.serverKey(spwd);
+ var sig = this.signature(skey, authMessage);
+ return sig.toString();
+ }
+});
+
+/**
+ * var scram = CryptoJS.SCRAM();
+ */
+C.SCRAM = function (cfg) {
+ return SCRAM.create(cfg);
+};
+
+
+async function getPublicKey(session){
+ const resp = await restCalls.fetchData(`http://${session.url}/api/webserver/publickey`,'GET', {
+ 'cookie': `sessionId=${session.SesInfo}`,
+ __RequestVerificationToken: session.TokInfo
+ });
+ const message = JSON.parse(parser.toJson(resp));
+ return message.response;
+}
+
+function utf8Encode(string) {
+ var stringTemp = string.replace(/\r\n/g, '\n');
+ var utftext = '';
+ for (var n = 0; n < stringTemp.length; n++) {
+ var charStr = stringTemp.charCodeAt(n);
+ if (charStr < 128) {
+ utftext += String.fromCharCode(charStr);
+ } else if ((charStr > 127) && (charStr < 2048)) {
+ utftext += String.fromCharCode((charStr >> 6) | 192);
+ utftext += String.fromCharCode((charStr & 63) | 128);
+ } else {
+ utftext += String.fromCharCode((charStr >> 12) | 224);
+ utftext += String.fromCharCode(((charStr >> 6) & 63) | 128);
+ utftext += String.fromCharCode((charStr & 63) | 128);
+ }
+ }
+ return utftext;
+}
+
+function base64encode(str) {
+ var keyStr = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+ var outputStr = '';
+ var char1;
+ var char2;
+ var char3;
+ var encry1;
+ var encry2;
+ var encry3;
+ var encry4;
+ var i = 0;
+ var input = utf8Encode(str);
+ while (i < input.length) {
+ char1 = input.charCodeAt(i++);
+ char2 = input.charCodeAt(i++);
+ char3 = input.charCodeAt(i++);
+ encry1 = char1 >> 2;
+ encry2 = ((char1 & 3) << 4) | (char2 >> 4);
+ encry3 = ((char2 & 15) << 2) | (char3 >> 6);
+ encry4 = char3 & 63;
+ if (isNaN(char2)) {
+ encry3 = encry4 = 64;
+ } else if (isNaN(char3)) {
+ encry4 = 64;
+ }
+ outputStr += keyStr.charAt(encry1) + keyStr.charAt(encry2) + keyStr.charAt(encry3) + keyStr.charAt(encry4);
+ }
+ return outputStr;
+}
+
+async function doRSAEncrypt(session,encstring) {
+ if (encstring === '') {
+ return '';
+ }
+ let res;
+ const gEncPublickey = { e: '', n: '' };
+ const pubkeyKeyInfo = await getPublicKey(session);
+ // eslint-disable-next-line prefer-destructuring
+ gEncPublickey.n = pubkeyKeyInfo.encpubkeyn;
+ // eslint-disable-next-line prefer-destructuring
+ gEncPublickey.e = pubkeyKeyInfo.encpubkeye;
+ var rsa = new RSAKey();
+ rsa.setPublic(gEncPublickey.n, gEncPublickey.e);
+ var encStr = base64encode(encstring);
+ var num = encStr.length / 245;
+ // if (EMUI.LoginStateController.rsapadingtype === '1') {
+ num = encStr.length / 214;
+ // }
+ var restotal = '';
+ var rsan = gEncPublickey.n;
+ for (var i = 0; i < num; i++) {
+ // if (EMUI.LoginStateController.rsapadingtype === '1') {
+ var encdata = encStr.substr(i * 214, 214);
+ res = rsa.encryptOAEP(encdata);
+ // } else {
+ // var encdata = encStr.substr(i * 245, 245);
+ // res = rsa.encrypt(encdata);
+ // }
+ if (res.length !== rsan.length) {
+ i--;
+ continue;
+ }
+ restotal += res;
+ }
+ return restotal;
+}
+
+const scram = CryptoJS.SCRAM();
+const smsNonce = scram.nonce().toString();
+const smsSalt = scram.nonce().toString();
+const nonceStr = smsNonce + smsSalt;
+
+
+function getDAesString(encrypted, keystr, ivstr) {
+ var key = CryptoJS.enc.Hex.parse(keystr);
+ var iv = CryptoJS.enc.Hex.parse(ivstr);
+ var decrypted = CryptoJS.AES.decrypt(encrypted, key, {
+ iv: iv,
+ mode: CryptoJS.mode.CBC,
+ padding: CryptoJS.pad.Pkcs7
+ });
+ return decrypted.toString(CryptoJS.enc.Latin1);
+}
+
+function utf8to16(str) {
+ var output, i, leng, unic;
+ var char1, char2;
+ output = "";
+ leng = str.length;
+ i = 0;
+ while (i < leng) {
+ unic = str.charCodeAt(i++);
+ switch (unic >> 4) {
+ case 0:
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ case 6:
+ case 7:
+ output += str.charAt(i - 1);
+ break;
+ case 12:
+ case 13:
+ char1 = str.charCodeAt(i++);
+ output += String.fromCharCode(((unic & 0x1F) << 6) | (char1 & 0x3F));
+ break;
+ case 14:
+ char1 = str.charCodeAt(i++);
+ char2 = str.charCodeAt(i++);
+ output += String.fromCharCode(((unic & 0x0F) << 12) |
+ ((char1 & 0x3F) << 6) |
+ ((char2 & 0x3F) << 0));
+ break;
+ }
+ }
+ return output;
+}
+
+function dataDecrypt(scram,smsNonce,smsSalt,nonceStr,pwdret) {
+ if (!pwdret.response
+ || !pwdret.response.pwd
+ || !pwdret.response.hash
+ || !pwdret.response.iter) {
+ return;
+ }
+ var smsEncrypted = pwdret.response.pwd;
+ var salt = CryptoJS.enc.Hex.parse(smsSalt);
+ var iter = pwdret.response.iter;
+ var saltedStr = scram.saltedPassword(smsNonce, salt, iter);
+ saltedStr = saltedStr.toString();
+ var aesKey = saltedStr.substring(0, 32);
+ var aesIV = saltedStr.substring(32, 48);
+ var hmacKey = saltedStr.substring(48, 64);
+ var hashData = scram.signature(CryptoJS.enc.Hex.parse(smsEncrypted), CryptoJS.enc.Hex.parse(hmacKey));
+ hashData = hashData.toString();
+ if (pwdret.response.hash !== hashData) {
+ throw new Error('UserPwd hash error');
+ }
+ var encrypted = CryptoJS.enc.Base64.stringify(CryptoJS.enc.Hex.parse(smsEncrypted));
+ var decryptedData = getDAesString(encrypted, aesKey, aesIV);
+ decryptedData = utf8to16(decryptedData);
+ decryptedData = decryptedData.substring(decryptedData.indexOf(''));
+ return decryptedData ;
+}
+
+module.exports.dataDecrypt = dataDecrypt;
+module.exports.CryptoJS = CryptoJS;
+module.exports.doRSAEncrypt = doRSAEncrypt;
diff --git a/jslib/rng.js b/jslib/rng.js
new file mode 100644
index 0000000..0be00cb
--- /dev/null
+++ b/jslib/rng.js
@@ -0,0 +1,79 @@
+// Random number generator - requires a PRNG backend, e.g. prng4.js
+
+// For best results, put code like
+//
+// in your main HTML document.
+
+var getRandomValues = require('get-random-values');
+const prng4 = require('./prng4.js');
+var rng_state;
+var rng_pool;
+var rng_pptr;
+
+// Mix in a 32-bit integer into the pool
+function rng_seed_int(x) {
+ rng_pool[rng_pptr++] ^= x & 255;
+ rng_pool[rng_pptr++] ^= (x >> 8) & 255;
+ rng_pool[rng_pptr++] ^= (x >> 16) & 255;
+ rng_pool[rng_pptr++] ^= (x >> 24) & 255;
+ if(rng_pptr >= prng4.rng_psize) rng_pptr -= prng4.rng_psize;
+}
+
+// Mix in the current time (w/milliseconds) into the pool
+function rng_seed_time() {
+ rng_seed_int(new Date().getTime());
+}
+
+// Initialize the pool with junk if needed.
+if(rng_pool == null) {
+ rng_pool = new Array();
+ rng_pptr = 0;
+ var t;
+
+ // Use webcrypto if available
+ var ua = new Uint8Array(32);
+ getRandomValues(ua);
+ for(t = 0; t < 32; ++t)
+ rng_pool[rng_pptr++] = ua[t];
+
+ // if(navigator.appName == "Netscape" && navigator.appVersion < "5" && window.crypto) {
+ // // Extract entropy (256 bits) from NS4 RNG if available
+ // var z = window.crypto.random(32);
+ // for(t = 0; t < z.length; ++t)
+ // rng_pool[rng_pptr++] = z.charCodeAt(t) & 255;
+ // }
+ while(rng_pptr < prng4.rng_psize) { // extract some randomness from Math.random()
+ t = Math.floor(65536 * Math.random());
+ rng_pool[rng_pptr++] = t >>> 8;
+ rng_pool[rng_pptr++] = t & 255;
+ }
+ rng_pptr = 0;
+ rng_seed_time();
+ //rng_seed_int(window.screenX);
+ //rng_seed_int(window.screenY);
+}
+
+function rng_get_byte() {
+ if(rng_state == null) {
+ rng_seed_time();
+ rng_state = prng4.prng_newstate();
+ rng_state.init(rng_pool);
+ for(rng_pptr = 0; rng_pptr < rng_pool.length; ++rng_pptr)
+ rng_pool[rng_pptr] = 0;
+ rng_pptr = 0;
+ //rng_pool = null;
+ }
+ // TODO: allow reseeding after first request
+ return rng_state.next();
+}
+
+function rng_get_bytes(ba) {
+ var i;
+ for(i = 0; i < ba.length; ++i) ba[i] = rng_get_byte();
+}
+
+function SecureRandom() {}
+
+SecureRandom.prototype.nextBytes = rng_get_bytes;
+
+module.exports.SecureRandom = SecureRandom;
diff --git a/jslib/rsa.js b/jslib/rsa.js
new file mode 100644
index 0000000..b5c2198
--- /dev/null
+++ b/jslib/rsa.js
@@ -0,0 +1,228 @@
+// Depends on jsbn.js and rng.js
+
+// Version 1.1: support utf-8 encoding in pkcs1pad2
+
+// convert a (hex) string to a bignum object
+
+const { BigInteger } = require('./jsbn');
+const { SecureRandom } = require('./rng');
+const {KJUR} = require('./crypto-1.1.js');
+
+function parseBigInt(str, r) {
+ return new BigInteger(str, r);
+}
+
+function linebrk(s, n) {
+ let ret = '';
+ let i = 0;
+ while (i + n < s.length) {
+ ret += `${s.substring(i, i + n)}\n`;
+ i += n;
+ }
+ return ret + s.substring(i, s.length);
+}
+
+function byte2Hex(b) {
+ if (b < 0x10) return `0${b.toString(16)}`;
+ return b.toString(16);
+}
+
+/**
+ * convert a raw string including non printable characters to hexadecimal encoded string.
+ * @name rstrtohex
+ * @function
+ * @param {String} s raw string
+ * @return {String} hexadecimal encoded string
+ * @since 1.1.2
+ * @example
+ * rstrtohex("a\x00a") → "610061"
+ */
+function rstrtohex(s) {
+ var result = "";
+ for (var i = 0; i < s.length; i++) {
+ result += ("0" + s.charCodeAt(i).toString(16)).slice(-2);
+ }
+ return result;
+}
+
+function hextorstr(sHex) {
+ var s = "";
+ for (var i = 0; i < sHex.length - 1; i += 2) {
+ s += String.fromCharCode(parseInt(sHex.substr(i, 2), 16));
+ }
+ return s;
+}
+
+// PKCS#1 (type 2, random) pad input string s to n bytes, and return a bigint
+function pkcs1pad2(s, n) {
+ if (n < s.length + 11) { // TODO: fix for utf-8
+ alert('Message too long for RSA');
+ return null;
+ }
+ const ba = new Array();
+ let i = s.length - 1;
+ while (i >= 0 && n > 0) {
+ const c = s.charCodeAt(i--);
+ if (c < 128) { // encode using utf-8
+ ba[--n] = c;
+ } else if ((c > 127) && (c < 2048)) {
+ ba[--n] = (c & 63) | 128;
+ ba[--n] = (c >> 6) | 192;
+ } else {
+ ba[--n] = (c & 63) | 128;
+ ba[--n] = ((c >> 6) & 63) | 128;
+ ba[--n] = (c >> 12) | 224;
+ }
+ }
+ ba[--n] = 0;
+ const rng = new SecureRandom();
+ const x = new Array();
+ while (n > 2) { // random non-zero pad
+ x[0] = 0;
+ while (x[0] == 0) rng.nextBytes(x);
+ ba[--n] = x[0];
+ }
+ ba[--n] = 2;
+ ba[--n] = 0;
+ return new BigInteger(ba);
+}
+
+
+// PKCS#1 (OAEP) mask generation function
+function oaep_mgf1_arr(seed, len, hash) {
+ var mask = '', i = 0;
+
+ while (mask.length < len) {
+ mask += hash(String.fromCharCode.apply(String, seed.concat([
+ (i & 0xff000000) >> 24,
+ (i & 0x00ff0000) >> 16,
+ (i & 0x0000ff00) >> 8,
+ i & 0x000000ff])));
+ i += 1;
+ }
+
+ return mask;
+}
+
+/**
+ * PKCS#1 (OAEP) pad input string s to n bytes, and return a bigint
+ * @name oaep_pad
+ * @param s raw string of message
+ * @param n key length of RSA key
+ * @param hash JavaScript function to calculate raw hash value from raw string or algorithm name (ex. "SHA1")
+ * @param hashLen byte length of resulted hash value (ex. 20 for SHA1)
+ * @return {BigInteger} BigInteger object of resulted PKCS#1 OAEP padded message
+ * @description
+ * This function calculates OAEP padded message from original message.
+ * NOTE: Since jsrsasign 6.2.0, 'hash' argument can accept an algorithm name such as "sha1".
+ * @example
+ * oaep_pad("aaa", 128) → big integer object // SHA-1 by default
+ * oaep_pad("aaa", 128, function(s) {...}, 20);
+ * oaep_pad("aaa", 128, "sha1");
+ */
+function oaep_pad(s, n, hash, hashLen) {
+ var MD = KJUR.crypto.MessageDigest;
+ var Util = KJUR.crypto.Util;
+ var algName = null;
+
+ if (!hash) hash = "sha1";
+
+ if (typeof hash === "string") {
+ algName = MD.getCanonicalAlgName(hash);
+ hashLen = MD.getHashLength(algName);
+ hash = function (s) {
+ return hextorstr(Util.hashHex(rstrtohex(s), algName));
+ };
+ }
+
+ if (s.length + 2 * hashLen + 2 > n) {
+ throw "Message too long for RSA";
+ }
+
+ var PS = '', i;
+
+ for (i = 0; i < n - s.length - 2 * hashLen - 2; i += 1) {
+ PS += '\x00';
+ }
+
+ var DB = hash('') + PS + '\x01' + s;
+ var seed = new Array(hashLen);
+ new SecureRandom().nextBytes(seed);
+
+ var dbMask = oaep_mgf1_arr(seed, DB.length, hash);
+ var maskedDB = [];
+
+ for (i = 0; i < DB.length; i += 1) {
+ maskedDB[i] = DB.charCodeAt(i) ^ dbMask.charCodeAt(i);
+ }
+
+ var seedMask = oaep_mgf1_arr(maskedDB, seed.length, hash);
+ var maskedSeed = [0];
+
+ for (i = 0; i < seed.length; i += 1) {
+ maskedSeed[i + 1] = seed[i] ^ seedMask.charCodeAt(i);
+ }
+
+ return new BigInteger(maskedSeed.concat(maskedDB));
+}
+
+// "empty" RSA key constructor
+function RSAKey() {
+ this.n = null;
+ this.e = 0;
+ this.d = null;
+ this.p = null;
+ this.q = null;
+ this.dmp1 = null;
+ this.dmq1 = null;
+ this.coeff = null;
+}
+
+// Set the public key fields N and e from hex strings
+function RSASetPublic(N, E) {
+ if (N != null && E != null && N.length > 0 && E.length > 0) {
+ this.n = parseBigInt(N, 16);
+ this.e = parseInt(E, 16);
+ } else alert('Invalid RSA public key');
+}
+
+// Perform raw public operation on "x": return x^e (mod n)
+function RSADoPublic(x) {
+ return x.modPowInt(this.e, this.n);
+}
+
+// Return the PKCS#1 RSA encryption of "text" as an even-length hex string
+function RSAEncrypt(text) {
+ const m = pkcs1pad2(text, (this.n.bitLength() + 7) >> 3);
+ if (m == null) return null;
+ const c = this.doPublic(m);
+ if (c == null) return null;
+ const h = c.toString(16);
+ if ((h.length & 1) == 0) return h; return `0${h}`;
+}
+
+function RSAEncryptOAEP(text, hash, hashLen) {
+ var m = oaep_pad(text, (this.n.bitLength() + 7) >> 3, hash, hashLen);
+ if (m == null) return null;
+ var c = this.doPublic(m);
+ if (c == null) return null;
+ var h = c.toString(16);
+ if ((h.length & 1) == 0) return h; else return "0" + h;
+}
+
+// Return the PKCS#1 RSA encryption of "text" as a Base64-encoded string
+// function RSAEncryptB64(text) {
+// var h = this.encrypt(text);
+// if(h) return hex2b64(h); else return null;
+// }
+
+// protected
+RSAKey.prototype.doPublic = RSADoPublic;
+
+// public
+RSAKey.prototype.setPublic = RSASetPublic;
+RSAKey.prototype.encrypt = RSAEncrypt;
+RSAKey.prototype.encryptOAEP = RSAEncryptOAEP;
+// RSAKey.prototype.encrypt_b64 = RSAEncryptB64;
+
+module.exports.RSAKey = RSAKey;
diff --git a/jslib/rsa2.js b/jslib/rsa2.js
new file mode 100644
index 0000000..1dfdb70
--- /dev/null
+++ b/jslib/rsa2.js
@@ -0,0 +1,132 @@
+// Depends on rsa.js and jsbn2.js
+
+// Version 1.1: support utf-8 decoding in pkcs1unpad2
+
+// Undo PKCS#1 (type 2, random) padding and, if valid, return the plaintext
+function pkcs1unpad2(d,n) {
+ var b = d.toByteArray();
+ var i = 0;
+ while(i < b.length && b[i] == 0) ++i;
+ if(b.length-i != n-1 || b[i] != 2)
+ return null;
+ ++i;
+ while(b[i] != 0)
+ if(++i >= b.length) return null;
+ var ret = "";
+ while(++i < b.length) {
+ var c = b[i] & 255;
+ if(c < 128) { // utf-8 decode
+ ret += String.fromCharCode(c);
+ }
+ else if((c > 191) && (c < 224)) {
+ ret += String.fromCharCode(((c & 31) << 6) | (b[i+1] & 63));
+ ++i;
+ }
+ else {
+ ret += String.fromCharCode(((c & 15) << 12) | ((b[i+1] & 63) << 6) | (b[i+2] & 63));
+ i += 2;
+ }
+ }
+ return ret;
+}
+
+// Set the private key fields N, e, and d from hex strings
+function RSASetPrivate(N,E,D) {
+ if(N != null && E != null && N.length > 0 && E.length > 0) {
+ this.n = parseBigInt(N,16);
+ this.e = parseInt(E,16);
+ this.d = parseBigInt(D,16);
+ }
+ else
+ alert("Invalid RSA private key");
+}
+
+// Set the private key fields N, e, d and CRT params from hex strings
+function RSASetPrivateEx(N,E,D,P,Q,DP,DQ,C) {
+ if(N != null && E != null && N.length > 0 && E.length > 0) {
+ this.n = parseBigInt(N,16);
+ this.e = parseInt(E,16);
+ this.d = parseBigInt(D,16);
+ this.p = parseBigInt(P,16);
+ this.q = parseBigInt(Q,16);
+ this.dmp1 = parseBigInt(DP,16);
+ this.dmq1 = parseBigInt(DQ,16);
+ this.coeff = parseBigInt(C,16);
+ }
+ else
+ alert("Invalid RSA private key");
+}
+
+// Generate a new random private key B bits long, using public expt E
+function RSAGenerate(B,E) {
+ var rng = new SecureRandom();
+ var qs = B>>1;
+ this.e = parseInt(E,16);
+ var ee = new BigInteger(E,16);
+ for(;;) {
+ for(;;) {
+ this.p = new BigInteger(B-qs,1,rng);
+ if(this.p.subtract(BigInteger.ONE).gcd(ee).compareTo(BigInteger.ONE) == 0 && this.p.isProbablePrime(10)) break;
+ }
+ for(;;) {
+ this.q = new BigInteger(qs,1,rng);
+ if(this.q.subtract(BigInteger.ONE).gcd(ee).compareTo(BigInteger.ONE) == 0 && this.q.isProbablePrime(10)) break;
+ }
+ if(this.p.compareTo(this.q) <= 0) {
+ var t = this.p;
+ this.p = this.q;
+ this.q = t;
+ }
+ var p1 = this.p.subtract(BigInteger.ONE);
+ var q1 = this.q.subtract(BigInteger.ONE);
+ var phi = p1.multiply(q1);
+ if(phi.gcd(ee).compareTo(BigInteger.ONE) == 0) {
+ this.n = this.p.multiply(this.q);
+ this.d = ee.modInverse(phi);
+ this.dmp1 = this.d.mod(p1);
+ this.dmq1 = this.d.mod(q1);
+ this.coeff = this.q.modInverse(this.p);
+ break;
+ }
+ }
+}
+
+// Perform raw private operation on "x": return x^d (mod n)
+function RSADoPrivate(x) {
+ if(this.p == null || this.q == null)
+ return x.modPow(this.d, this.n);
+
+ // TODO: re-calculate any missing CRT params
+ var xp = x.mod(this.p).modPow(this.dmp1, this.p);
+ var xq = x.mod(this.q).modPow(this.dmq1, this.q);
+
+ while(xp.compareTo(xq) < 0)
+ xp = xp.add(this.p);
+ return xp.subtract(xq).multiply(this.coeff).mod(this.p).multiply(this.q).add(xq);
+}
+
+// Return the PKCS#1 RSA decryption of "ctext".
+// "ctext" is an even-length hex string and the output is a plain string.
+function RSADecrypt(ctext) {
+ var c = parseBigInt(ctext, 16);
+ var m = this.doPrivate(c);
+ if(m == null) return null;
+ return pkcs1unpad2(m, (this.n.bitLength()+7)>>3);
+}
+
+// Return the PKCS#1 RSA decryption of "ctext".
+// "ctext" is a Base64-encoded string and the output is a plain string.
+//function RSAB64Decrypt(ctext) {
+// var h = b64tohex(ctext);
+// if(h) return this.decrypt(h); else return null;
+//}
+
+// protected
+RSAKey.prototype.doPrivate = RSADoPrivate;
+
+// public
+RSAKey.prototype.setPrivate = RSASetPrivate;
+RSAKey.prototype.setPrivateEx = RSASetPrivateEx;
+RSAKey.prototype.generate = RSAGenerate;
+RSAKey.prototype.decrypt = RSADecrypt;
+//RSAKey.prototype.b64_decrypt = RSAB64Decrypt;
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..681ea23
--- /dev/null
+++ b/package.json
@@ -0,0 +1,57 @@
+{
+ "name": "e3372h-320-cli",
+ "version": "1.0.0",
+ "description": "e3372h-320 client",
+ "main": "index.js",
+ "scripts": {
+ "sendSMS": "node index.js sendSMS --phone=+11111111111 --message=test123 --url=192.168.89.1 ",
+ "contacts": "node index.js contacts --url=192.168.89.1",
+ "getContactsCount": "node index.js contactPages --url=192.168.89.1 --exportFormat=json",
+ "sms": "node index.js sms --phone=+11111111111 --url=192.168.89.1 --page=1",
+ "pages": "node index.js pages --phone=+11111111111 --url=192.168.89.1 --exportFormat=json",
+ "enableData": "node index.js mobileData --mode=on --url=192.168.89.1",
+ "disableData": "node index.js mobileData --mode=off --url=192.168.89.1",
+ "reconnected": "node index.js mobileData --mode=reconnect --url=192.168.89.1",
+ "monitoring": "node index.js monitoring --url=192.168.89.1",
+ "lint": "eslint src --ext .ts src",
+ "build": "tsc --build",
+ "lint:fix": "eslint --fix src --ext .ts"
+ },
+ "bin": {
+ "e3372h_320": "./bin/e3372h_320"
+ },
+ "dependencies": {
+ "axios": "^0.24.0",
+ "crypto-js": "^4.1.1",
+ "get-random-values": "^1.2.2",
+ "xml2json": "^0.12.0",
+ "yargs": "^17.2.1"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/vzakharchenko/E3372h-320-cli.git"
+ },
+ "keywords": [
+ "huawei",
+ "e3372h-320",
+ "client",
+ "rest-api",
+ "publicKey"
+ ],
+ "devDependencies": {
+ "@shopify/eslint-plugin": "^40.4.0",
+ "@types/xml2json": "^0.11.4",
+ "@types/yargs": "^17.0.4",
+ "@typescript-eslint/parser": "^5.2.0",
+ "eslint": "7.3.0",
+ "eslint-plugin-no-loops": "^0.3.0",
+ "parcel-bundler": "^1.12.5",
+ "typescript": "^4.4.4"
+ },
+ "author": "vzakharchenko",
+ "license": "Apache-2.0",
+ "bugs": {
+ "url": "https://github.com/vzakharchenko/E3372h-320-cli/issues"
+ },
+ "homepage": "https://github.com/vzakharchenko/E3372h-320-cli#readme"
+}
diff --git a/src/ListSMS.ts b/src/ListSMS.ts
new file mode 100644
index 0000000..94e06e4
--- /dev/null
+++ b/src/ListSMS.ts
@@ -0,0 +1,206 @@
+import fs from "fs";
+
+import parser from 'xml2json';
+
+import {SessionData} from './startSession';
+import {restCalls} from "./utils/DefaultRestCalls";
+import {ExportFormat} from "./utils/Constants";
+
+const huawei = require('../jslib/public');
+
+async function saveFile(filename: string, data: string) {
+ await fs.promises.writeFile(filename, data);
+}
+
+export async function getSMSByUsers(sessionData: SessionData,
+ phone: string,
+ pageindex: number,
+ exportFile: string,
+ exportFormat: ExportFormat,
+ deleteAfter: boolean) {
+ // const count = await getContactSMSPages(sessionData, phone, '', 'hide');
+ // if (count === 0) {
+ // console.log(`contact ${phone} does not have messages`);
+ // return;
+ // }
+ const scram = huawei.CryptoJS.SCRAM();
+ const smsNonce = scram.nonce().toString();
+ const smsSalt = scram.nonce().toString();
+ const nonceStr = smsNonce + smsSalt;
+ const encrpt = await huawei.doRSAEncrypt(sessionData, nonceStr);
+ const data = await huawei.doRSAEncrypt(sessionData, `${phone}${pageindex}20${encrpt}`);
+ const resp = await restCalls.sendData(`http://${sessionData.url}/api/sms/sms-list-phone`, 'POST', data, {
+ __RequestVerificationToken: sessionData.TokInfo,
+ 'content-type': 'application/x-www-form-urlencoded; charset=UTF-8;enc',
+ Cookie: `SessionId=${sessionData.SesInfo}`,
+ });
+ const pwdret = JSON.parse(parser.toJson(resp));
+ const ret = huawei.dataDecrypt(scram, smsNonce, smsSalt, nonceStr, pwdret);
+
+ if (exportFormat !== 'hide') {
+ if (exportFormat === 'xml') {
+ await saveFile(exportFile, ret);
+ console.info(`xml file ${exportFile} created`);
+ } else if (exportFormat === 'json') {
+ await saveFile(exportFile, parser.toJson(ret));
+ console.info(`json file ${exportFile} created`);
+ } else {
+ const text = parser.toJson(ret);
+ const json = JSON.parse(text);
+ if (Array.isArray(json.response.messages.message)) {
+ json.response.messages.message.forEach((message: any) => {
+ console.log(`MessageId: ${message.index} Phone: ${message.phone} Message: ${JSON.stringify(message.content)}`);
+ });
+ } else {
+ const message: any = json.response.messages.message;
+ console.log(`MessageId: ${message.index} Phone: ${message.phone} Message: ${JSON.stringify(message.content)}`);
+ }
+ }
+ }
+
+ if (deleteAfter) {
+ const text = parser.toJson(ret);
+ const json = JSON.parse(text);
+ const messages = json.response.messages.message;
+ for (let i = 0; i < messages.length; i++) {
+ await deleteMessage(sessionData, messages[i].index);
+ }
+ }
+}
+
+export async function getContactSMSPages(sessionData: SessionData,
+ phone: string,
+ exportFile: string,
+ exportFormat: ExportFormat) {
+ const data = await huawei.doRSAEncrypt(sessionData, `${phone}`);
+ const resp = await restCalls.sendData(`http://${sessionData.url}/api/sms/sms-count-contact`, 'POST', data, {
+ __RequestVerificationToken: sessionData.TokInfo,
+ 'content-type': 'application/x-www-form-urlencoded; charset=UTF-8;enc',
+ Cookie: `SessionId=${sessionData.SesInfo}`,
+ });
+
+ const text = parser.toJson(resp);
+ const json = JSON.parse(text);
+ let number = Math.floor(json.response.count / 21);
+ if (number > 0) {
+ number += 1;
+ }
+ if (exportFormat !== 'hide') {
+ if (exportFormat === 'xml') {
+ await saveFile(exportFile, resp);
+ console.info(`xml file ${exportFile} created`);
+ } else if (exportFormat === 'json') {
+ await saveFile(exportFile, parser.toJson(resp));
+ console.info(`json file ${exportFile} created`);
+ } else {
+ console.info(`${number}`);
+ }
+ }
+ return number;
+}
+
+export async function getSMSPages(sessionData: SessionData,
+ exportFile: string,
+ exportFormat: ExportFormat) {
+ const resp = await restCalls.fetchData(`http://${sessionData.url}/api/sms/sms-count`, 'GET');
+ const text = parser.toJson(resp);
+ const json = JSON.parse(text);
+ let number = Math.floor((json.response.LocalInbox + json.response.LocalOutbox) / 21);
+ if (number > 0) {
+ number += 1;
+ }
+ if (exportFormat !== 'hide') {
+ if (exportFormat === 'xml') {
+ await saveFile(exportFile, resp);
+ console.info(`xml file ${exportFile} created`);
+ } else if (exportFormat === 'json') {
+ await saveFile(exportFile, parser.toJson(resp));
+ console.info(`json file ${exportFile} created`);
+ } else {
+ console.info(`${number}`);
+ }
+ }
+ return number;
+}
+
+export async function deleteMessage(sessionData: SessionData,
+ messageId: string) {
+ const data = await huawei.doRSAEncrypt(sessionData, `${messageId}`);
+ const resp = await restCalls.sendData(`http://${sessionData.url}/api/sms/delete-sms`, 'POST', data, {
+ __RequestVerificationToken: sessionData.TokInfo,
+ 'content-type': 'application/x-www-form-urlencoded; charset=UTF-8;enc',
+ Cookie: `SessionId=${sessionData.SesInfo}`,
+ });
+ const text = parser.toJson(resp);
+ const json = JSON.parse(text);
+ if (json.response !== 'OK') {
+ throw new Error(`Delete message error: ${text}`);
+ }
+ console.info('Message or Contact deleted');
+}
+
+export async function sendMessage(sessionData: SessionData,
+ phones: string,
+ message: string) {
+ const scram = huawei.CryptoJS.SCRAM();
+ const smsNonce = scram.nonce().toString();
+ const smsSalt = scram.nonce().toString();
+ const nonceStr = smsNonce + smsSalt;
+ const encrpt = await huawei.doRSAEncrypt(sessionData, nonceStr);
+ const data = await huawei.doRSAEncrypt(sessionData, `-1${(phones)}${message}${message.length}12021-10-27 00:12:24${encrpt}`);
+ const resp = await restCalls.sendData(`http://${sessionData.url}/api/sms/send-sms`, 'POST', data, {
+ __RequestVerificationToken: sessionData.TokInfo,
+ 'content-type': 'application/x-www-form-urlencoded; charset=UTF-8;enc',
+ Cookie: `SessionId=${sessionData.SesInfo}`,
+ });
+ const text = parser.toJson(resp);
+ const json = JSON.parse(text);
+ if (json.response !== 'OK') {
+ throw new Error(`Delete message error: ${text}`);
+ }
+ console.info('Message sent');
+}
+
+
+export async function getSMSContacts(sessionData: SessionData,
+ pageindex: number,
+ exportFile: string,
+ exportFormat: ExportFormat) {
+ const count = await getSMSPages(sessionData, '', 'hide');
+ if (count === 0) {
+ console.log('huawei does not have contacts');
+ return;
+ }
+ const scram = huawei.CryptoJS.SCRAM();
+ const smsNonce = scram.nonce().toString();
+ const smsSalt = scram.nonce().toString();
+ const nonceStr = smsNonce + smsSalt;
+ const encrpt = await huawei.doRSAEncrypt(sessionData, nonceStr);
+ const data = await huawei.doRSAEncrypt(sessionData, `${pageindex}20${encrpt}`);
+ const resp = await restCalls.sendData(`http://${sessionData.url}/api/sms/sms-list-contact`, 'POST',
+ data, {
+ 'content-type': 'application/x-www-form-urlencoded; charset=UTF-8;enc',
+ __RequestVerificationToken: sessionData.TokInfo,
+ Cookie: `SessionId=${sessionData.SesInfo}`,
+ });
+ const pwdret = JSON.parse(parser.toJson(resp));
+ const ret = huawei.dataDecrypt(scram, smsNonce, smsSalt, nonceStr, pwdret);
+ if (exportFormat === 'xml') {
+ await saveFile(exportFile, ret);
+ console.info(`xml file ${exportFile} created`);
+ } else if (exportFormat === 'json') {
+ await saveFile(exportFile, parser.toJson(ret));
+ console.info(`json file ${exportFile} created`);
+ } else {
+ const text = parser.toJson(ret);
+ const json = JSON.parse(text);
+ if (Array.isArray(json.response.messages.message)) {
+ json.response.messages.message.forEach((message: any) => {
+ console.log(`MessageId: ${message.index} Phone: ${message.phone} lastMessage: ${JSON.stringify(message.content)}`);
+ });
+ } else {
+ const message: any = json.response.messages.message;
+ console.log(`(MessageId: ${message.index}) Phone: ${message.phone} lastMessage: ${message.content}`);
+ }
+ }
+}
diff --git a/src/MobileData.ts b/src/MobileData.ts
new file mode 100644
index 0000000..161ac57
--- /dev/null
+++ b/src/MobileData.ts
@@ -0,0 +1,66 @@
+import fs from "fs";
+
+import parser from "xml2json";
+
+import {SessionData} from "./startSession";
+import {restCalls} from "./utils/DefaultRestCalls";
+import {ExportFormat} from "./utils/Constants";
+
+
+type MobileStatus = 'on' | 'off';
+
+async function saveFile(filename: string, data: string) {
+ await fs.promises.writeFile(filename, data);
+}
+
+export async function controlMobileData(sessionData: SessionData, mobileStatus: MobileStatus) {
+ const data = `${mobileStatus === 'on' ? 1 : 0}`;
+ const resp = await restCalls.sendData(`http://${sessionData.url}/api/dialup/mobile-dataswitch`, 'POST', data, {
+ __RequestVerificationToken: sessionData.TokInfo,
+ Cookie: `SessionId=${sessionData.SesInfo}`,
+ });
+ const text = parser.toJson(resp);
+ const json = JSON.parse(text);
+ if (json.response !== 'OK') {
+ throw new Error(`Control Mobile Data error: ${text}`);
+ }
+ console.log(`Control Mobile Data changed to ${mobileStatus}`);
+}
+
+export async function reconnect(sessionData: SessionData) {
+ const data = `1`;
+ const resp = await restCalls.sendData(`http://${sessionData.url}/api/net/reconnect`, 'POST', data, {
+ __RequestVerificationToken: sessionData.TokInfo,
+ Cookie: `SessionId=${sessionData.SesInfo}`,
+ });
+ const text = parser.toJson(resp);
+ const json = JSON.parse(text);
+ if (json.response !== 'OK') {
+ throw new Error(`Reconnecting error: ${text}`);
+ }
+ console.log('Reconnected');
+}
+
+export async function status(sessionData: SessionData, exportFile: string,
+ exportFormat: ExportFormat) {
+ const resp = await restCalls.fetchData(`http://${sessionData.url}/api/monitoring/status`, 'GET', {
+ __RequestVerificationToken: sessionData.TokInfo,
+ Cookie: `SessionId=${sessionData.SesInfo}`,
+ });
+ if (exportFormat !== 'hide') {
+ if (exportFormat === 'xml') {
+ await saveFile(exportFile, resp);
+ console.info(`xml file ${exportFile} created`);
+ } else if (exportFormat === 'json') {
+ await saveFile(exportFile, parser.toJson(resp));
+ console.info(`json file ${exportFile} created`);
+ } else {
+ const text = parser.toJson(resp);
+ const json = JSON.parse(text);
+ const response = json.response;
+ Object.keys(response).forEach((key) => {
+ console.info(`${key}=${response[key]}`);
+ });
+ }
+ }
+}
diff --git a/src/startSession.ts b/src/startSession.ts
new file mode 100644
index 0000000..b5f90e1
--- /dev/null
+++ b/src/startSession.ts
@@ -0,0 +1,57 @@
+import parser from 'xml2json';
+
+import {restCalls} from "./utils/DefaultRestCalls";
+
+export type SessionData = {
+ TokInfo: string,
+ SesInfo: string,
+ url: string
+}
+
+type SessionData0 = {
+ TokInfo: string,
+ SesInfo: string
+}
+
+// async function saveFile(data: SessionData) {
+// await fs.promises.writeFile(os.tmpdir() + '/huawei.tmp', JSON.stringify(data));
+// }
+//
+// async function readFile(): Promise {
+// try {
+// return JSON.parse(await fs.promises.readFile(os.tmpdir() + '/huawei.tmp', 'utf-8'));
+// } catch (e) {
+// console.error("read session data error", e);
+// await fs.promises.rm(os.tmpdir() + '/huawei.tmp');
+// throw e;
+// }
+// }
+//
+async function getSessionId(url: string): Promise {
+ const resp = await restCalls.fetchData(`http://${url}/api/webserver/SesTokInfo`, 'GET');
+ const message = JSON.parse(parser.toJson(resp));
+ return message.response;
+}
+//
+// export async function getCurrentSession() {
+// try {
+// const session: SessionData = await readFile();
+// await startSession(session.url);
+// return await readFile();
+// } catch (e) {
+// console.error("Session file does not exist or not valid please start a new session", e);
+// throw new Error("Session Does not exist")
+// }
+//
+// }
+
+export async function startSession(url: string) {
+ const session0: SessionData0 = await getSessionId(url);
+ const sessionData: SessionData = {
+ ...session0,
+ url,
+ };
+ return sessionData;
+}
+
+
diff --git a/src/utils/Constants.ts b/src/utils/Constants.ts
new file mode 100644
index 0000000..fc371c5
--- /dev/null
+++ b/src/utils/Constants.ts
@@ -0,0 +1,2 @@
+
+export type ExportFormat = 'xml' | 'json' | 'none' | 'hide';
diff --git a/src/utils/DefaultRestCalls.ts b/src/utils/DefaultRestCalls.ts
new file mode 100644
index 0000000..1465324
--- /dev/null
+++ b/src/utils/DefaultRestCalls.ts
@@ -0,0 +1,33 @@
+import fetch from 'axios';
+
+import {HTTPMethod, RestCalls} from './restCalls';
+
+class DefaultRestCalls implements RestCalls {
+ async fetchData(url: string, method: HTTPMethod, headers?: any): Promise {
+ const ret = await fetch({
+ url,
+ method,
+ headers,
+ transformResponse: (req) => req,
+ withCredentials: true,
+ timeout: 29000,
+ });
+ return ret.data;
+ }
+
+ async sendData(url: string, method: HTTPMethod, data: string, headers?: any): Promise {
+ const ret = await fetch({
+ url,
+ method,
+ data,
+ transformResponse: (req) => req,
+ headers,
+ withCredentials: true,
+ timeout: 29000,
+ });
+ return ret.data;
+ }
+
+}
+
+export const restCalls = new DefaultRestCalls();
diff --git a/src/utils/restCalls.ts b/src/utils/restCalls.ts
new file mode 100644
index 0000000..57cef61
--- /dev/null
+++ b/src/utils/restCalls.ts
@@ -0,0 +1,16 @@
+export type HTTPMethod =
+ | 'get' | 'GET'
+ | 'delete' | 'DELETE'
+ | 'head' | 'HEAD'
+ | 'options' | 'OPTIONS'
+ | 'post' | 'POST'
+ | 'put' | 'PUT'
+ | 'patch' | 'PATCH'
+ | 'purge' | 'PURGE'
+ | 'link' | 'LINK'
+ | 'unlink' | 'UNLINK'
+
+export interface RestCalls {
+ fetchData(url:string, method?:HTTPMethod, headers?:any):Promise;
+ sendData(url:string, method:HTTPMethod, data:string, headers?:any):Promise;
+}
diff --git a/tsconfig.json b/tsconfig.json
new file mode 100644
index 0000000..86220c2
--- /dev/null
+++ b/tsconfig.json
@@ -0,0 +1,73 @@
+{
+ "compilerOptions": {
+ /* Visit https://aka.ms/tsconfig.json to read more about this file */
+ /* Basic Options */
+ // "incremental": true, /* Enable incremental compilation */
+ "target": "ES2015", /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', 'ES2021', or 'ESNEXT'. */
+ "module": "commonjs", /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
+ // "lib": [], /* Specify library files to be included in the compilation. */
+ // "allowJs": true, /* Allow javascript files to be compiled. */
+ // "checkJs": true, /* Report errors in .js files. */
+ // "jsx": "preserve", /* Specify JSX code generation: 'preserve', 'react-native', 'react', 'react-jsx' or 'react-jsxdev'. */
+ "declaration": false, /* Generates corresponding '.d.ts' file. */
+ "declarationMap": false, /* Generates a sourcemap for each corresponding '.d.ts' file. */
+ "sourceMap": true, /* Generates corresponding '.map' file. */
+ // "outFile": "./", /* Concatenate and emit output to single file. */
+ "outDir": "./", /* Redirect output structure to the directory. */
+ // "rootDir": "./", /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
+ // "composite": true, /* Enable project compilation */
+ // "tsBuildInfoFile": "./", /* Specify file to store incremental compilation information */
+ // "removeComments": true, /* Do not emit comments to output. */
+ // "noEmit": true, /* Do not emit outputs. */
+ // "importHelpers": true, /* Import emit helpers from 'tslib'. */
+ // "downlevelIteration": true, /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
+ // "isolatedModules": true, /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
+
+ /* Strict Type-Checking Options */
+ "strict": true, /* Enable all strict type-checking options. */
+ // "noImplicitAny": true, /* Raise error on expressions and declarations with an implied 'any' type. */
+ // "strictNullChecks": true, /* Enable strict null checks. */
+ // "strictFunctionTypes": true, /* Enable strict checking of function types. */
+ // "strictBindCallApply": true, /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
+ // "strictPropertyInitialization": true, /* Enable strict checking of property initialization in classes. */
+ // "noImplicitThis": true, /* Raise error on 'this' expressions with an implied 'any' type. */
+ // "alwaysStrict": true, /* Parse in strict mode and emit "use strict" for each source file. */
+
+ /* Additional Checks */
+ // "noUnusedLocals": true, /* Report errors on unused locals. */
+ // "noUnusedParameters": true, /* Report errors on unused parameters. */
+ // "noImplicitReturns": true, /* Report error when not all code paths in function return a value. */
+ // "noFallthroughCasesInSwitch": true, /* Report errors for fallthrough cases in switch statement. */
+ // "noUncheckedIndexedAccess": true, /* Include 'undefined' in index signature results */
+ // "noImplicitOverride": true, /* Ensure overriding members in derived classes are marked with an 'override' modifier. */
+ // "noPropertyAccessFromIndexSignature": true, /* Require undeclared properties from index signatures to use element accesses. */
+
+ /* Module Resolution Options */
+ // "moduleResolution": "node", /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
+ // "baseUrl": "./", /* Base directory to resolve non-absolute module names. */
+ // "paths": {}, /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
+ // "rootDirs": [], /* List of root folders whose combined content represents the structure of the project at runtime. */
+ // "typeRoots": [], /* List of folders to include type definitions from. */
+ "types": ["node"], /* Type declaration files to be included in compilation. */
+ // "allowSyntheticDefaultImports": true, /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
+ "esModuleInterop": true, /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
+ // "preserveSymlinks": true, /* Do not resolve the real path of symlinks. */
+ // "allowUmdGlobalAccess": true, /* Allow accessing UMD globals from modules. */
+
+ /* Source Map Options */
+ // "sourceRoot": "", /* Specify the location where debugger should locate TypeScript files instead of source locations. */
+ // "mapRoot": "", /* Specify the location where debugger should locate map files instead of generated locations. */
+ // "inlineSourceMap": true, /* Emit a single file with source maps instead of having a separate file. */
+ // "inlineSources": true, /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
+
+ /* Experimental Options */
+ // "experimentalDecorators": true, /* Enables experimental support for ES7 decorators. */
+ // "emitDecoratorMetadata": true, /* Enables experimental support for emitting type metadata for decorators. */
+
+ /* Advanced Options */
+ "skipLibCheck": true, /* Skip type checking of declaration files. */
+ "forceConsistentCasingInFileNames": true /* Disallow inconsistently-cased references to the same file. */
+ },
+ "exclude": [
+ ]
+}