请问怎样加密一个字符窜，方法越简单越好。(50分)

[]

对字符串进行异或(xor)就可以加密了,再做一次就可解密

地球人都知道，还算加密么。

你不是说最简单的么,这就是最简单的,要不你就直接用MD5/DES之类的啊

对字符串先作移位处理（移位的个数做为参数1）
再对字符串进行异或(xor)
再对字符串作移位处理（移位的个数做为参数2）

这样的话，方法简单，破解就有点麻烦了。

数据加密方法越简单,破起来就越简单,只要知道你的加密方法,就很容易了.所以你提到的问题本来就是矛盾的.
你的问题,包括上边的人提到的方法,加密方法似乎都是对字符窜进行变换处理,简单的说,这样的方法是很容易破的.建议用一种方法,对字符串的长度也进行修改.
还有顺便提一下,加密几个要素.源码,密钥,加密方法.
上面说到的是加密方法,并没有用到密钥.
要不你搞个密钥,每次都用密钥,按照一定算法处理源码.加密的数据,通过相反的解密方法,就恢复成源码.这样的方法,密钥不公开,加密方法公开,只要密钥不错,而且管理完善,经常改,防止被破译什么的,就问题不大.
至于加密的方法很多,例如ABCDEFGHIJK是源码,用rinson作密钥,A与r按位做异或,B与i作异或,类推.到了第7个字母G又按r来作异或.然后每几位再加几个随机字符什么的,例如每5位加'A'.这样长度变化,每个字母也变化.就不容易破.
解密的时候,先去掉多出来的A,然后再与加密方法一样作异或.
我们来讨论下这种加密方法 的安全性.安全的保证完全就落在密钥的安全上.
密钥安全,通过猜测是不容易得到源码的.假如是一个知道加密方法 的人,虽然不知道源码,但是可以知道源码的长度.
在不知道加密方法,密钥的情况下,可以尝试几种最简单的加密方法,没成功,也就没办法了.除非遍历所有可能.

请问怎样xor

ReverseString 用这个函数 最简单了

异或的问题,自己查下C语言帮助吧

var
a, b, c, d: Char;
begin
a := 'a';
b := 'b';
c := a xor b;
ShowMessage(c);
d := c xor b;
ShowMessage(d);
d := c xor a;
ShowMessage(d);
end;

随便找的一个：

unit DesUnit;

interface

procedure DES(var Input; var Output; var Key; Encrypt : Boolean);

implementation

procedure DES(var Input; var Output; var Key; Encrypt : Boolean);

const
IP : array [1..64] Of Byte = (58,50,42,34,26,18,10,2,
60,52,44,36,28,20,12,4,
62,54,46,38,30,22,14,6,
64,56,48,40,32,24,16,8,
57,49,41,33,25,17, 9,1,
59,51,43,35,27,19,11,3,
61,53,45,37,29,21,13,5,
63,55,47,39,31,23,15,7);

InvIP : Array [1..64] Of Byte = (40, 8,48,16,56,24,64,32,
39, 7,47,15,55,23,63,31,
38, 6,46,14,54,22,62,30,
37, 5,45,13,53,21,61,29,
36, 4,44,12,52,20,60,28,
35, 3,43,11,51,19,59,27,
34, 2,42,10,50,18,58,26,
33, 1,41, 9,49,17,57,25);

