这个密码算法的主要问题有2点：
1、算法强度完全依赖于随机化函数；
2、只能一次一密。

　　1.用比较差的随机函数也能有不错的效果（例如 C里面的rand（）），好的就更好了。请注意随机排序的n1, 要是不使用随机函数而使用ss_my[],n1,循环变量等做参数，依然能向下运行，我称其为自我激励，但我觉得没有随机函数来的强壮，如果两者结合起来也许效果更好，这样对随机函数的依赖也小些。
　　2.一个明文字节，用多个密钥字节很容易实现。或者可以做出一个密钥串加密后，再做一个密钥串，再次加密...，但有这个必要吗？

choday，rqqeq ：编程和密码学都是粗略的业余学习见笑了。并不怎么了解RC4。
　　看来你们对密钥的形成还不了解，这里介绍一下，由用户密码计算得到的随机数据算出100个K[] 只用到几个，主要是做随机函数种子，密钥的形成主要是对原始数组ss_my[]的随机排序

x_ = K[31];  //给随机函数Rand()做种子
y_ = K[73];
z_ = K[47];
c_ = K[91];
int n1;

        for(i=0;i<(int)(K[99]%1001);i++)//先进行K[99]%1001次原始数组ss_my[]变换  
        {
                for(j=0;j<b256;j++)                //原始数组ss_my[]的随机排序 执行一遍完成一次排序
                {
                n1=Rand()%b256;                        //Rand()是随机函数
                ch=ss_my[j];
                ss_my[j]=ss_my[n1];
                ss_my[n1]=ch;
                }
        }

        for(i=0;i<Length;i=i+b256)                //建造密钥数组 Length是明文长度
        {
                for(j=0;j<b256;j++)                //单元串随机排序
                {
                n1=Rand()%b256;                        //Rand()是随机函数
                ch=ss_my[j];
                ss_my[j]=ss_my[n1];
                ss_my[n1]=ch;
                }
//为了单元数组的边缘元素不重复
                        if(ss_my[0]==ch1)                //边缘相等情况
                        {
                        ss_my[0]=ss_my[111];        //换值
                        ss_my[111]=ch1;
                        }

                        for(j=0;j<b256;j++)                //段落接起来组成密钥
                        {
                        ss1[i+j]=ss1[i+j]+ss_my[j];        //对结果串赋值
                        }
                        ch1=ss_my[255];                //记录边缘值
        }//for(i=0;i<Length;i=i+b256)
        ss1[Length]='\0';
        ss[Length]='\0';

        strrev((char *)ss1);                                //密钥串颠倒次序

        for(i=0;i<Length;i++)                        //建立密文或恢复明文
        {
        ss[i] = ss[i] + biaozhi*ss1[i];        //加密解密    用加减法比异或灵活能多遍运算
        }
　　不知说清楚了吗？从上面可见密钥串ss1 总是饱满的没有中间出现空白的可能，因为它是由ss_my[]变换得到的，而ss_my[]是由0-255组成的。并且随机参数对密钥的形成影响大了，只要有一点变化，后面的密钥串ss1将发生很大变化。

[QUOTE=sjdkx;1209121]choday，rqqeq ：编程和密码学都是粗略的业余学习见笑了。并不怎么了解RC4。
　　看来你们对密钥的形成还不了解，这里介绍一下，由用户密码计算得到的随机数据算出100个K[] 只用到几个，主要是做随机函数种子，密钥的形成主要是对原始数组ss_my[]的随机排序

x_ = K[31];...[/QUOTE]

嗯……
还有一点，使用未经密码学论证的线性随机数是很危险的……因为他可以通过一部分已知明文进行推导（不是说完全能推出来……而是说可以缩小很大的范围）

你的密匙生成上是值得称道的，标准差为0
但是分布上……还不够
还有我们要抵抗密匙出现规律性，其实绝对均匀也是一种规律性……这个也很危险

　　

使用未经密码学论证的线性随机数是很危险的

　　你是说指使用随机函数吧？程序中在做数据交换时，直接使用一个随机函数，实际使用ss_my[]，n1、j等的代数组合也是可以的，我称为自我激励方式，但此种方式没有使用随机函数强壮，这是通过小数组模型的试验得到的结论，有可能产生重复数组，所以不要单独使用自我激励方式，或少量使用虽然对大数组的威胁不大，比较好的做法可能是两种方式混合使用。
　　密匙生成上，那里采用对一个有256个元素的数组多次排序组合成大数组，设明文长度为 N实际也可以做一个长度为N的数组，然后将256个元素均匀的充填到其中，并对整个数组做随机排序，这样局部均匀性就差些，总效果也不错，但这样大尺度的排序耗费的时间要比前者多些。

