Зачем это нужно?

Как это использовать?

//==== Encrypt portion of data:
string scEncryptString(string source, string key)


//==== Decrypt portion of data:
string scDecryptString(string coded, string key)

//==== On Initialize event:
bool scEncryptInit()

Ограничения

Исходный код

//==================================================================================================​======
// ScEncryptLibrary
// (c) ScorpioT1000 2010
//==================================================================================================​======


//====================================================
// name: ScMath
// author: ScorpioT1000
// note: my libs uses it
//====================================================

int ceil(fixed f) {
    int x = FixedToInt(f);
    if(f > IntToFixed(x)) { return x+1; }
    return x;
}

// little endian, from 0
int int2byte0(int source) { return (source & 0xFF); }
int int2byte(int source, int index) { return ((source >> (index*8)) &  0xFF); }
int int2short0(int source) { return (source & 0x0000FFFF); }
int int2short1(int source) { return (source  << 8); }

//====================================================
// name: ScString
// author: ScorpioT1000
// note: '\n' and '\r' chars don't work
//====================================================
const string scASCIITable="\x1\x2\x3\x4\x5\x6\x7\x8\x9\x1\xB\x1\xD\xE\xF\x10\x11\x12\x13\x14\x15\x16\x17\x18​\x19\x1A\x1B\x1C\x1D\x1E\x1F\x20!\x22#$%&'()*+,-./0123456789:;\x3C=\x3E?@ABCDEFGHIJKLMNOPQRSTUVW​XYZ[\x5C]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7F"; 

// conversion
int string2char(string s) {
    return (StringFind(scASCIITable,s,true));
}
string char2string(int ch) {
    if(ch==0) { return "\x0"; }
    return StringSub(scASCIITable,ch,ch);
}

// add one char to the tail
string stringAddChar(string s, int ch) {
    return s+char2string(ch);
}

// get/set one char in specific position (from 0)
int stringGetChar(string s, int position) {
    return string2char(StringSub(s,position+1,position+1));
}
int stringGetCharPos(string s, string ch) {
    return (StringFind(s,ch,true)-1);
}
string stringSetChar(string s, int position, int ch) {
    int len = StringLength(s);
    position = position + 1; //from 0
    if(len <= 1) { return char2string(ch); }
    if(position == 1) {
        return char2string(ch)+StringSub(s,2,len);
    } else if(position >= (len-1)) {
        return StringSub(s,1,(len-2))+char2string(ch);
    }
    return StringSub(s,1,position-1)+char2string(ch)+StringSub(s,position+1,(len-1));
}

string substr(string src, int start, int end) { return StringSub(src,start+1,end+1); }
string strchar(string src, int index) { return StringSub(src,index+1,index+1); }

//====================================================
// name: ScDebug
// author: ScorpioT1000
// note: my libs uses it
//====================================================

bool scDebugEnable = true;

void scdebug(string msg) {
    UIDisplayMessage(PlayerGroupAll(),c_messageAreaDebug,StringToText("[debug] "+msg));
}

void scassertmsg(string msg) {
    UIDisplayMessage(PlayerGroupAll(),c_messageAreaDebug,StringToText("[assert] "+msg));
}

int sc__isassert=0;
string sc__assertnotes="";
void scassert(bool cond, string notes) {
    if((! cond) && scDebugEnable) {
        scassertmsg("\""+notes+"\" - assertion failed!");
        sc__isassert=1;
        sc__assertnotes = notes;
        TriggerStop(TriggerGetCurrent());
    }
}

//====================================================
// name: ScEncrypt v0.01
// author: ScorpioT1000
// special thanks: NETRAT
// source: www.xgm.ru
// note: it's not recommended to use both "zero"(0) and "ou"(O) symbols in the alphabet
//====================================================

const int scEncryptMaxDataSize = 4096;
const int scEncryptMinDataSize = 4;
const string scEncryptAlphabet = "$#@123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; // 64 !

int sce_a; int sce_b; int sce_c; int sce_w; int sce_x; int sce_y; int sce_z;

//====================================================
//===== Private Functions ============================
//====================================================

//===== data coding

// code 3 8-bit-int (a,b,c) to 4 6-bit-int (w,x,y,z)
void sceCodeData(int a, int b, int c) {
    sce_w = a >> 2;
    sce_x = ((a & 3)<<4) | (b>>4);
    sce_y = ((b & 15)<<2) | (c>>6);
    sce_z = c & 63;
}

// code 4 6-bit-int (w,x,y,z) to 3 8-bit-int (a,b,c)
void sceDecodeData(int w, int x, int y, int z) {
    sce_a = (w<<2) | (x>>4);
    sce_b = ((x & 15)<<4) | (y>>2);
    sce_c = ((y & 3)<<6) | z;
}

//
int [scEncryptMaxDataSize] sce__DataBuffer0;
int sce__DataBuffer0Size =0;
bool sce__inited0 =false;

void sce__DataBufferClear() {
    int i=0;
    while(i < scEncryptMaxDataSize) {
        sce__DataBuffer0[i]=0;
        i=i+1;
    }
}