E : Array [1..48] Of Byte = (32, 1, 2, 3, 4, 5,
4, 5, 6, 7, 8, 9,
8, 9,10,11,12,13,
12,13,14,15,16,17,
16,17,18,19,20,21,
20,21,22,23,24,25,
24,25,26,27,28,29,
28,29,30,31,32, 1);
P : Array [1..32] Of Byte = (16, 7,20,21,
29,12,28,17,
1,15,23,26,
5,18,31,10,
2, 8,24,14,
32,27, 3, 9,
19,13,30, 6,
22,11, 4,25);
SBoxes : Array [1..8,0..3,0..15] Of Byte =
(((14, 4,13, 1, 2,15,11, 8, 3,10, 6,12, 5, 9, 0, 7),
( 0,15, 7, 4,14, 2,13, 1,10, 6,12,11, 9, 5, 3, 8),
( 4, 1,14, 8,13, 6, 2,11,15,12, 9, 7, 3,10, 5, 0),
(15,12, 8, 2, 4, 9, 1, 7, 5,11, 3,14,10, 0, 6,13)),

((15, 1, 8,14, 6,11, 3, 4, 9, 7, 2,13,12, 0, 5,10),
( 3,13, 4, 7,15, 2, 8,14,12, 0, 1,10, 6, 9,11, 5),
( 0,14, 7,11,10, 4,13, 1, 5, 8,12, 6, 9, 3, 2,15),
(13, 8,10, 1, 3,15, 4, 2,11, 6, 7,12, 0, 5,14, 9)),

((10, 0, 9,14, 6, 3,15, 5, 1,13,12, 7,11, 4, 2, 8),
(13, 7, 0, 9, 3, 4, 6,10, 2, 8, 5,14,12,11,15, 1),
(13, 6, 4, 9, 8,15, 3, 0,11, 1, 2,12, 5,10,14, 7),
( 1,10,13, 0, 6, 9, 8, 7, 4,15,14, 3,11, 5, 2,12)),

(( 7,13,14, 3, 0, 6, 9,10, 1, 2, 8, 5,11,12, 4,15),
(13, 8,11, 5, 6,15, 0, 3, 4, 7, 2,12, 1,10,14, 9),
(10, 6, 9, 0,12,11, 7,13,15, 1, 3,14, 5, 2, 8, 4),
( 3,15, 0, 6,10, 1,13, 8, 9, 4, 5,11,12, 7, 2,14)),

(( 2,12, 4, 1, 7,10,11, 6, 8, 5, 3,15,13, 0,14, 9),
(14,11, 2,12, 4, 7,13, 1, 5, 0,15,10, 3, 9, 8, 6),
( 4, 2, 1,11,10,13, 7, 8,15, 9,12, 5, 6, 3, 0,14),
(11, 8,12, 7, 1,14, 2,13, 6,15, 0, 9,10, 4, 5, 3)),

((12, 1,10,15, 9, 2, 6, 8, 0,13, 3, 4,14, 7, 5,11),
(10,15, 4, 2, 7,12, 9, 5, 6, 1,13,14, 0,11, 3, 8),
( 9,14,15, 5, 2, 8,12, 3, 7, 0, 4,10, 1,13,11, 6),
( 4, 3, 2,12, 9, 5,15,10,11,14, 1, 7, 6, 0, 8,13)),

(( 4,11, 2,14,15, 0, 8,13, 3,12, 9, 7, 5,10, 6, 1),
(13, 0,11, 7, 4, 9, 1,10,14, 3, 5,12, 2,15, 8, 6),
( 1, 4,11,13,12, 3, 7,14,10,15, 6, 8, 0, 5, 9, 2),
( 6,11,13, 8, 1, 4,10, 7, 9, 5, 0,15,14, 2, 3,12)),

((13, 2, 8, 4, 6,15,11, 1,10, 9, 3,14, 5, 0,12, 7),
( 1,15,13, 8,10, 3, 7, 4,12, 5, 6,11, 0,14, 9, 2),
( 7,11, 4, 1, 9,12,14, 2, 0, 6,10,13,15, 3, 5, 8),
( 2, 1,14, 7, 4,10, 8,13,15,12, 9, 0, 3, 5, 6,11)));

PC_1 : Array [1..56] Of Byte = (57,49,41,33,25,17, 9,
1,58,50,42,34,26,18,
10, 2,59,51,43,35,27,
19,11, 3,60,52,44,36,
63,55,47,39,31,23,15,
7,62,54,46,38,30,22,
14, 6,61,53,45,37,29,
21,13, 5,28,20,12, 4);

PC_2 : Array [1..48] Of Byte = (14,17,11,24, 1, 5,
3,28,15, 6,21,10,
23,19,12, 4,26, 8,
16, 7,27,20,13, 2,
41,52,31,37,47,55,
30,40,51,45,33,48,
44,49,39,56,34,53,
46,42,50,36,29,32);

ShiftTable : Array [1..16] Of Byte = (1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1);