[QUOTE=sjdkx;1209203]　　
　　你是说指使用随机函数吧？程序中在做数据交换时，直接使用一个随机函数，实际使用ss_my[]，n1、j等的代数组合也是可以的，我称为自我激励方式，但此种方式没有使用随机函数强壮，这是通过小数组模型的试验得到的结论，有可能产生重复数组，所以不要单独使用自我激励方式，或少量使用虽然对大数组的...[/QUOTE]

均匀性差，重复都没关系，只要别出现趋势就行了……在单次加密中随机出现这种情况甚至还有益于保密……

你上源码吧……至少上个控制台程序……我一看这种带窗口的程序就晕~~~
但是个人认为你的程序是先生成完与明文等长密匙再加密的……这一点纯属推断
这样兼容性和可扩充性不好……而且不能反篡改……

我是来看笑话的.

rqqeq：那种东西还没有，我试试吧。早就习惯MFC了。

控制台传论坛上吧……别用悄悄话……悄悄话是好kx的……

======下面是控制台程序  （见笑了，英语 拼音 混用）
源文件是 XXXX.cpp 在VC++6.0 通过编译
运行方式
加密：
XXXX 被加密文件名  密码  1
解密：
XXXX 被解密文件名  密码  -1
==================================================
#include <stdio.h>
#include <conio.h>

#include <stdlib.h>
#include <io.h>
#include <string.h>

void HanShu(char *filename,char *mima,int biaozhi);

static int s1=1;
static int s2=1;
#define MODMULT(a,b,m,s) s= b*s; if(s<0) s+=m;
unsigned int combinedLOG(void);
void initLOG(int InitS1,int InitS2);

unsigned int x_ = 1,
                         y_ = 1,
             z_ = 1,
             c_ = 1;
unsigned int Rand();        //来自网George  Marsaglia造 周期2的124次方 = 2.1×10的37次方

int main(void)
{
char filename[240],mima[240];
int biaozhi;
        printf("请输入被加密文件名  密码  标志 : ");
        scanf("%s  %s  %d" ,&filename,&mima,&biaozhi);

//HanShu是加密解密函数 biaozhi=1 加密 biaozhi=-1 解密
        HanShu(filename,mima,biaozhi);       

        getch();                                                        //暂停
        return 0;
}

