PHP encryption is decrypted by JavaScript example

Source: Internet
Author: User
Tags 0xc0 base64 hash join md5 ord strlen

PHP Cryptographic functions

  code is as follows copy code
<?php
&NBSP
Function Strencode ($string) {
    $string = Base64_encode ($string);
     $key = MD5 (' Just a test ');
    $len = strlen ($key);
    $code = ';
    for ($i = 0; $i < strlen ($string); $i + +) {
        $k = $i% $len;
        $code. = $string [$i] ^ $key [$k];
   }
    return Base64_encode ($code);
}
 
Echo strencode (' Just a test ');
?>

JS: Decryption

The code is as follows Copy Code
&lt;script src= "Md5.js" &gt;&lt;/script&gt;


&lt;script src= "Base64.js" &gt;&lt;/script&gt;


&lt;script&gt;





function Strencode (string) {


Key =md5 (' Just a test ');


String = Base64.decode (string);


len = key.length;


Code = ';


for (i = 0; i &lt; string.length; i++) {


K = i% Len;


Code + + String.fromCharCode (string.charcodeat (i) ^ key.charcodeat (k));


}


return Base64.decode (code);


}


Alert (Strencode (' u1s1tfn3iq0retzbbgjlca==== '));


&lt;/script&gt;


JS MD5:

The code is as follows Copy Code
/*


* Configurable variables. You could need to tweak are compatible with


* The Server-side, but the defaults work in most cases.


*/


var hexcase = 0; /* Hex output format. 0-lowercase; 1-uppercase *


var b64pad = ""; /* base-64 pad character. "=" for strict RFC compliance * *





/*


* These are the functions and you'll usually want to call


* They take string arguments and return either hex or BASE-64 encoded


*/


function MD5 (s) {


Return Rstr2hex (RSTR_MD5 (Str2rstr_utf8 (s)));


}


function B64_md5 (s) {


Return rstr2b64 (RSTR_MD5 (Str2rstr_utf8 (s)));


}


function Any_md5 (s, e) {


Return Rstr2any (RSTR_MD5 (Str2rstr_utf8 (s)), E);


}


function Hex_hmac_md5 (k, D)


{


Return Rstr2hex (Rstr_hmac_md5 (Str2rstr_utf8 (k), Str2rstr_utf8 (d)));


}


function B64_hmac_md5 (k, D)


{


Return rstr2b64 (Rstr_hmac_md5 (Str2rstr_utf8 (k), Str2rstr_utf8 (d)));


}


function Any_hmac_md5 (k, D, E)


{


Return Rstr2any (Rstr_hmac_md5 (Str2rstr_utf8 (k), Str2rstr_utf8 (d)), E);


}





/*


* Perform a simple self-test to, if the VM is working


*/


function Md5_vm_test ()


{


Return HEX_MD5 ("abc"). toLowerCase () = = "900150983cd24fb0d6963f7d28e17f72";


}





/*


* Calculate the MD5 of a raw string


*/


function Rstr_md5 (s)


{


Return Binl2rstr (BINL_MD5 (Rstr2binl (s), s.length * 8));


}





/*


* Calculate the HMAC-MD5, a key and some data (raw strings)


*/


function Rstr_hmac_md5 (key, data)


{


var bkey = rstr2binl (key);


if (Bkey.length &gt;) bkey = Binl_md5 (Bkey, key.length * 8);





var ipad = array, Opad = Array (16);


for (var i = 0; i &lt; i++)


{


Ipad[i] = bkey[i] ^ 0x36363636;


Opad[i] = bkey[i] ^ 0x5c5c5c5c;


}





var hash = binl_md5 (rstr2binl (data), Ipad.concat + data.length * 8);


Return Binl2rstr (BINL_MD5 (Opad.concat (hash), 512 + 128));


}





/*


* Convert a raw string to a hex string


*/


function Rstr2hex (input)