Var
InputValue : Array [1..64] Of Byte;
OutputValue : Array [1..64] Of Byte;
RoundKeys : Array [1..16,1..48] Of Byte;
L, R, FunctionResult : Array [1..32] Of Byte;
C, D : Array [1..28] Of Byte;

Function GetBit (Var Data; Index : Byte) : Byte;

Var
Bits : Array [0..7] Of Byte ABSOLUTE Data;

Begin
Dec (Index);
If Bits[Index DIV 8] And (128 SHR (Index MOD 8))>0 then GetBit:=1 Else GetBit:=0;
End;{GetBit}

Procedure SetBit (Var Data; Index, Value : Byte);

Var
Bits : Array [0..7] Of Byte ABSOLUTE Data;
Bit : Byte;

Begin
Dec (Index);
Bit:=128 SHR (Index MOD 8);
Case Value Of
0 : Bits[Index DIV 8]:=Bits[Index DIV 8] And (Not Bit);
1 : Bits[Index DIV 8]:=Bits[Index DIV 8] Or Bit;
End;
End;{SetBit}

Procedure F (Var FR, FK, Output);

Var
R : Array [1..48] Of Byte ABSOLUTE FR;
K : Array [1..48] Of Byte ABSOLUTE FK;
Temp1 : Array [1..48] Of Byte;
Temp2 : Array [1..32] Of Byte;
n, h, i, j, Row, Column : Integer;
TotalOut : Array [1..32] Of Byte ABSOLUTE Output;

Begin
For n:=1 to 48 Do Temp1[n]:=R[E[n]] Xor K[n];
For n:=1 to 8 Do Begin
i:=(n-1)*6;
j:=(n-1)*4;
Row:=Temp1[i+1]*2+Temp1[i+6];
Column:=Temp1[i+2]*8 + Temp1[i+3]*4 + Temp1[i+4]*2 + Temp1[i+5];
For h:=1 to 4 Do Begin
Case h Of
1 : Temp2[j+h]:=(SBoxes[n,Row,Column] And 8) DIV 8;
2 : Temp2[j+h]:=(SBoxes[n,Row,Column] And 4) DIV 4;
3 : Temp2[j+h]:=(SBoxes[n,Row,Column] And 2) DIV 2;
4 : Temp2[j+h]:=(SBoxes[n,Row,Column] And 1);
End;
End;
End;
For n:=1 to 32 Do TotalOut[n]:=Temp2[P[n]];
End;{F}

Procedure Shift (Var SubKeyPart);

Var
SKP : Array [1..28] Of Byte ABSOLUTE SubKeyPart;
n, b : Byte;

Begin
b:=SKP[1];
For n:=1 to 27 Do SKP[n]:=SKP[n+1];
SKP[28]:=b;
End;{Shift}

Procedure SubKey (Round : Byte; Var SubKey);

Var
SK : Array [1..48] Of Byte ABSOLUTE SubKey;
n, b : Byte;

Begin
For n:=1 to ShiftTable[Round] Do Begin
Shift (C);
Shift (D);
End;
For n:=1 to 48 Do Begin
b:=PC_2[n];
If b<=28 then SK[n]:=C Else SK[n]:=D[b-28];
End;
End;{SubKey}

Var
n, i, b, Round : Byte;
Outputje : Array [1..64] Of Byte;
K : Array [1..48] Of Byte;
fi : Text;

Begin
For n:=1 to 64 Do InputValue[n]:=GetBit (Input,n);
For n:=1 to 28 Do Begin
C[n]:=GetBit(Key,PC_1[n]);
D[n]:=GetBit(Key,PC_1[n+28]);
End;
For n:=1 to 16 Do SubKey (n,RoundKeys[n]);
For n:=1 to 64 Do If n<=32 then L[n]:=InputValue[IP[n]] Else R[n-32]:=InputValue[IP[n]];
For Round:=1 to 16 Do Begin
If Encrypt then
F (R,RoundKeys[Round],FunctionResult)
Else
F (R,RoundKeys[17-Round],FunctionResult);
For n:=1 to 32 Do FunctionResult[n]:=FunctionResult[n] Xor L[n];
L:=R;
R:=FunctionResult;
End;
For n:=1 to 64 Do Begin
b:=InvIP[n];
If b<=32 then OutputValue[n]:=R Else OutputValue[n]:=L[b-32];
End;
For n:=1 to 64 Do SetBit (Output,n,OutputValue[n]);
End;