void HanShu(char *filename,char *mima,int biaozhi)
{
unsigned int K[100]={0};                                //密码相关参数
        FILE *f;
    unsigned char *ss;                                //文件容器
    unsigned char *ss1;                                //密钥容器
//        unsigned char s1[NK+1] ;                //盐池
//        unsigned char *s1;                                //盐池

unsigned char ch;
unsigned char ch1='\0';
unsigned char ss_my[256] ={
0x4f,0x1d,0x03,0xc7,0xa2,0x0d,0xd7,0xbb,0xd9,0x17,0x33,0x19,0x82,0xbf,0x9d,0x4a,0x2a,
0x51,0xe4,0x2e,0x9a,0x47,0xd4,0x3e,0x2b,0x59,0x43,0xc2,0xc9,0x92,0x00,0x07,0xf7,0xa3,
0x2c,0x10,0xc0,0x97,0xa7,0x1f,0x55,0x1c,0x21,0x49,0x58,0xa0,0xd2,0x0e,0x13,0x40,0x6c,
0xe6,0x22,0xdd,0x05,0x08,0x75,0xc6,0xd8,0x7a,0xcc,0x8d,0x37,0x70,0x8c,0x72,0x32,0x28,
0x53,0x6f,0x30,0x7b,0x80,0x6b,0x62,0xd0,0xec,0x9b,0x61,0xb9,0x52,0x93,0x74,0xb4,0xf2,
0xa9,0xe1,0x06,0xbd,0x41,0xcb,0x7f,0x36,0x25,0x35,0x46,0x77,0x54,0x73,0xf6,0x85,0x1a,
0xf0,0x26,0xb3,0x6e,0xac,0xf4,0xe2,0x90,0x88,0xce,0x71,0xcd,0x9c,0x09,0x18,0x9f,0x38,
0xb6,0x86,0x69,0xfd,0xde,0x99,0x57,0x76,0xee,0xb1,0x01,0xa8,0xd1,0x39,0x02,0x4c,0xfc,
0x94,0xef,0x7d,0x3b,0x48,0xc1,0x7e,0x24,0x15,0x5a,0x3d,0xc8,0x0b,0xaa,0x83,0x29,0xa6,
0x5d,0xe3,0x14,0x67,0xa5,0x23,0xbe,0x11,0xe5,0xab,0x79,0xda,0x8b,0xe9,0x44,0x1e,0xc3,
0xc4,0x95,0x84,0xbc,0xf9,0xcf,0x42,0xfe,0x2d,0x68,0xae,0x64,0xb0,0x04,0x16,0x4d,0x5b,
0x31,0x34,0xdb,0x0f,0x8f,0x0c,0x3c,0xf5,0xe0,0xb5,0x66,0xd6,0x5e,0x65,0xad,0x60,0xd3,
0x12,0x20,0x2f,0x87,0x6d,0x3a,0xd5,0x8e,0xb7,0x5c,0x5f,0x4e,0xf1,0xeb,0xc5,0x96,0x63,
0xdf,0xdc,0xe8,0xff,0x45,0x27,0x1b,0x4b,0xca,0x81,0x8a,0x89,0x78,0xaf,0x6a,0xfb,0x9e,
0x98,0xba,0x56,0xf8,0xa1,0x0a,0xb2,0xa4,0xb8,0x91,0xed,0x7c,0xea,0xf3,0x3f,0x50,0xe7,
0xfa};
unsigned char ss_my1[256]={0x51,0xe4,0x2e,0x9a,0x47,0xd4,0x3e,0x2b,0x59,0x43,0xc2,0xc9,0x92,0x4d,0xdf,0xfb,0xdc,0xe8,0xff,0x45,0x27,0x1b,0x4b,0xca,0x81,0x8a,0x89,0x78,0xaf,0x6a,0x2c,0x10,0xc0,0x97,0xa7,0x00,0x1f,0x55,0x1c,0x21,0x49,0x58,0xa0,0xd2,0x0e,0x13,0x40,0xb6,0x86,0x69,0xfd,0xde,0x99,0x57,0x76,0xee,0xb1,0x01,0xa8,0xd1,0x39,0x02,0x4c,0x9e,0xe6,0x22,0xdd,0x05,0x08,0x75,0xc6,0xd8,0x7a,0xcc,0x8d,0x37,0x70,0x8c,0x72,0x32,0x6c,0xa9,0x6f,0x30,0x7b,0x80,0x6b,0x62,0xd0,0xec,0x9b,0x61,0xb9,0x52,0x93,0x74,0xb4,0xfc,0x53,0xe1,0x06,0xbd,0x41,0xcb,0x7f,0x36,0x25,0x35,0x46,0x77,0x54,0x73,0xf6,0x85,0x28,0xf0,0x26,0xb3,0x6e,0xac,0xf4,0xe2,0x90,0x88,0xce,0x71,0xcd,0x9c,0x09,0x18,0x9f,0xf2,0x4f,0x1d,0x03,0xc7,0xa2,0x0d,0xd7,0xbb,0xd9,0x17,0x33,0x19,0x82,0xbf,0x9d,0x4a,0x1a,0x94,0xef,0x7d,0x3b,0x48,0xc1,0x7e,0x24,0x15,0x5a,0x3d,0xc8,0x0b,0xaa,0x83,0x29,0x38,0x5d,0xe3,0x14,0x67,0xa5,0x23,0xbe,0x11,0xe5,0xab,0x79,0xda,0x8b,0xe9,0x44,0x1e,0xa3,0x31,0x95,0x84,0xbc,0xf9,0xcf,0x42,0xfe,0x2d,0x68,0xae,0x64,0xb0,0x04,0x07,0x16,0xf7,0xc4,0x34,0xdb,0x0f,0x8f,0x0c,0x3c,0xf5,0xe0,0xb5,0x66,0xd6,0x5e,0x65,0xad,0x60,0x2a,0x12,0x20,0x2f,0x87,0x6d,0x3a,0xd5,0x8e,0xb7,0x5c,0x5f,0x4e,0xf1,0xeb,0xc5,0x96,0xa6,0x98,0xba,0x56,0xf8,0xa1,0x0a,0xb2,0xa4,0xb8,0x91,0xed,0x7c,0xea,0xf3,0x3f,0x50,0xc3,0x63,0xe7,0xfa,0xd3,0x5b};
int b256=256;

    int Length=0;
        int i,j=0;
        if((f=fopen(filename,"ab+"))==NULL)
        {printf("无法打开1");exit(0);}
        Length = filelength(_fileno(f));                //得到文件长度
    fclose(f);
        ss=new unsigned char[Length+256+1];                //文件容器
        ss1=new unsigned char[Length+256+1];        //密钥容器

        ss = (unsigned char*)calloc(Length+256, sizeof(char));   
        ss1 = (unsigned char*)calloc(Length+256, sizeof(char));   

int        k1=strlen(mima);                //k1密码串长度                               
        x_ = (mima[0]+mima[9])*mima[4]*mima[0]*mima[4];
        y_ = (mima[1]+mima[8])*mima[5]*mima[1]*mima[5];
    z_ = (mima[2]+mima[7])*mima[5]*mima[2]*mima[6];
    c_ = (mima[3]+mima[6])*mima[4]*mima[3]*mima[7];

        initLOG(Rand(),Rand());        //combinedLOG()种子设定
       
        for(i=0;i<100;i++)
        {
        x_ = combinedLOG();
        y_ = combinedLOG();
    z_ = combinedLOG();
    c_ = combinedLOG();
        initLOG(Rand(),Rand());       
        if(K[i]!=0) K[i]=(K[i]>>(x_%7));        //采用数据截断舍弃防止跟踪
        K[i] = K[i] + Rand() + combinedLOG();
        }

        if((f=fopen(filename,"ab+"))==NULL)
        {printf("无法打开2");exit(0);}
        fseek(f,0,0);
        fread(ss,Length,1,f);        //文件内容读入 ss
        fclose(f);

        x_ = K[31];                                                //算了半天只用了这 4 个参数
        y_ = K[73];
    z_ = K[47];
    c_ = K[91];
int n1;

        for(i=0;i<(int)(K[99]%1001);i++)                //先进行若干次单元数组变换
        {
                for(j=0;j<b256;j++)                //单元串随机排序
                {
                n1=Rand()%b256;
                ch=ss_my[j];
                ss_my[j]=ss_my[n1];
                ss_my[n1]=ch;
                }
        }

        for(i=0;i<Length;i=i+b256)                        //建造密钥数组
        {
                for(j=0;j<b256;j++)                //单元串随机排序
                {
                n1=Rand()%b256;
//                n1=(ss_my[n1]+j+100002)%b256;                //自激
                ch=ss_my[j];
                ss_my[j]=ss_my[n1];
                ss_my[n1]=ch;
                }
//为了单元数组的边缘元素不重复
                        if(ss_my[0]==ch1)                        //边缘相等情况
                        {
                        ss_my[0]=ss_my[111];                //换值
                        ss_my[111]=ch1;
                        }

                        for(j=0;j<b256;j++)                        //段落接起来组成密钥
                        {
                        ss1[i+j]=ss1[i+j]+ss_my[j];        //对结果串赋值
                        }
                        ch1=ss_my[255];                                //记录边缘值
        }//for(i=0;i<Length;i=i+b256)
        ss1[Length]='\0';
        ss[Length]='\0';

        strrev((char *)ss1);                                //密钥串颠倒次序

        for(i=0;i<Length;i++)                                //结果串
        {
        ss[i] = ss[i] + biaozhi*ss1[i];                //加密解密    用加减法比异或灵活能多遍运算
        }

        if((f=fopen(filename,"w"))==NULL)
        {printf("无法打开3");exit(0);}
        fclose(f);
        if((f=fopen(filename,"ab+"))==NULL)
        {printf("无法打开4");exit(0);}
        fseek(f,0,SEEK_SET);  
        fwrite(ss,Length,1,f);
        fclose(f);

        delete [] ss;
        delete [] ss1;

}

