Difference between revisions of "XTEA"

From Second Life Wiki
Jump to navigation Jump to search
m (→‎Source: rouge tabs)
Line 1: Line 1:
{{RightToc}}
Another XTEA implementation for LSL. Not sure if i have used the correct endian.
Another XTEA implementation for LSL. Not sure if i have used the correct endian.


===Known Issues===
===Changes===
*Calculating the length properly is difficult. An appropriate solution has not yet determined.


===Future Changes===
====0.3====
*Move index parameter into a global?
*Fixed length calculation
*Combine Decipher and Cipher, then inline Read & Write functions?
*Reduced loop logic, now parses backwards.
 
*Better memory cleanup.
===Changes===
*Less Vertical whitespace


====0.2====
====0.2====
Line 21: Line 21:
===Source===
===Source===
<lsl>//===================================================//
<lsl>//===================================================//
//                XTEA Library v0.2                 //
//                XTEA Library v0.3                 //
//            "Dec  8 2007", "17:01:47"            //
//            "Dec  9 2007", "04:58:36"            //
//  Copyright (C) 2004-2007, Strife Onizuka (cc-by)  //
//  Copyright (C) 2004-2007, Strife Onizuka (cc-by)  //
//    http://creativecommons.org/licenses/by/3.0/    //
//    http://creativecommons.org/licenses/by/3.0/    //
//===================================================//
//===================================================//
//{
string v;
integer v0;
integer v1;
string Base64_XTEA_Encipher(integer num_rounds, string in, list k) {
    integer len = ((llStringLength(v = TrimRight(in,in="=")) * 6) >> 5);
    ReadBase64IntegerPair(len);//ReadBase64Integer could be used here instead
    if((len = ((len + (2 >> !v0)) & 0xFFFFFFFE)))//just a little length fudging
        do{
            integer sum = 0;
            ReadBase64IntegerPair(len -= 2);
            integer j = (-~(num_rounds));
            while((j = ~-j)){
                v0 += (((v1 << 4) ^ ((v1 >> 5) & 0x07FFFFFF)) + v1) ^ (sum + llList2Integer(k, sum & 3));
                sum += 0x9E3779B9;
                v1 += (((v0 << 4) ^ ((v0 >> 5) & 0x07FFFFFF)) + v0) ^ (sum + llList2Integer(k, (sum >> 11) & 3));
            }
            WriteBase64IntegerPair(len);
        }while(len);
    return TrimRight(v, v = "A");
}
string Base64_XTEA_Decipher(integer num_rounds, string in, list k) {
    integer len = ((llStringLength(v = TrimRight(in,in="=")) * 6) >> 5);
    ReadBase64IntegerPair(len);//ReadBase64Integer could be used here instead
    if((len = ((len + (2 >> !v0)) & 0xFFFFFFFE)))//just a little length fudging
        do{
            integer sum = 0x9E3779B9 * num_rounds;
            ReadBase64IntegerPair(len -= 2);
            integer j = (-~(num_rounds));
            while((j = ~-j)){
                v1 -= (((v0 << 4) ^ ((v0 >> 5) & 0x07FFFFFF)) + v0) ^ (sum + llList2Integer(k, (sum >> 11) & 3));
                sum -= 0x9E3779B9;
                v0 -= (((v1 << 4) ^ ((v1 >> 5) & 0x07FFFFFF)) + v1) ^ (sum + llList2Integer(k, sum & 3));
            }
            WriteBase64IntegerPair(len);
        }while(len);
    return TrimRight(v, v = "A");
}
//} XTEA Library