end.

加密方法简单不等于无用，因为人一提到加密就条件反射地想到异或，加密和不加密又有什么两样呢。
goddy的想法和我一样，ReverseString这个函数你为什么不早说呢，我用循环编了一个 ，
不过要用中文字符串好些，反过来就是乱码，用英文就容易看出来。

你到底是要加密，还是要数据隐藏，说清楚～～～～

用 strtobase64
与 base64tostr

delphi自己的单元encddecd

这是我学习了大家的经验后自编了一个加密的小函数，请大家看看：
procedure encrypt(var str: string; key: string);
var
i, j: longint;
strlen, keylen: longint;
begin
strlen := Length(str);
keylen := Length(key);
i := 0;
repeat
for j := 1 to keylen do
if (i + j) <= strlen then
str[i + j] := chr(ord(str[i + j]) xor ord(key[j]));
inc(i, keylen);
until i >= strlen;
end;
解密也用同样的函数。

学习学习

发现一个比较好且简单和安全的方法:

用Delphi实现文本加密
我们编程时常常要用到文本加密，例如做一个多用户的程序，通常需要将用户名和口令加
密保存，这样程序便具有了更高的安全性。对文本的加密方法有很多种，下面我就向大家
介绍比较常用的一种方法。

编程思路：

该种加密方法是逐一取出文本内的字符，按照一定的规律对字符的ASCII码进行运算，
运算后再把ASCII码转换为字符，得到的字符串即为加密后的文本。

编程过程：

一、新建一个窗体Form1，在窗体上加入下列控件： Edit1、Edit2、 Edit3、Edit4、
Label1、Label2、Label3、Label4、Button1、Button2、Button3。把Label1、Label2、Label3、Label4的“Caption”属性分别改为“加密前”、“加密后”、“解密前”、“解密后”，同时把Button1、Button2、Button3的“Caption”属性分别改为“加密”、“解密”、“退出”。

二、编写加密和解密的函数

1.编写加密函数

加密函数的输入参数和输出参数都是一个字符串。该函数加密的密钥是由变量i、j组成的代数式j^2- i^2+3。其中j代表输入的字符串长度，i代表字符处于字符串内的位数。通过该代数式计算得到变量k，k即是输出字符串中对应于输入字符串第i位字符的ASCII码偏移量。从上面的代数式可以看出：同样一个字符，在字符串中的位置不一样或所在字符串的长度不一样，加密后得到的结果就不一样，因此算法虽简单，但也不易破解。

加密函数的代码如下：

function TForm1.encrypt(s:string):string;
var
i,j,k:integer;
s1:string;
begin
s1:='';
j:=length(s);
for i:=1 to j do
begin
k:=j*j-i*i+3;
s1:=s1+chr(ord(s)+k);
end;
result:=s1
end;

2.编写解密函数

解密运算即是加密的反运算，根据上面的加密函数，我们编写如下解密函数：

function TForm1.decrypt(s:string):string;
var
i,j,k:integer;
s1:string;
begin
s1:='';
j:=length(s);
for i:=1 to j do
begin
k:=j*j-i*i+3;
s1:=s1+chr(ord(s)-k);
end;
result:=s1
end;

三、引用加密和解密函数，进行加密解密

1.在Button1的Onclick事件中加入以下代码，引用加密函数进行加密：

procedure TForm1.Button1Click(Sender: TObject);
var
ss:string;
begin
ss:=Edit1.Text;
Edit2.Text:=encrypt(ss);
end;

2.在Button2的Onclick事件中加入以下代码，引用解密函数进行解密：

procedure TForm1.Button2Click(Sender: TObject);
var ss:string;
begin
ss:=Edit3.Text;
Edit4.Text:=decrypt(ss);
end;
程序编写完成后，我们可以随意输入几个字符，看看程序的运行结果。

综上所述，这是一种常用的文本加密的方法，简便易用，你也可以根据需要灵活地改变密钥。此种加密方法非常适用于小型文本或字符串的加密。

注：以上程序在Windows 2000、Delphi6.0下调试通过。"

[]

[]