二十六进制形式加密字符

//加密ASC码十进制33~126的字符，用二十六进制显示

int linearEncrypt(char *RegCode, char *EncryptData)
{
    int index = 0, k, b, i, x, y, scope;
    char EncryptBuff[65] = {0};
    char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";    
    if(!RegCode || strlen(RegCode) != 12)
    {
        LOG(sw_LIN_EN, "RegCode: %s, input data length not equal to 12 bit or is NULL\n", RegCode);
        return -1;
    }
    
    srand((int)time(0));
    k = (int)(rand()%5 + 1); //随机生成1-5，不加1生成0-4

    LOG(sw_LIN_EN, "k: %d\n", k);
    switch(k)
    {
        case 1:
        {
            scope = 548;
            break;
        }
        case 2:
        {
            scope = 422;
            break;
        }
        case 3:
        {
            scope = 296;
            break;
        }
        case 4:
        {
            scope = 170;
            break;
        }
        case 5:
        {
            scope = 44;
            break;
        }
        default:
            return -1;
    }
    EncryptBuff[0] = alphabet[(int)(rand()%26)];
    EncryptBuff[1] = alphabet[k];
    EncryptBuff[2] = alphabet[(int)(rand()%26)];
    EncryptBuff[3] = alphabet[strlen(RegCode) + k];

    for(i = 4; i < 64; i++)
    {
        EncryptBuff[i] = alphabet[(int)(rand()%26)];
        b = (int)(rand()%scope + 1);

        switch(k)
        {
            case 1:
            {
                if(b < 1 || b > 548)
                    return -1;
                break;
            }
            case 2:
            {
                if(b < 1 || b > 422)
                    return -1;
                break;
            }
            case 3:
            {
                if(b < 1 || b > 296)
                    return -1;
                break;
            }
            case 4:
            {
                if(b < 1 || b > 170)
                    return -1;
                break;
            }
            case 5:
            {
                if(b < 1 || b > 44)
                    return -1;
                break;
            }
            default:
                return -1;
        }
    
        EncryptBuff[i + 1] = alphabet[b/26];
        EncryptBuff[i + 2] = alphabet[b%26];

        x = (int)RegCode[index];
        index += 1;
        y = k*x + b;
        LOG(sw_LIN_EN, "i: %d index: %d, b: %d, -----x: %d, y: %d\n", i, index, b, x, y);

        if(index < 13 || index > 0)
        {
            EncryptBuff[i + 3] = alphabet[y/26];
            EncryptBuff[i + 4] = alphabet[y%26];
        }else
            return -1;
            
        i += 4;    

    }

    strncpy(EncryptData, EncryptBuff, strlen(EncryptBuff));
    LOG(sw_LIN_EN, "last EncryptBuff: %s, len: %ld\n", EncryptBuff,strlen(EncryptBuff));
    
    return 0;
}

int linearDecode(char *EncryptData, char *DecodeData)
{
    int index = 0, k, len,  i, y, x, b, bit1, bit2;
    char DecodeBuff[13] = {0};
    char CharTable[] = "! #$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[ ]^_`abcdefghijklmnopqrstuvwxyz{|}~";
    LOG(sw_LIN_DC, "len charTable: %ld\n", strlen(CharTable));

    if(!EncryptData)
        return -1;
    
    k = checkIndex(EncryptData[1]);
    len = strlen(EncryptData);    
    if(checkIndex(EncryptData[3]) - k != 12 || len != 64)
    {
        LOG(sw_LIN_DC, "encrypt data len error\n");
        return -1;
    }

    LOG(sw_LIN_DC, "k: %d, Encrypt Data len: %d\n", k, len);
    
    for(i = 5; i < len - 1; i++)
    {
        bit1 = checkIndex(EncryptData[i]);
        bit2 = checkIndex(EncryptData[i + 1]);

        b = 26*bit1 + bit2;
        LOG(sw_LIN_DC, "b: %d, bit1: %d, bit2: %d\n", b, bit1, bit2);
        switch(k)
        {
            case 1:
            {
                if(b < 1 || b > 548)
                    return -1;
                break;
            }
            case 2:
            {
                if(b < 1 || b > 422)
                    return -1;
                break;
            }
            case 3:
            {
                if(b < 1 || b > 296)
                    return -1;
                break;
            }
            case 4:
            {
                if(b < 1 || b > 170)
                    return -1;
                break;
            }
            case 5:
            {
                if(b < 1 || b > 44)
                    return -1;
                break;
            }
            default:
                return -1;
        }        

        bit1 = checkIndex(EncryptData[i + 2]);
        bit2 = checkIndex(EncryptData[i + 3]);
        LOG(sw_LIN_DC, "y--bit1: %d, bit2: %d\n", bit1, bit2);

        y = 26*bit1 + bit2;
        x = (y - b)/k;
        if(x > 32 && x < 48) //字符：! #$%&'()*+,-./
        {
            DecodeBuff[index] = CharTable[x - 33];
        }

        if(x > 47 && x < 58) //字符：0123456789
        {
            DecodeBuff[index] = CharTable[(x - 48) + 15];
        }
        
        if(x > 57 && x < 65) //字符：:;<=>?@
        {
            DecodeBuff[index] = CharTable[(x - 58) + 25];
        }    
        
        if(x > 64 && x < 91) //字符：ABCDEFGHIJKLMNOPQRSTUVWXYZ
        {
            DecodeBuff[index] = CharTable[(x - 65) + 32];
        }

        if(x > 90 && x < 97) //字符：[ ]^_`
        {
            DecodeBuff[index] = CharTable[(x - 91) + 58];
        }

        if(x > 96 && x < 123) //字符：abcdefghijklmnopqrstuvwxyz
        {
            DecodeBuff[index] = CharTable[(x - 97) + 64];
        }
        
        if(x > 122 && x < 127) //字符：{|}~
        {
            DecodeBuff[index] = CharTable[(x - 123) + 90];
        }    
        
        LOG(sw_LIN_DC, "y: %d, x: %d, index: %d, DecodeBuff: %s\n", y, (y - b)/k, index, DecodeBuff);
        index += 1;
        i += 4;
        
    }

    strncpy(DecodeData, DecodeBuff, strlen(DecodeBuff));
    LOG(sw_LIN_DC, "last DecodeBuff: %s, len: %ld\n", DecodeBuff,strlen(DecodeBuff));

    return 0;
}