//===================================================//
//===================================================//
//                Combined Library                  //
//                Combined Library                  //
//            "Dec  8 2007", "17:01:47"            //
//            "Dec  9 2007", "04:58:36"            //
//  Copyright (C) 2004-2007, Strife Onizuka (cc-by)  //
//  Copyright (C) 2004-2007, Strife Onizuka (cc-by)  //
//    http://creativecommons.org/licenses/by/3.0/    //
//    http://creativecommons.org/licenses/by/3.0/    //
Line 40: Line 83:
//Mono is the future VM for LSL, LSO is the current VM of LSL.
//Mono is the future VM for LSL, LSO is the current VM of LSL.
//To achieve safety, the functions require more bytecode and sacrifice a bit of performance.
//To achieve safety, the functions require more bytecode and sacrifice a bit of performance.
string Base64Pad(string in)
{
    integer len = llStringLength(in);
    return in + llDeleteSubString("AAAA", 1, len % 4);
}


string TrimRight(string src, string chrs)//Mono Safe, LSO Safe
string TrimRight(string src, string chrs)//Mono Safe, LSO Safe
Line 111: Line 148:


//} Combined Library
//} Combined Library
string v;
integer v0;
integer v1;
string Base64_XTEA_Encipher(integer num_rounds, string in, list k) {
    integer len = (((llStringLength(v = TrimRight(in,in="=")) + 4) * 6) >> 5);
    integer i = -2;
    while((i += 2) < len)
    {
        integer sum = 0;
        ReadBase64IntegerPair(i);
        integer j = (-~(num_rounds));
        while((j = ~-j)){
            v0 += (((v1 << 4) ^ ((v1 >> 5) & 0x07FFFFFF)) + v1) ^ (sum + llList2Integer(k, sum & 3));
            sum += 0x9E3779B9;
            v1 += (((v0 << 4) ^ ((v0 >> 5) & 0x07FFFFFF)) + v0) ^ (sum + llList2Integer(k, (sum >> 11) & 3));
        }
        WriteBase64IntegerPair(i);
    }
    return TrimRight(v, "A");
}
string Base64_XTEA_Decipher(integer num_rounds, string in, list k) {
    integer len = (((llStringLength(v = TrimRight(in,in="=")) + 4) * 6) >> 5);
    integer i = -2;
    while((i += 2) < len)
    {
        integer sum = 0x9E3779B9 * num_rounds;
        ReadBase64IntegerPair(i);
        integer j = (-~(num_rounds));
        while((j = ~-j)){
            v1 -= (((v0 << 4) ^ ((v0 >> 5) & 0x07FFFFFF)) + v0) ^ (sum + llList2Integer(k, (sum >> 11) & 3));
            sum -= 0x9E3779B9;
            v0 -= (((v1 << 4) ^ ((v1 >> 5) & 0x07FFFFFF)) + v1) ^ (sum + llList2Integer(k, sum & 3));
        }
        WriteBase64IntegerPair(i);
    }
    return TrimRight(v, "A");
}


list mk;
list mk;
Line 185: Line 174:
             for(a = 0; a < 3; ++a)
             for(a = 0; a < 3; ++a)
                 mk += (integer)llList2String(e,a);
                 mk += (integer)llList2String(e,a);
             llOwnerSay(llList2CSV(mk));
             llOwnerSay(llList2CSV([rounds, "~~~~"] + mk));
         }
         }
         else if(a == 2)
         else if(a == 2)
Line 218: Line 207:
             llOwnerSay(b = d = v);
             llOwnerSay(b = d = v);
             llOwnerSay(llList2CSV([d = Base64_XTEA_Encipher(rounds, b, mk)]));
             llOwnerSay(llList2CSV([d = Base64_XTEA_Encipher(rounds, b, mk)]));
             llOwnerSay(llList2CSV([d = Base64_XTEA_Decipher(rounds, d, mk), llBase64ToString(Base64Pad(d))]));
             llOwnerSay(llList2CSV([d = Base64_XTEA_Decipher(rounds, d, mk), llBase64ToString(d)]));
             llOwnerSay(llList2CSV([b, llBase64ToString(Base64Pad(b))]));
             llOwnerSay(llList2CSV([b, llBase64ToString(b)]));
         }
         }
     }
     }
}</lsl>
}</lsl>

Revision as of 02:57, 9 December 2007

Another XTEA implementation for LSL. Not sure if i have used the correct endian.

Changes