string sce__CodeS() {
    string s;
    int i=0;
    // integer math, check 4 chars in 2 bytes
    scassert(sce__DataBuffer0Size == ((sce__DataBuffer0Size/3)*3), "sce__CodeS: wrong size");
    while(i < sce__DataBuffer0Size) {
        sceCodeData(sce__DataBuffer0[i],sce__DataBuffer0[i+1],sce__DataBuffer0[i+2]);
        s = s + strchar(scEncryptAlphabet,sce_w);
        s = s + strchar(scEncryptAlphabet,sce_x);
        s = s + strchar(scEncryptAlphabet,sce_y);
        s = s + strchar(scEncryptAlphabet,sce_z);
        i = i+3;
    }
    return s;
}
void sce__DecodeS(string coded) {
    int len = StringLength(coded);
    int i=0;
    int j=0;
    len = (len/4)*4; // integer math, check 3 bytes in 4 chars
    sce__DataBuffer0Size = ceil(len * 0.75); // 3/4
    scassert(sce__DataBuffer0Size > scEncryptMinDataSize, "sce__DecodeS: buffer size is too small");
    scassert(sce__DataBuffer0Size < (scEncryptMaxDataSize+scEncryptMinDataSize), "sce__DecodeS: buffer overflow");
    while(i<len) {
        sce_w = stringGetCharPos(scEncryptAlphabet,strchar(coded,i));
        sce_x = stringGetCharPos(scEncryptAlphabet,strchar(coded,i+1));
        sce_y = stringGetCharPos(scEncryptAlphabet,strchar(coded,i+2));
        sce_z = stringGetCharPos(scEncryptAlphabet,strchar(coded,i+3));
        sceDecodeData(sce_w,sce_x,sce_y,sce_z);
        sce__DataBuffer0[j] = sce_a;
        sce__DataBuffer0[j+1] = sce_b;
        sce__DataBuffer0[j+2] = sce_c;
        j=j+3;
        i=i+4;
    }
}

//===== encryption

string sce__EncryptS(string src, string key) {
    string rk;
    string result;
    int N = StringLength(src);
    int Nk = StringLength(key);
    int i=0;
    int j=0;
    scassert(N < (scEncryptMaxDataSize+scEncryptMinDataSize), "sce__EncryptS: input overflow");
    if(N > Nk) { // rep. key
        while(i < N) {
            if(j >= Nk) {
                j=0;
            }
            rk = rk + strchar(key,j);
            j=j+1;
            i=i+1;
        }
    } else {
        rk = substr(key,0,N-1);
    }
    sce__DataBuffer0[1] = int2byte0(N) ^ string2char(strchar(rk,0)); // c1 = N0 xor rk0
    sce__DataBuffer0[0] = int2byte(N,1) ^ sce__DataBuffer0[1]; // c0 = N1 xor c1
    i=0;
    while(i<N) { // encrypt
        sce__DataBuffer0[i+2] = (string2char(strchar(src,i)) ^ (string2char(strchar(rk,i)) ^ i));
        i=i+1;
    }
    sce__DataBuffer0Size = (i+2);
    j = ((sce__DataBuffer0Size/3) *3);
    if(j != sce__DataBuffer0Size) { sce__DataBuffer0Size = sce__DataBuffer0Size + (j+3-sce__DataBuffer0Size); }
    result = sce__CodeS();
    sce__DataBufferClear();
    return result;
}

string sce__DecryptS(string coded, string key) {
    string result;
    string rk;
    int N =0; // size
    int i=0;
    int j=0;
    int Nk = StringLength(key);
    sce__DecodeS(coded); // decode
    N = (sce__DataBuffer0[1] ^ string2char(strchar(key,0))); // d1 = c1 xor rk0
    N = (((sce__DataBuffer0[0] ^ sce__DataBuffer0[1])<<8) | N); // d0 = c0 xor d1
    scassert(N >= (sce__DataBuffer0Size-scEncryptMinDataSize), "sce__DecryptS: wrong size(-)");
    scassert(N < sce__DataBuffer0Size, "sce__DecryptS: wrong size(+)");
    if(N > Nk) { // rep. key 
        while(i < N) {
            if(j >= Nk) {
                j=0;
            }
            rk = rk + strchar(key,j);
            j=j+1;
            i=i+1;
        }
    } else {
        rk = substr(key,0,N-1);
    }
    i=0;
    while(i < N) { // decrypt
        result = result + char2string(sce__DataBuffer0[i+2] ^ (string2char(strchar(rk,i)) ^ i));
        i=i+1;
    }
    sce__DataBufferClear();
    return result;
}

bool sce__Init0() {
    sce__inited0 = true;
    sce__DataBufferClear();
    return true;
}



//====================================================
//===== User Functions ===============================
// Encrypt and decrypt any data in string by private key.
// note: it's not recommended to use some identical symbols successively
// source size:     from (scEncryptMinDataSize) to (scEncryptMaxDataSize)
// key size:        from 2 to (scEncryptMaxDataSize)
//====================================================

// Encrypt portion of data
string scEncryptString(string source, string key) { return sce__EncryptS(source,key); }

// Decrypt portion of data
string scDecryptString(string coded, string key) { return sce__DecryptS(coded,key); }

// Initialize encryption system
bool scEncryptInit() { return sce__Init0(); }

//====================================================
//====================================================

void scInit() {
    scEncryptInit();
}

А что если взломают?

English Description