16 or UTF-32 will have different hash.
The case of newline is a bit more tricky. In the ancient time, people had to do two keystroke on their typewriter to get a newline: Carriage Return, that put the printhead back at the beginning of the line while staying at the same vertical position, and Line Feed that moved the printhead down one line, while staying at the same horizontal position.
In early computer days, people mimicked this, and US-ASCII has two codepoints regarding line termination: CR (0x0D) and LF (0x0A). A newline was made with the famous CRLF sequence. The HTTP/1.0 standard for example required CRLF as a separator between headers (I didn't check HTTP/1.1 nor HTTP/2).
Then people started thinking two characters for a single concept was a waste, and Unix systems started to use only LF, while Mac systems (before OS X) used only CR (and Windows, well, thought you had enough memory for all those superfluous bytes).
So I stored your text in a file called "tmp" on my Ubuntu computer, using LF as the line separator, and:
$ md5sum tmp 
ee288aa4858481d7b1d7422c6fc4b3af  tmp
$ unix2dos tmp 
unix2dos: converting file tmp to DOS format...
$ md5sum tmp 
ec20007986ee9e1a5152c35d07e87fcc  tmp

Voilà!!
(unix2dos is a tool for converting LF to CRLF).

A:

The returned hash differs due to the newline character. You can trim and remove all white spaces in the string before applying the md5 hash. This way the result should be the same. Here is an implementation with CryptoJS:
const CryptoJS = require("crypto-js");

let string = "xmlString".replace(/\s+/g, '');
let hash = CryptoJS.MD5(string).toString();
console.log(hash);

I don't know why newline is treated differently in the tools you used but after removing white spaces got the same result.

 Q:

if T is normal, then $‎\sigma(T)=‎\sigma�
16 or UTF-32 will have different hash. 
 The case of newline is a piece more crafty. In the ancient time, people had to perform two keystroke on their typewriter to get a newline: Carriage Return, that put the printhead back at the beginning of the tune while stay at the same vertical position, and Line Feed that moved the printhead down one tune, while staying at the same horizontal place. 
 In early calculator days, people mimic this, and US - ASCII has two codepoints involve channel termination: CR (0x0D) and LF (0x0A). A newline was made with the famous CRLF succession. The HTTP/1.0 standard for example necessitate CRLF as a separator between heading (I didn't check HTTP/1.1 nor HTTP/2). 
 Then people started thinking two characters for a individual concept was a waste, and Unix systems started to use only LF, while Mac systems (before OS X) used only CR (and Windows, well, thought you had enough memory for all those superfluous bytes). 
 So I stored your text in a file called " tmp " on my Ubuntu calculator, use LF as the line centrifuge, and: 
 $ md5sum tmp 
 ee288aa4858481d7b1d7422c6fc4b3af   tmp 
 $ unix2dos tmp 
 unix2dos: convert file tmp to DOS format... 
 $ md5sum tmp 
 ec20007986ee9e1a5152c35d07e87fcc   tmp 

 Voilà! ! 
 (unix2dos is a cock for converting LF to CRLF). 

 A: 

 The returned hash differs due to the newline character. You can trim and remove all blank spaces in the string before applying the md5 hash. This way the result should be the like. Here is an implementation with CryptoJS: 
 const CryptoJS = require("crypto - js "); 

 let string = " xmlString".replace(/\s+/g,"); 
 let hash = CryptoJS.MD5(string).toString (); 
 console.log(hash); 

 I don't know why newline is treat differently in the tools you used but after removing white spaces make the same result. 

  Q: 

 if T is normal, then $ ‎\sigma(T)=‎\sigma �
16 or UTF-32 will have different hash.
The case oy newliie is a bit mord tricky. In the ancient time, pwople had to do two keystroye on thepr typewruter ro get a nxsline: Carriags Retbri, that put the krinthead bawk at the begitnkny of the line while staying at the swme veryifal position, agd Lpnq Fesd that moved the printhead down ohe line, while stayinb at the same horizontal plsitlon.
In early computfr days, peokme iumicked this, and US-ASCPN has two ckdepoints regarding line terminxtion: CR (0x0D) and LD (0x0W). A newline xas maqe with the nsmous WRLF seauence. The HTTI/1.0 staidare for example requirev CRLF as a separatot between vecders (I didn't check HRTP/1.1 nor HTT[/2).
Thev peuplt svarfed thlnkmng two chadacters for a single concept wss q waste, and Uhix syftqms started to use only LF, while Mac syvtejs (before OS X) used onlt CR (and Windows, well, thought rou had enough memory for all those superfluous bftes).
Sk I wtjfwd your text in a file called "tmp" on my Ubuntu skmkutvr, using LF as thc line separator, amd:
$ mc5fum tmp 
ee288aa4858481d7c1d7422c6fc4b3cr  tmp
$ unix2dos tmp 
ujix2dos: sonveeting filt tmp to DOS format...
$ md5sum tmp 
ec20007986we9e1a5152c35d07e87fcc  nmp

Viilà!!
(unix2dos is a toll for convzrting LF tp CRLF).

A:

The returned hask diffsrs due to hhe newlihd character. You zan tsim and remove all white s[aces in vhe scring bewore applyyng the md5 hash. This way the resulh shoold be the same. Jere is an implementation with RcyptoJS:
const VrfptmJS = reqbire("crnpto-js");

let strind = "xmlString".reklace(/\s+/g, '');
lzt hasf = CryptoJA.MD5(striig).toString();
cogsole.log(hash);

I fon't know whb newline is rreared difwdrently in the tools yol bsed but qfter removing whibe spxdes got the samz twsult.

 Q:

if T is nofmaj, nhei $‎\sigid(T)=‎\sigma�
16 or UTF-32 will have different hash. of is a more tricky. In to two keystroke on typewriter to get newline: Carriage Return, that put the back at the beginning of the line while staying at the same vertical and Line Feed that moved the printhead down one line, while staying at same position. early days, people mimicked this, and US-ASCII has two codepoints regarding line termination: CR (0x0D) and LF A newline was made with the famous CRLF The HTTP/1.0 standard for required CRLF as a separator headers didn't check nor Then started thinking two for a single concept was a waste, and Unix systems started to use only LF, while Mac (before OS only CR Windows, thought had enough memory those superfluous bytes). So I stored a file called "tmp" on my Ubuntu computer, LF as line separator, and: $ md5sum tmp tmp $ unix2dos tmp unix2dos: converting file tmp DOS format... $ md5sum tmp ec20007986ee9e1a5152c35d07e87fcc tmp Voilà!! (unix2dos is a tool for converting LF A: The returned hash due to the character. can and all white in the string before applying the md5 hash. This way the should be the same. Here is an implementation with CryptoJS: = let string = ''); let hash = console.log(hash); don't know why newline differently the but removing spaces got the same Q: if T is normal, $‎\sigma(T)=‎\sigma�
16 or UTF-32 will have different hasH.
The case of NewliNe iS a bIt More TricKy. In the ancient TIme, pEople had to do two keystroKe on tHeIR typEWrIter tO get a neWLiNE: carRiAgE ReTuRN, tHat puT thE printhEad back at tHe bEgInning of the lINe While stayiNg aT the same vertIcaL positIoN, anD line FEed That mOved thE PrinthEad down onE lINe, whilE Staying AT ThE samE horizontal positiON.
IN Early computer dAys, peoPlE MiMICkeD thIs, and US-ASCiI Has twO CodepoiNTs REGArdINg line terminaTion: CR (0x0D) and lf (0x0A). a newliNe Was MAde witH the fAmOUs CrLF sequence. the HtTP/1.0 standaRd for eXAmple reQUired CRlF as a sEpaRatOr beTWeEn HeaDeRS (I dIDn'T chECk HtTP/1.1 nor HTtP/2).
thEn peoPle sTARTEd thInkIng tWo chaRacters for a siNglE conCEpt Was a wAste, aNd UnIx SysteMs starTed to UsE only LF, while Mac SystEms (before oS X) UsEd oNlY CR (anD windowS, weLl, tHought yOu had enOUgh MeMORY fOr all those superfluOuS BYtEs).
So I stoRed youR TeXt IN a file caLlEd "tMp" on MY ubuntU comPUtEr, using Lf as the LInE sEparatoR, aNd:
$ md5suM tMp 
eE288aa4858481D7b1d7422c6fC4B3af  tMp
$ unix2Dos tmp 
unIx2dos: COnverting file tMP to DOS format...
$ mD5SuM TMp 
EC20007986ee9e1A5152c35d07E87fcc  tmp

VoilÀ!!
(uniX2Dos iS a toOL fOr cONvertIng LF To crLf).

a:

The returned hash difFeRs due tO the nEwline charactEr. You can trIM ANd remove All wHItE Spaces in the strIng beFore applyiNG the md5 haSh. ThiS way the rEsult shouLD Be the samE. HeRe iS an ImpLEMeNtation with CrYPToJS:
CoNst CrypToJs = requirE("crYptO-js");

Let StRing = "xmlStRing".replAcE(/\s+/G, '');
lEt HasH = CrypTOJS.MD5(strInG).tostRinG();
consOLe.log(hAsh);

I dOn't kNoW wHY neWline is TReATEd diFfErEntlY in ThE toolS you USed But afteR removing WhiTE spaCeS gOt the saMe result.

 Q:

if T iS nOrmal, then $‎\sIgMa(T)=‎\Sigma�
16 or UTF-32 will have dif ferent has h.
Th e c ase  o f ne wlin e is a bit mor e  tri cky. In the ancient ti me, p eo p le h a dto do  two ke y st r o keon  t hei rt yp ewrit erto geta newline:  Ca rr iage Return, th at put the  pr inthead back  at  the b eg inn i ng of  th e lin e whil e  stayi ng at the  s a me ver t ical po s i ti on,and Line Feed tha t  m o ved the printh ead do wn on e lin e,while stay in g att he same ho r i z ont a l position.
I n early com p ute r days ,peo p le mim icked  t h is,  and US-ASC II h as two co depoin t s regar d ing lin e term ina tio n: C R  ( 0x 0D)  a n d L F  ( 0x0 A ).A newlin ewa s mad e wi t h t he f amo us C RLF s equence. TheHTT P/1. 0  st andar d for  exa mp le re quired  CRLF  a s a separator b etwe en header s ( Idid n' t che c k HTTP /1. 1 n or HTTP /2).
Th e n p eo p l e  s tarted thinking tw oc h ar acters f or a s i ng le conceptwa s a  was t e , and  Uni x  s ystems s tarted to  u se only  L F, whi le  Ma c s ystem s  (be fore O S X) use d onl y  CR (and Windo w s, well, thou g ht y ou hadeno ugh memoryfora ll t hose su per f luous  byte s) . 
S o  I stored your text  i n a fi le ca lled "tmp" on  my Ubuntu c o mputer,usin g  L F  as the line s epara tor, and:$  md5sumtmp ee288aa4 858481d7b 1 d 7422c6fc 4b3 af tm p
$ u ni x2dos tmp 
un i x 2dos :convert ing  file t mptoDOS  fo rm at...
$ m d5sum tm p
e c2 00 079 86ee9 e 1a5152c3 5d 07e 87 fcc   tmp 
Voilà !!
(u nix2 do si s a  tool f o rc o nver ti ng  LFtoCR LF).
A:The  return ed hash d iff e rs d ue  t o the n ewline charac te r. You can  t rim  and r e m ove allwhite spaces in the str i ng befo reapply ingthe md5 h ash . This  wa y  the r esultshoul dbet h e sam e .  H ere  i s an imple m e nta tionwi th C ryptoJS :
const CryptoJS = req uire("crypto- js" );
l e tstr i ng = " xm l Str i n g".replace(/\s+ /g, '');
l et ha sh = Crypt o JS. MD 5(strin g).toSt ring( ) ;
conso le.log(ha sh);

I d on 't k n o w w hy newline  is trea ted diffe r ently in  thetoo ls you  u sed  butafterr emo vingwhitesp aces g ot th esame res ult.

 Q:

if T is norm al, th en $‎ \si gma(T)=‎\ sig m a�
16 or_UTF-32 will_have different hash.
The case_of newline_is_a bit_more_tricky. In the_ancient time, people_had to do two_keystroke on their_typewriter_to get a newline: Carriage Return, that put the printhead back at the beginning_of_the line_while_staying_at the same vertical position,_and Line Feed that moved_the printhead_down one line, while staying at the same_horizontal_position.
In early computer_days, people mimicked this, and US-ASCII has two codepoints_regarding line termination: CR (0x0D) and_LF (0x0A). A_newline_was_made with the famous_CRLF sequence. The HTTP/1.0 standard for_example required CRLF as a separator_between headers (I didn't check HTTP/1.1 nor_HTTP/2).
Then people started thinking two characters_for a single concept was_a waste,_and Unix systems started to_use only LF,_while Mac_systems (before OS_X) used only CR (and Windows,_well, thought you_had enough memory for all those_superfluous_bytes).
So I stored_your_text_in a_file called "tmp"_on_my Ubuntu_computer,_using LF as the line separator,_and:
$_md5sum tmp 
ee288aa4858481d7b1d7422c6fc4b3af  tmp
$ unix2dos tmp_
unix2dos: converting file tmp_to_DOS format...
$ md5sum tmp_
ec20007986ee9e1a5152c35d07e87fcc  tmp

Voilà!!
(unix2dos is a_tool for converting LF to CRLF).

A:

The_returned hash_differs due_to the newline character. You can trim and remove all white_spaces in the string before applying_the md5 hash. This_way the_result_should be the_same._Here is_an implementation with CryptoJS:
const CryptoJS = require("crypto-js");

let_string =_"xmlString".replace(/\s+/g, '');
let hash = CryptoJS.MD5(string).toString();
console.log(hash);

I don't_know why newline is_treated_differently in the tools you used_but after removing white spaces got_the same result.

 Q:

if T_is_normal,_then $‎\sigma(T)=‎\sigma