0.3

  • Fixed length calculation
  • Reduced loop logic, now parses backwards.
  • Better memory cleanup.
  • Less Vertical whitespace

0.2

  • Uses globals cutting down on instances and copies, should result in a huge time and bytecode savings.
  • Base64 functions moved from XTEA in to CL.
  • All functions optimized further.
  • Introduction of ReadBase64IntegerPair - By doing read and writes this way it reduces bytecode.

0.1

  • Initial Release

Source

<lsl>//===================================================// // XTEA Library v0.3 // // "Dec 9 2007", "04:58:36" // // Copyright (C) 2004-2007, Strife Onizuka (cc-by) // // http://creativecommons.org/licenses/by/3.0/ // //===================================================// //{

string v; integer v0; integer v1;

string Base64_XTEA_Encipher(integer num_rounds, string in, list k) { 

   integer len = ((llStringLength(v = TrimRight(in,in="=")) * 6) >> 5);
   ReadBase64IntegerPair(len);//ReadBase64Integer could be used here instead
   if((len = ((len + (2 >> !v0)) & 0xFFFFFFFE)))//just a little length fudging
       do{
           integer sum = 0;
           ReadBase64IntegerPair(len -= 2);
           integer j = (-~(num_rounds));
           while((j = ~-j)){
               v0 += (((v1 << 4) ^ ((v1 >> 5) & 0x07FFFFFF)) + v1) ^ (sum + llList2Integer(k, sum & 3));
               sum += 0x9E3779B9;
               v1 += (((v0 << 4) ^ ((v0 >> 5) & 0x07FFFFFF)) + v0) ^ (sum + llList2Integer(k, (sum >> 11) & 3));
           }
           WriteBase64IntegerPair(len);
       }while(len);
   return TrimRight(v, v = "A");

}

string Base64_XTEA_Decipher(integer num_rounds, string in, list k) { 

   integer len = ((llStringLength(v = TrimRight(in,in="=")) * 6) >> 5);
   ReadBase64IntegerPair(len);//ReadBase64Integer could be used here instead
   if((len = ((len + (2 >> !v0)) & 0xFFFFFFFE)))//just a little length fudging
       do{
           integer sum = 0x9E3779B9 * num_rounds;
           ReadBase64IntegerPair(len -= 2);
           integer j = (-~(num_rounds));
           while((j = ~-j)){
               v1 -= (((v0 << 4) ^ ((v0 >> 5) & 0x07FFFFFF)) + v0) ^ (sum + llList2Integer(k, (sum >> 11) & 3));
               sum -= 0x9E3779B9;
               v0 -= (((v1 << 4) ^ ((v1 >> 5) & 0x07FFFFFF)) + v1) ^ (sum + llList2Integer(k, sum & 3));
           }
           WriteBase64IntegerPair(len);
       }while(len);
   return TrimRight(v, v = "A");

}

//} XTEA Library

//===================================================// // Combined Library // // "Dec 9 2007", "04:58:36" // // Copyright (C) 2004-2007, Strife Onizuka (cc-by) // // http://creativecommons.org/licenses/by/3.0/ // //===================================================// //{

//Functions marked "Mono Safe" are safe for use in LSLEditor & Mono //Functions marked "LSO Safe" are safe for use in LSO //Functions marked "Double Safe" are safe for use in VM's that support doubles (Mono, LSLEditor). //Mono is the future VM for LSL, LSO is the current VM of LSL. //To achieve safety, the functions require more bytecode and sacrifice a bit of performance.

string TrimRight(string src, string chrs)//Mono Safe, LSO Safe { 

   integer i = llStringLength(src);
   integer j = i;
   do ; while(~llSubStringIndex(chrs, llGetSubString(src, i = (~-(j = i)), i)) && j);
   return llDeleteSubString(src, j, 0x7FFFFFF0);

}