unsigned int combinedLOG(void)
{
        unsigned int z;
        MODMULT(40014,12211,2147483563,s1)
        MODMULT(40692,3791,2147483399,s2)
        z = s1 -s2;
        return z;
}

void initLOG(int InitS1,int InitS2)
{
        s1=InitS1;
        s2=InitS2;
}

unsigned int Rand()
{  
//    unsigned long long t, A = 698769069LL;  //原型
//        它采用了三种随机算法混合而成，“线性同余”，“移位轮转”和“带记忆乘法”，
//    unsigned long t, A = 698769069L;  
unsigned __int64 t,A = 698769069L;
x_ = 69069*x_+12345;  
y_ ^= (y_<<13); y_ ^= (y_>>17); y_ ^= (y_<<5);  
t = A*z_ + c_;         c_ = ((unsigned int)t >> 32);
return x_+y_+(z_=(unsigned int)t);  
}

密匙生成还可以
加密算法太弱了……最好搞复杂点

具体等这几天有空了来完整测一测……

顺便问句啊……我没仔细看，为啥有些东西算了一大堆貌似作用不大……

　　谢谢了，许多东西是的没什么用的，先搞一个精简的控制台程序。去掉那些大型随机函数，只用C语言的rand()。

要不你有兴趣的话留个qq给我吧，我们聊一聊交流交流