{


try {


Hexcase


catch (e) {


hexcase=0;


}


var hex_tab = hexcase? "0123456789ABCDEF": "0123456789abcdef";


var output = "";


var x;


for (var i = 0; i &lt; input.length; i++)


{


x = Input.charcodeat (i);


Output + + Hex_tab.charat ((x &gt;&gt;&gt; 4) &amp; 0x0f)


+ Hex_tab.charat (x &amp; 0x0f);


}


return output;


}





/*


* Convert a raw string to a base-64 string


*/


function rstr2b64 (input)


{


try {


B64pad


catch (e) {


B64pad= ';


}


var tab = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz0123456789+/";


var output = "";


var len = input.length;


for (var i = 0; i &lt; len; i = 3)


{


var triplet = (Input.charcodeat (i) &lt;&lt; 16)


| (i + 1 &lt; len Input.charcodeat (i+1) &lt;&lt; 8:0)


| (i + 2 &lt; len Input.charcodeat (i+2): 0);


for (var j = 0; J &lt; 4; J + +)


{


if (I * 8 + J * 6 &gt; Input.length * 8) output + + = B64pad;


else output + = Tab.charat ((triplet &gt;&gt;&gt; 6* (3-j)) &amp; 0x3F);


}


}


return output;


}





/*


* Convert a raw string to an arbitrary string encoding


*/


function Rstr2any (input, encoding)


{


var divisor = encoding.length;


var i, J, Q, X, quotient;





/* Convert to an array of 16-bit Big-endian values, forming the dividend * *


var dividend = Array (Math.ceil (INPUT.LENGTH/2));


for (i = 0; i &lt; dividend.length; i++)


{


Dividend[i] = (Input.charcodeat (i * 2) &lt;&lt; 8) | Input.charcodeat (i * 2 + 1);


}





/*


* Repeatedly perform a long division. The binary array forms the dividend,


* The length of the encoding is the divisor. Once computed, the quotient


* Forms the dividend for the next step. All remainders are stored for later


* use.


*/


var full_length = Math.ceil (Input.length * 8/


(Math.log (encoding.length)/Math.log (2)));


var remainders = Array (full_length);


for (j = 0; J &lt; Full_length; J + +)


{


quotient = Array ();


x = 0;


for (i = 0; i &lt; dividend.length; i++)


{


x = (x &lt;&lt;) + dividend[i];


Q = Math.floor (x/divisor);


x = q * DIVISOR;


if (Quotient.length &gt; 0 | | | q &gt; 0)


Quotient[quotient.length] = q;


}


REMAINDERS[J] = x;


Dividend = quotient;


}





* Convert the remainders to the output string */


var output = "";


for (i = remainders.length-1 i &gt;= 0; i--)


Output + + Encoding.charat (remainders[i]);





return output;


}





/*


* Encode a string as Utf-8.


* For efficiency, this assumes the input is valid utf-16.


*/


function Str2rstr_utf8 (input)


{


var output = "";


var i =-1;


var x, y;





while (++i &lt; input.length)


{


/* Decode utf-16 Surrogate Pairs * *


x = Input.charcodeat (i);


y = i + 1 &lt; input.length? Input.charcodeat (i + 1): 0;


if (0xd800 &lt;= x &amp;&amp; x &lt;= 0xDBFF &amp;&amp; 0xdc00 &lt;= y &amp;&amp; y &lt;= 0xDFFF)


{


x = 0x10000 + ((x &amp; 0X03FF) &lt;&lt; ten) + (Y &amp; 0x03ff);


i++;


}





/* Encode OUTPUT as Utf-8 * *


if (x &lt;= 0x7F)


Output + + string.fromcharcode (x);


else if (x &lt;= 0x7ff)


Output + + string.fromcharcode (0xc0 | ((x &gt;&gt;&gt; 6) &amp; 0x1F),


0x80 | (x &amp; 0x3F));


else if (x &lt;= 0xFFFF)


Output + + string.fromcharcode (0xe0 | ((x &gt;&gt;&gt;) &amp; 0x0f),


0x80 | ((x &gt;&gt;&gt; 6) &amp; 0x3F),


0x80 | (x &amp; 0x3F));


else if (x &lt;= 0x1fffff)


Output + + string.fromcharcode (0xF0 | ((x &gt;&gt;&gt; a) &amp; 0x07),


0x80 | ((x &gt;&gt;&gt;) &amp; 0x3F),


0x80 | ((x &gt;&gt;&gt; 6) &amp; 0x3F),


0x80 | (x &amp; 0x3F));


}


return output;


}





/*


* Encode a string as utf-16


*/


function Str2rstr_utf16le (input)


{


var output = "";


for (var i = 0; i &lt; input.length; i++)


Output + + String.fromCharCode (input.charcodeat (i) &amp; 0xFF,


(Input.charcodeat (i) &gt;&gt;&gt; 8) &amp; 0xFF);


return output;


}





function Str2rstr_utf16be (input)


{


var output = "";


for (var i = 0; i &lt; input.length; i++)


Output + + String.fromCharCode (input.charcodeat (i) &gt;&gt;&gt; 8) &amp; 0xFF,


Input.charcodeat (i) &amp; 0xFF);


return output;


}





/*


* Convert a raw string to an array of Little-endian words


* Characters &gt;255 have their high-byte silently.


*/


function Rstr2binl (input)


{


var output = Array (input.length &gt;&gt; 2);


for (var i = 0; i &lt; output.length; i++)


Output[i] = 0;


for (var i = 0; i &lt; input.length * 8; i + + 8)


OUTPUT[I&GT;&GT;5] |= (Input.charcodeat (I/8) &amp; 0xFF) &lt;&lt; (i%32);


return output;


}





/*


* Convert An array of Little-endian words to a string


*/


function Binl2rstr (input)


{


var output = "";


for (var i = 0; i &lt; input.length * i + + 8)


Output + + String.fromCharCode ((input[i&gt;&gt;5] &gt;&gt;&gt; (i%)) &amp; 0xFF);


return output;


}





/*


* Calculate The MD5 of an array of Little-endian words, and a bit length.


*/


function Binl_md5 (x, Len)


{


/* Append padding * *


X[len &gt;&gt; 5] |= 0x80 &lt;&lt; ((len)% 32);


X[((len +) &gt;&gt;&gt; 9) &lt;&lt; 4) + [] = Len;





var a = 1732584193;


var b =-271733879;


var c =-1732584194;


var d = 271733878;





for (var i = 0; i &lt; x.length i + + 16)


{


var Olda = A;


var oldb = b;


var oldc = c;


var oldd = D;





A = Md5_ff (A, B, C, D, x[i+ 0], 7,-680876936);


D = md5_ff (d, a, B, C, x[i+ 1], 12,-389564586);


c = md5_ff (c, D, a, B, x[i+ 2], 17, 606105819);


b = md5_ff (b, C, D, A, x[i+ 3], 22,-1044525330);


A = Md5_ff (A, B, C, D, x[i+ 4], 7,-176418897);


D = md5_ff (d, a, B, C, x[i+ 5], 12, 1200080426);


c = md5_ff (c, D, a, B, x[i+ 6], 17,-1473231341);


b = md5_ff (b, C, D, A, x[i+ 7], 22,-45705983);


A = Md5_ff (A, B, C, D, x[i+ 8], 7, 1770035416);


D = md5_ff (d, a, B, C, x[i+ 9], 12,-1958414417);


c = md5_ff (c, D, a, B, x[i+10], 17,-42063);


b = md5_ff (b, C, D, A, x[i+11], 22,-1990404162);


A = Md5_ff (A, B, C, D, X[i+12], 7, 1804603682);


D = md5_ff (d, a, B, C, x[i+13], 12,-40341101);


c = md5_ff (c, D, a, B, x[i+14], 17,-1502002290);


b = md5_ff (b, C, D, A, x[i+15], 22, 1236535329);





A = Md5_gg (A, B, C, D, x[i+ 1], 5,-165796510);


D = Md5_gg (d, a, B, C, x[i+ 6], 9,-1069501632);


c = Md5_gg (c, D, a, B, x[i+11], 14, 643717713);


b = Md5_gg (b, C, D, A, x[i+ 0], 20,-373897302);


A = Md5_gg (A, B, C, D, x[i+ 5], 5,-701558691);


D = Md5_gg (d, a, B, C, x[i+10], 9, 38016083);


c = Md5_gg (c, D, a, B, x[i+15], 14,-660478335);


b = Md5_gg (b, C, D, A, x[i+ 4], 20,-405537848);


A = Md5_gg (A, B, C, D, x[i+ 9], 5, 568446438);


D = Md5_gg (d, a, B, C, x[i+14], 9,-1019803690);


c = Md5_gg (c, D, a, B, x[i+ 3], 14,-187363961);


b = Md5_gg (b, C, D, A, x[i+ 8], 20, 1163531501);


A = Md5_gg (A, B, C, D, X[i+13], 5,-1444681467);


D = Md5_gg (d, a, B, C, x[i+ 2], 9,-51403784);


c = Md5_gg (c, D, a, B, x[i+ 7], 14, 1735328473);


b = Md5_gg (b, C, D, A, x[i+12], 20,-1926607734);





A = Md5_hh (A, B, C, D, x[i+ 5], 4,-378558);


D = md5_hh (d, a, B, C, x[i+ 8], 11,-2022574463);


c = md5_hh (c, D, a, B, x[i+11], 16, 1839030562);


b = md5_hh (b, C, D, A, x[i+14], 23,-35309556);


A = Md5_hh (A, B, C, D, x[i+ 1], 4,-1530992060);


D = md5_hh (d, a, B, C, x[i+ 4], 11, 1272893353);


c = md5_hh (c, D, a, B, x[i+ 7], 16,-155497632);


b = md5_hh (b, C, D, A, x[i+10], 23,-1094730640);


A = Md5_hh (A, B, C, D, X[i+13], 4, 681279174);


D = md5_hh (d, a, B, C, x[i+ 0], 11,-358537222);


c = md5_hh (c, D, a, B, x[i+ 3], 16,-722521979);


b = md5_hh (b, C, D, A, x[i+ 6], 23, 76029189);


A = Md5_hh (A, B, C, D, x[i+ 9], 4,-640364487);


D = md5_hh (d, a, B, C, x[i+12], 11,-421815835);


c = md5_hh (c, D, a, B, x[i+15], 16, 530742520);


b = md5_hh (b, C, D, A, x[i+ 2], 23,-995338651);





A = Md5_ii (A, B, C, D, x[i+ 0], 6,-198630844);


D = Md5_ii (d, a, B, C, x[i+ 7], 10, 1126891415);


c = Md5_ii (c, D, a, B, x[i+14], 15,-1416354905);


b = Md5_ii (b, C, D, A, x[i+ 5], 21,-57434055);


A = Md5_ii (A, B, C, D, X[i+12], 6, 1700485571);


D = Md5_ii (d, a, B, C, x[i+ 3], 10,-1894986606);


c = Md5_ii (c, D, a, B, x[i+10], 15,-1051523);


b = Md5_ii (b, C, D, A, x[i+ 1], 21,-2054922799);


A = Md5_ii (A, B, C, D, x[i+ 8], 6, 1873313359);


D = Md5_ii (d, a, B, C, x[i+15], 10,-30611744);


c = Md5_ii (c, D, a, B, x[i+ 6], 15,-1560198380);


b = Md5_ii (b, C, D, A, x[i+13], 21, 1309151649);


A = Md5_ii (A, B, C, D, x[i+ 4], 6,-145523070);


D = Md5_ii (d, a, B, C, x[i+11], 10,-1120210379);


c = Md5_ii (c, D, a, B, x[i+ 2], 15, 718787259);


b = Md5_ii (b, C, D, A, x[i+ 9], 21,-343485551);





A = Safe_add (A, Olda);


b = Safe_add (b, oldb);


c = Safe_add (c, OLDC);


D = Safe_add (d, OLDD);


}


Return Array (A, B, C, D);


}





/*


* These functions implement the four basic operations the algorithm uses.


*/


function Md5_cmn (q, A, B, X, S, t)


{


Return Safe_add (Bit_rol (Safe_add (Safe_add (A, Q), Safe_add (x, T)), s), b);


}


function Md5_ff (A, B, C, D, X, S, t)


{


Return Md5_cmn (b &amp; c) | ((~b) &amp; D), A, B, X, S, T);


}


function Md5_gg (A, B, C, D, X, S, t)


{


Return Md5_cmn (b &amp; D) | (C &amp; (~d)), A, B, X, S, T);


}


function Md5_hh (A, B, C, D, X, S, t)


{


return Md5_cmn (b ^ C ^ D, a, B, X, S, T);


}


function Md5_ii (A, B, C, D, X, S, t)


{


return Md5_cmn (c ^ (b) | (~d)), A, B, X, S, T);


}





/*


* Add integers, wrapping at 2^32. This uses 16-bit operations internally


* To work around bugs in some JS interpreters.


*/


function Safe_add (x, y)


{


var LSW = (x &amp; 0xFFFF) + (Y &amp; 0xFFFF);


var MSW = (x &gt;&gt;) + (y &gt;&gt;) + (LSW &gt;&gt; 16);


Return (MSW &lt;&lt; 16) | (LSW &amp; 0xFFFF);


}





/*


* Bitwise rotate a 32-bit number to the left.


*/


function Bit_rol (num, CNT)


{


return (num &lt;&lt; cnt) | (Num &gt;&gt;&gt; (32-cnt));


}


JS Base64:

The code is as follows Copy Code



(function (Global) {


' Use strict ';


Existing version for Noconflict ()


var _base64 = Global. Base64;


var version = "2.1.4";


If node.js, we use Buffer


var buffer;


if (typeof module!== ' undefined ' &amp;&amp; module.exports) {


Buffer = require (' buffer '). Buffer;


}


Constants


var b64chars


= ' abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz0123456789+/';


var b64tab = function (bin) {


var t = {};


for (var i = 0, L = bin.length i &lt; l; i++) T[bin.charat (i)] = i;


return t;


} (B64chars);


var fromcharcode = String.fromCharCode;


Encoder Stuff


var Cb_utob = function (c) {


if (C.length &lt; 2) {


var cc = c.charcodeat (0);


return cc &lt; 0x80? C


: CC &lt; 0x800? (fromCharCode (0xc0 | (CC &gt;&gt;&gt; 6))


+ fromCharCode (0x80 | (CC &amp; 0x3f))


: (fromCharCode (0xe0 | ((cc &gt;&gt;&gt;) &amp; 0x0f))


+ fromCharCode (0x80 | (CC &gt;&gt;&gt; 6) &amp; 0x3f)


+ fromCharCode (0x80 | (CC &amp; 0x3f));


} else {


var cc = 0x10000


+ (c.charcodeat (0)-0xd800) * 0x400


+ (C.charcodeat (1)-0xdc00);


Return (fromCharCode (0xf0 | (cc &gt;&gt;&gt;%) &amp; 0x07)


+ fromCharCode (0x80 | ((cc &gt;&gt;&gt;) &amp; 0x3f))


+ fromCharCode (0x80 | (CC &gt;&gt;&gt; 6) &amp; 0x3f)


+ fromCharCode (0x80 | (CC &amp; 0x3f));


}


};


var Re_utob =/[ud800-udbff][udc00-udffff]| [^x00-x7f]/g;


var Utob = function (u) {


Return U.replace (Re_utob, Cb_utob);


};


var cb_encode = function (CCC) {


var Padlen = [0, 2, 1][ccc.length% 3],


Ord = ccc.charcodeat (0) &lt;&lt; 16


| ((Ccc.length &gt; 1 ccc.charcodeat (1): 0) &lt;&lt; 8)


| ((Ccc.length &gt; 2 ccc.charcodeat (2): 0)),


chars = [


B64chars.charat (Ord &gt;&gt;&gt; 18),


B64chars.charat ((Ord &gt;&gt;&gt;) &amp; 63),


Padlen &gt;= 2? ' = ': B64chars.charat ((Ord &gt;&gt;&gt; 6) &amp; 63),


Padlen &gt;= 1? ' = ': B64chars.charat (Ord &amp; 63)


];


Return Chars.join (");


};


var Btoa = Global.btoa? function (b) {


return Global.btoa (b);


}: Function (b) {


Return B.replace (/[ss]{1,3}/g, Cb_encode);


};


var _encode = buffer


? function (U) {


Return (new buffer (U)). toString (' base64 ')


}


: function (U) {


Return Btoa (Utob (U))


}


;


var encode = function (U, urisafe) {


Return!urisafe


? _encode (U)


: _encode (U). Replace (/[+/]/g, function (M0) {


return M0 = = ' + '? '-' : '_';


). Replace (/=/g, ' ");


};


var encodeURI = function (u) {


return encode (U, True)


};


Decoder stuff


var Re_btou = new RegExp ([


' [XC0-XDF][X80-XBF] ',


' [Xe0-xef][x80-xbf]{2} ',


' [Xf0-xf7][x80-xbf]{3} '


].join (' | '), ' G ');


var Cb_btou = function (CCCC) {


Switch (cccc.length) {


Case 4:


var cp = ((0x07 &amp; cccc.charcodeat (0)) &lt;&lt; 18)


| ((0x3f &amp; Cccc.charcodeat (1)) &lt;&lt; 12)


| ((0x3f &amp; Cccc.charcodeat (2)) &lt;&lt; 6)


| (0x3f &amp; Cccc.charcodeat (3)),


offset = cp-0x10000;


Return (fromCharCode (offset &gt;&gt;&gt;) + 0xd800)


+ fromCharCode ((offset &amp; 0x3ff) + 0xdc00));


Case 3:


Return fromCharCode (


((0x0f &amp; cccc.charcodeat (0)) &lt;&lt; 12)


| ((0x3f &amp; Cccc.charcodeat (1)) &lt;&lt; 6)


| (0x3f &amp; Cccc.charcodeat (2))


);


Default


Return fromCharCode (


((0x1f &amp; cccc.charcodeat (0)) &lt;&lt; 6)


| (0x3f &amp; Cccc.charcodeat (1))


);


}


};


var Btou = function (b) {


Return B.replace (Re_btou, Cb_btou);


};


var cb_decode = function (CCCC) {


var len = cccc.length,


Padlen = len% 4,


n = (len &gt; 0? b64tab[cccc.charat (0)] &lt;&lt; 18:0)


| (Len &gt; 1 B64tab[cccc.charat (1)] &lt;&lt; 12:0)


| (Len &gt; 2 B64tab[cccc.charat (2)] &lt;&lt; 6:0)


| (Len &gt; 3 B64tab[cccc.charat (3)]: 0),


chars = [


fromCharCode (n &gt;&gt;&gt; 16),


fromCharCode ((n &gt;&gt;&gt; 8) &amp; 0xff),


fromCharCode (N &amp; 0xff)


];


Chars.length-= [0, 0, 2, 1][padlen];


Return Chars.join (");


};


var Atob = Global.atob? function (a) {


Return Global.atob (a);


}: Function (a) {


Return A.replace (/[ss]{1,4}/g, Cb_decode);


};


var _decode = buffer


? function (a) {


Return (new buffer (A, ' base64 ')). ToString ()


}


: function (a) {


Return Btou (Atob (a))


};


var decode = function (a) {


Return _decode (


A.replace (/[-_]/g, function (M0) {


return M0 = '-'? '+' : '/'


})


. replace (/[^a-za-z0-9+/]/g, "")


);


};


var noconflict = function () {


var Base64 = Global. Base64;


Global. Base64 = _base64;


return Base64;


};


Export Base64


Global. Base64 = {


Version:version,


Atob:atob,


Btoa:btoa,


Frombase64:decode,


Tobase64:encode,


Utob:utob,


Encode:encode,


Encodeuri:encodeuri,


Btou:btou,


Decode:decode,


Noconflict:noconflict


};


If ES5 is available, make base64.extendstring () available


if (typeof Object.defineproperty = = ' function ') {


var noenum = function (v) {


return {


Value:v,


Enumerable:false,


Writable:true,


Configurable:true


};


};


Global. base64.extendstring = function () {


Object.defineproperty (


String.prototype, ' FromBase64 ', noenum (function () {


Return decode (This)


}));


Object.defineproperty (


String.prototype, ' ToBase64 ', noenum (function (Urisafe) {


Return encode (this, urisafe)


}));


Object.defineproperty (


String.prototype, ' Tobase64uri ', noenum (function () {


Return encode (this, true)


}));


};


}


That ' s it!


}) (this);

Finally, the following very long JS are saved as base64.js files and md5.js files, and then in the file to decrypt the load of the two JS can be.

Related Article

Contact Us

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.