ReadBase64IntegerPair(integer index) { 

   integer S = (index << 5) % 6;
   string buf = llGetSubString(v, index = ((index << 5) / 6), index + 11);
   index = llBase64ToInteger(llGetSubString("A" + (llDeleteSubString(buf, 0, 2)) + "AAAAA", 0, 5));

       v0 = (llBase64ToInteger(llGetSubString((buf) + "AAAAAA", 0, 5)) << S) | (index >> (12 - S));
       v1 = ((llBase64ToInteger(llGetSubString((llDeleteSubString(buf,0,5)) + "AAAAAA", 0, 5)) >> (4 - S)) & ~(0xF0000000 << S)) | (index << (20 + S));

}

WriteBase64IntegerPair(integer index) { 

   integer S = 10 - ((index << 5) % 6);
   v =  llDeleteSubString(
               llInsertString(
                   v,
                   index = ((index << 5) / 6),
                   llInsertString(
                       llInsertString(
                           llIntegerToBase64(
                               (llBase64ToInteger(llGetSubString((v = llGetSubString(v, index, index + 12)) + "AAAAAA", 0, 5)) & (0xFFC00000 << S)) | 
                               ((v0 >> (10 - S)) & ~(0xFFC00000 << S))
                           ),
                           3,
                           llIntegerToBase64(
                               ((v1 >> (24 - S)) & ~(0xFFFFFF00 << S)) | 
                               (v0 << (8 + S))
                           )
                       ),
                       7,
                       llIntegerToBase64(
                           (llBase64ToInteger(llGetSubString((llDeleteSubString(v, 0, 6)) + "AAAAAA", 0, 5)) & ~(0xFFFFFFFF << S)) | 
                           (v1 << S)
                       )
                   )
               ),
               index + 12,
               index + 35
           );

}

HexToBase64(string a) { 

   v = "";
   integer e = (llStringLength(a = (a + "0000000000000000")) - 9) & 0xFFFFFFF8;
   integer g;
   do
   {
       v0 = ((integer)("0x"+(llGetSubString(a, g, g + 7)))); v1 = ((integer)("0x"+(llGetSubString(a, g + 8, g + 15)))); WriteBase64IntegerPair(g >> 3);
   }while((g += 16) < e);

}

//} Combined Library

list mk; integer rounds = 128;

default { 

   state_entry()
   {
       key owner = llGetOwner();
       llListen(0, "", owner, "");
       llListen(1, "", owner, "");
       llListen(2, "", owner, "");
       llListen(3, "", owner, "");
       llListen(4, "", owner, "");
       llListen(5, "", owner, "");

   }
   listen(integer a, string b, key c, string d)
   {
       if(a == 1)
       {
           mk = [];
           list e = llCSV2List(d);
           for(a = 0; a < 3; ++a)
               mk += (integer)llList2String(e,a);
           llOwnerSay(llList2CSV([rounds, "~~~~"] + mk));
       }
       else if(a == 2)
       {
           rounds = (integer)d;
           llOwnerSay(llList2CSV([rounds, "~~~~"] + mk));
       }
       else if(a == 3)
       {
           v = TrimRight(llStringToBase64(d), "=");
           ReadBase64IntegerPair(0);
           mk = [v0,v1];
           ReadBase64IntegerPair(2);
           mk += [v0,v1];
           llOwnerSay(llList2CSV([rounds, "~~~~"] + mk));
       }
       else if(a == 4)
       {
           HexToBase64(d);
           ReadBase64IntegerPair(0);
           mk = [v0,v1];
           ReadBase64IntegerPair(2);
           mk += [v0,v1];
           llOwnerSay(llList2CSV([rounds, "~~~~"] + mk));
       }
       else
       {
           if(a == 5)
               HexToBase64(d);
           else
               v = llStringToBase64(d);
           llOwnerSay(b = d = v);
           llOwnerSay(llList2CSV([d = Base64_XTEA_Encipher(rounds, b, mk)]));
           llOwnerSay(llList2CSV([d = Base64_XTEA_Decipher(rounds, d, mk), llBase64ToString(d)]));
           llOwnerSay(llList2CSV([b, llBase64ToString(b)]));
       }
   }

}</lsl>

Retrieved from "https://wiki.secondlife.com/w/index.php?title=XTEA&oldid=44048"