QQ：323241088
精简的控制台程序
/////////////////////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <io.h>
#include <string.h>
void HanShu(char *filename,char *mima,int biaozhi);        //加密解密函数
int main(void)
{
char filename[240],mima[240];
int biaozhi;
        printf("请输入被加密文件名  密码  标志 : ");
        scanf("%s  %s  %d" ,&filename,&mima,&biaozhi);
//HanShu是加密解密函数 biaozhi=1 加密 biaozhi=-1 解密
        HanShu(filename,mima,biaozhi);       
        getch();                                        //暂停
        return 0;
}
void HanShu(char *filename,char *mima,int biaozhi)
{
unsigned int K[100]={0};                        //密码相关参数
FILE *f;
unsigned char *ss;                                //文件容器
unsigned char *ss1;                                //密钥容器
unsigned char ch;
unsigned char ch1='\0';
unsigned char ss_my[256] ={0};
int b256=256;
int Length=0;
int i,j=0;
        if((f=fopen(filename,"ab+"))==NULL)
        {printf("无法打开1");exit(0);}
        Length = filelength(_fileno(f));                //得到文件长度
    fclose(f);
        ss=new unsigned char[Length+256+1];                //文件容器
        ss1=new unsigned char[Length+256+1];        //密钥容器
        ss = (unsigned char*)calloc(Length+256, sizeof(char));   
        ss1 = (unsigned char*)calloc(Length+256, sizeof(char));   
int        k1=strlen(mima);                //k1密码串长度                               
unsigned int mm[100];
        for(i=0;i<k1;i++)                        // 密码复杂化
        {
        mm[i]=mima[i]*19773161;
        mm[i]=mm[i]%(i+1373);
        mm[i]=mm[i]>>(mima[5]%7);
        mm[i]=mm[i]*mm[i]*mm[i]+101;
        }
        srand(mm[3]+mm[7]);
        srand(rand()+mm[9]);
        for(i=0;i<100;i++)
        {
        K[i] = K[i] + rand()*rand()*rand()*rand() + mm[i%10]*i + 1;
        }
        if((f=fopen(filename,"ab+"))==NULL)
        {printf("无法打开2");exit(0);}
        fseek(f,0,0);
        fread(ss,Length,1,f);        //文件内容读入 ss
        fclose(f);
        srand(K[31]+K[73]+K[47]+K[91]);
int n1=123;
                for(j=0;j<b256;j++)                //单元串赋初值
                {
                ss_my[j]=j;
                }
        for(i=0;i<(int)(K[99]%1001);i++)        //先进行若干次单元数组变换
        {
                for(j=0;j<b256;j++)                //单元串随机排序
                {
                n1=(rand()+ss_my[n1]+i*j)%b256;
                ch=ss_my[j];
                ss_my[j]=ss_my[n1];
                ss_my[n1]=ch;
                }
        }
        for(i=0;i<Length;i=i+b256)                //建造密钥数组
        {
                for(j=0;j<b256;j++)                //单元串随机排序
                {
                n1=(rand()+j+ss_my[j])%b256;
                ch=ss_my[j];
                ss_my[j]=ss_my[n1];
                ss_my[n1]=ch;
                }
//为了单元数组的边缘元素不重复
                if(ss_my[0]==ch1)                //边缘相等情况
                {
                ss_my[0]=ss_my[111];                //换值
                ss_my[111]=ch1;
                }
                for(j=0;j<b256;j++)                //段落接起来组成密钥
                {
                ss1[i+j]=ss1[i+j]+ss_my[j];        //对结果串赋值
                }
                ch1=ss_my[255];                        //记录边缘值
        }//for(i=0;i<Length;i=i+b256)
        ss1[Length]='\0';
        ss[Length]='\0';
        strrev((char *)ss1);                        //密钥串颠倒次序
        for(i=0;i<Length;i++)                        //结果串
        {
        ss[i] = ss[i] + biaozhi*ss1[i];                //加密解密    用加减法比异或灵活能多遍运算
        }
        if((f=fopen(filename,"w"))==NULL)
        {printf("无法打开3");exit(0);}
        fclose(f);
        if((f=fopen(filename,"ab+"))==NULL)
        {printf("无法打开4");exit(0);}
        fseek(f,0,SEEK_SET);  
        fwrite(ss,Length,1,f);
        fclose(f);
        delete [] ss;
        delete [] ss1;
}

可否告知加密算法，目前的加密体制破解都是基于加密算法已知，密钥未知的前提的

63楼就是加密算法的C语言描述。

火钳刘翔。貌似跟那个2011年的台湾大哥一样

无聊！！！