文章出处:白云黄鹤★


发信人: fyd (丁丁), 信区: Encrypt
标  题: WPS文件的解密与加密
发信站: 武汉白云黄鹤站 (Mon Dec  8 14:11:23 1997) , 站内信件

标题：WPS文件的解密与加密
期版：月刊第3期  PC 应用
作者：程学浦
    5.0版以上的金山DOS软件, 在WPS的菜单中安排了"设置密码"的
选项,  使用户可以通过简单的操作给需要保密的文件加密。但是,
这一功能有时侯也会给我们带来一些麻烦。例如, 在遗忘密码的时侯
, 或者是由于误操作,  输入了自己无法确认的密码等等,都会造成难
以直接读取自己的文件。本文介绍的有关知识和方法, 将可以帮您解
决这一问题, 并告诉您怎样更有效地给自己的WPS文件加密。

    一、WPS文件的结构和加密过程
    WPS用户文件的前1024个字节(偏移地址为0000H-03FFH处)是存放
文件的各种设置、存盘前的各种状态等信息的,其中 02DDH-02E4H的
8个字节用于存放密码,文件的正文存放在0400H以后的单元中。
    对文件的加密过程如下: 用户选择 "设置密码" 的功能后, WPS
允许用户输入1～8个字符为密码; 对于用户键入的每一个字符的ASCI
I码, WPS首先将其高 4位与低 4位交换位置,
再对其按位取反, 然后依次存入从 02DDH开始的单元中。例如, 当


用户键入的第 1个字符为"A" 时, "A" 的ASCII码为41H, WPS 先将其
换位为 14H( 对应的二进制代码为00010100); 再按位取反后为: EBH
(对应的二进制代码为: 11101011); 然后将 EBH存入02DDH单元中。
每次文件存盘的时候, WPS都要事先检查02DDH- 02E4H 单元的内容,
如果不全为0, 则表明用户给文件设置了密码, WPS将用这8 个单元的
内容对文件的正文进行加密操作。方法是:从0400H单元开始, 每8个
字节为一组, 依次与密码区的 8 个字节进行异或操作, 直至文件结
束; 然后再执行存盘。如果WPS检查02DDH-02E4H单元的内容全为 0时
, 则不做异或操作, 将文件直接存盘。

    二、解密的方法
    知道了以上的原理, 就很容易解决遗忘密码等类问题了。
    首先, 用DEBUG将需要解密的文件调入内存。当文件名为:Filena
me.wps时, 键入以下的命令行即可:
    DEBUG  Filename.wps ↓
    其中给出存放DEBUG.COM文件的位置(通常是存放在DOS子目录中
的); 给出存放 Filename.wps 文件的位置。如果(或)是当前路径,
可在命令行中将该项省略。
    上述指令执行后, 屏幕上将出现闪动的"-" 符号,  这是 DEBUG
的提示符。 由于DEBUG调入内存的文件是从偏移地址0100H处开始存
放的, 所以此时密码区的偏移地址为03DDH-03E4H。我们可以用"D"指
令查看其密码的内容; 在"-"提示符下键入:


    -D 3DD↓
    假如屏幕上显示的内容如下:
    55AA:03D0EB DB CB...
    55AA:03E000 00 00 00 00 00 E0 01-D0 01 C0 01 B0 01 A0 01
..........
    ......
    ……
    我们可以看到该文件中共有三个密码字符, 其16进制代码为: "E
B、DB、CB"。把每个字节的高4位与低4位交换位置后得到"BE、BD、B
C"; 再算出用FFH 分别减去这三个数字的差(等于按位取反的操作),
可得到"41、42、43", 查ASCII码表可知,  它们分别是"A、B、C"三
个字符的ASCII码。
    用"Q"指令可退出DEBUG。启动 WPS 软件, 调用Filename.wps文
件, 当 WPS 要求输入密码时, 键入"ABC"即可进入该文件了。

    三、加密的方法
    由上文可知, WPS软件所提供的加密方法, 是很容易被别人破译
的。 为了能更有效地保护自己需要加密的文件, 可以采用下面介绍
的方法。
    首先选择好几个自己最熟悉, 而别人又难以得知的字符作为密码
( 例如自己的挚友或亲属姓名的拼音字头等)。
    对于需要加密的文件, 先用WPS提供的方法加密; 存盘后, 再用D


用"D"指令查看变换后的密码内容, 将其记录下来; 然后用"E"  指
令把输入的密码全都改写为00H; 用"W"指令存盘; 最后, 用"Q"指令
退出即可。例如,  当输入的密码为三个字符时, 可在"-"提示符下,
依次键入以下的命令行:
    -E 3DD 00 00 00 ↓
    -W↓
    -Q↓
    经过以上处理的文件, 如果有外人调用时, WPS不询问密码,但显
示出来的该文件内容将是一堆难以辨认的杂乱符号 (因为WPS 已对正
文部分进行过异或操作 ) 。 企图用DEBUG窥视密码的人, 也只能看
到00H而无法破译。当自己需要调用该文件时, 可以首先用DEBUG的"E
"指令按照原来记录的内容将密码复原; 然后再启动 WPS, 回答密码,
调出原文。
    (作者地址:北京朝外白家庄西里机械工程学院,100020;收稿日期
:1995.12)

--

发信人: LaoHong (批处理中), 信区: Program
标  题: 操作系统调度
发信站: BBS汕头大学郁金香站 (Sun Sep  9 18:44:23 2001), 转信
//操作系统调度
#include
#include
#include
#include
#include
#define ed NULL
void diaodu(void);
void shifang(int);
typedef struct node_type{//内存链
int start,len,fenp;
struct node_type *next;
}link;
typedef struct dl_type{//队列
int ip,len;
}dls;
dls dl[20];//定义20个元素的队列
int dlz=0;
link *h,*p,*q;
link *h,*p,*q;
int size,num;//定义内存总大小和进程数目
ofstream Output("output2.txt");
int main()
{
char* ch=" ";
int count;// 定义循环变量
int zj=0;
ifstream Input("read2.txt");
Input>>size>>num;
cout< {
Input>>dl[dlz].ip>>dl[dlz].len;
cout< {
Input>>zj;
cout< exit(1);
}
}
cin>>count;
}
void diaodu()
{ int i,l,ff=0;
for(i=0;i {
{
p=h;
do
{
if(p->len>=dl[i].len&&p->fenp==0)
{
q=(link*)malloc(sizeof(link));
q->next=p->next;
q->start=p->start+dl[i].len;
q->len=p->len-dl[i].len;
q->fenp=0;
p->fenp=dl[i].ip;
p->len=dl[i].len;
p->next=q;
cout<<" "<fenp<<" "<start< Output<fenp<<" "<start< for(l=i;l {
dl[l].ip=dl[l+1].ip;
dl[l].len=dl[l+1].len;
}
dl[l+1].ip=0;
dl[l+1].len=0;
dl[l+1].len=0;
dlz--;
ff=1;
}
else p=p->next;
}while(p!=ed&&ff==0);
}
}
void shifang(int zj)
{
link* w;
int ff=0,i,l;
p=h;
q=h;
do
{
if(p->fenp==zj)
{
ff=1;
if(p==h&&p->next!=ed)
{
w=p->next;
if(w->fenp==0)
if(w->fenp==0)
{
p->next=w->next;
p->len=p->len+w->len;
p->fenp=0;
free(w);
}
else
{
p->fenp=0;
}
}
if(p!=h&&p->next==ed)
{
q=h;
while(q->next!=p)
q=q->next;
if(q->fenp==0)
{
q->next=p->next;
q->len=q->len+p->len;
q->fenp=0;
free(p);
free(p);
}
else
{
p->fenp=0;
}
}
if(p!=h&&p->next!=ed)
{
q=h;
while(q->next!=p)
q=q->next;
w=p->next;
if(q->fenp==0&&w->fenp==0)
{
q->next=w->next;
q->len=q->len+p->len+w->len;
q->fenp=0;
free(p);
free(w);
}
else if(q->fenp==0&&w->fenp!=0)
{
{
q->next=p->next;
q->len=q->len+p->len;
q->fenp=0;
free(p);
}
else if(q->fenp!=0&&w->fenp==0)
{
p->next=w->next;
p->len=p->len+w->len;
p->fenp=0;
free(w);
}
else
{
p->fenp=0;
}
}
}
else p=p->next;
}while(p!=ed&&ff==0);
//如果new还在队列里
if(ff==0)
if(ff==0)
{
for(i=0;i {
if(zj==dl[i].ip)
{
for(l=i;l {
dl[l].ip=dl[l+1].ip;
dl[l].len=dl[l+1].len;
}
dl[l+1].ip=0;
dl[l+1].len=0;
dlz--;
}
}
}
}
--
--

发信人: Marslv (梦幻人生), 信区: Program
标  题: 傅立叶变换的源程序(转)
发信站: BBS汕头大学郁金香站 (Sun Oct 22 00:38:57 2000), 转信
发信人: bury (颓废的埋葬), 信区: Programming
标  题: 傅立叶变换的源程序
发信站: 逸仙时空 Yat-sen Channel (Wed Apr 19 13:30:18 2000), 站内信件
发信人: pinacle (Elton), 信区: Programming
标  题: Re: 谁有傅立叶变换的原程序！急需！！！！
发信站: BBS 水木清华站 (Thu Jul 22 10:10:28 1999)
#include<stdio.h>
#include<math.h>
#include<float.h>
#include<malloc.h>
#include<stdlib.h>
void initial(int num_data, float* real, float* inm);
void enter_data(int num_data, float* data);
void wave_sin(int num_data, float* data);
void wave_cos(int num_data, float* data);
void decay(int num_data, float* data);
void random(int num_data, float* data);
void table(int num_data, char flag,
     float* tablesin, float* tablecos);
void DFT(int num_data, char flag, float* real, float* img,
   float* tablesin, float* tablecos);
float period;
void main()
{
int num_data;
int i;
char flag;
float *real, *img;
float *tablecos, *tablesin;
printf("PLEASE INPUT SAMPLE PERIOD(Second):");
scanf("%f", &period);
printf("PLEASE INPUT SAMPLE POINT NUMBER:");
scanf("%d", &num_data);
fflush(stdin);
printf("DFT OR IDFT (D/I):");
flag=getchar();
if(flag=='d') flag='D';
if(flag=='i') flag='I';
printf("\n");
real=(float*)malloc(sizeof(float)* num_data);
img=(float*)malloc(sizeof(float)* num_data);
tablesin=(float*)malloc(sizeof(float)* num_data);
tablecos=(float*)malloc(sizeof(float)* num_data);
initial(num_data, real, img);
table(num_data, flag, tablesin, tablecos);
DFT(num_data, flag, real, img, tablesin, tablecos);
for(i=0; i<num_data; i++)
  printf("%8d real=%12.6f img=%12.6f\n",
    i, real[i], img[i]);
free(real);
free(img);
free(tablesin);
free(tablecos);
}
void initial(int num_data, float* real, float* img)
{
int n;
for(n=0; n<num_data; n++)
{
  real[n]=0;
  img[n]=0;
}
printf("INITIAL REAL DATA\n");
enter_data(num_data, real);
printf("\nINITIAL IMG DATA\n");
enter_data(num_data, img);
}
void enter_data(int num_data, float* data)
{
int selection;
printf("FUNCTION SELECTION\n");
printf("1-----AMPLITUDE*SIN(2*3.1415926
  *FREQUENCY*PERIOD*T)\n");
printf("2-----AMPLITUDE*COS(2*3.1415926
  *FREQUENCY*PERIOD*T)\n");
printf("3-----AMPLITUDE*EXP(-PERIOD)\n");
printf("4-----DATA=0\n");
printf("5-----ENTER DATA\n");
printf("ENTER SELECTION---");
scanf("%d", &selection);
switch(selection)
{
case 1:wave_sin(num_data, data);break;
case 2:wave_cos(num_data, data);break;
case 3:decay(num_data, data);break;
case 4:break;
case 5:random(num_data, data);break;
}
}
void wave_sin(int num_data, float* data)
{
float amplitude, frequency, c;
int n;
printf("PLEASE INPUT AMPLITUDE OF WAVE:\n");
scanf("%f", &amplitude);
printf("PLEASE INPUT FREQUENCY OF WAVE(Hz):\n");
scanf("%f", &frequency);
for(n=0; n<num_data; n++)
{
  c=2*3.1415926*frequency*period*n;
  data[n]=(float)(amplitude*sin(c));
}
}
void wave_cos(int num_data, float* data)
{
float amplitude, frequency, c;
int n;
printf("PLEASE INPUT AMPLITUDE OF WAVE:\n");
scanf("%f", &amplitude);
printf("PLEASE INPUT FREQUENCY OF WAVE(Hz):\n");
scanf("%f", &frequency);
for(n=0; n<num_data; n++)
{
  c=2*3.1415926*frequency*period*n;
  data[n]=(float)(amplitude*cos(c));
}
}
void decay(int num_data, float* data)
{
float amplitude, c;
int n;
printf("PLEASE INPUT AMPLITUDE OF WAVE\n");
scanf("%f", &amplitude);
for(n=0; n<num_data; n++)
{
  c=-period*n;
  data[n]=(float)(amplitude*exp(c));
}
}
void random(int num_data, float* data)
{
int n;
for(n=0; n<num_data; n++)
{
  printf("PLEASE INPUT DATA[%d]:", n);
  scanf("%f", &data[n]);
}
}
void table(int num_data, char flag,
     float* tablesin, float* tablecos)
{
float w, c;
int n;
w=(float)(8*atan(1)/num_data);
if(flag=='D') w=-w;
for(n=0; n<num_data; n++)
{
  c=w*n;
  tablecos[n]=(float)cos(c);
  tablesin[n]=(float)sin(c);
}
}
void DFT(int num_data, char flag, float* img,
   float* tablesin, float* tablecos)
{
int i, j, L;
float *result_r, *result_i;
result_r=(float*)malloc(sizeof(float)*num_data);
result_i=(float*)malloc(sizeof(float)*num_data);
for(i=0; i<num_data; i++)
{
  result_r[i]=0;
  result_i[i]=0;
  for(j=0; j<num_data; j++)
  {
   L=i*j%num_data;
   result_r[i]=result_r[i]+real[j]*tablecos[L]
    +img[j]*tablesin[L];
   result_i[i]=result_i[i]+img[j]*tablecos[L]
    -real[j]*tablesin[L];
  }
}
if(flag=='D')
{
  for(i=0; i<num_data; i++)
  {
   real[i]=result_r[i];
   img[i]=result_i[i];
  }
}
else if(flag=='I')
{
  for(i=0; i<num_data; i++)
  {
   real[i]=result_r[i]/num_data;
   img[i]=result_i[i]/num_data;
  }
}
free(result_r);
free(result_i);
}
--

发信人: windring (DLL), 信区: Programming
标  题: Re: 求教五子棋算法，如何算多步棋！
发信站: BBS 水木清华站 (Fri Dec 14 09:34:13 2001)
下面是黑白棋的设计思想，五子棋要复杂很多，不过类似的思考容易得到
////////////////////////////////////////////////////////
设计思路:
   从棋盘的当前状态构造博奕树，到达终局状态计算状态分，并回归到当前状态，以求
出最
有利的一步(部分回溯值最大的一个子结点)。
术语:
     棋手   计算机方
  对手   计算机的对手
要点:
    一.终局状态
    1.棋局已结束
    2.当前颜色已无处可下子
    3.博奕树的深度已到指定的深度
    二.博奕树的构造方法
    采用深度优先的方法节省构造过程中的内存使用,构造过程使用堆栈空间存储子节点
，
    已完成构造的分枝可抛弃，以达到节省内存(使用递归程序)。
      算法简单描述如下：
       如果当前棋局为终局状态，则返回状态分
    从当前棋局的状态出发,找出一个可走的步数,试走此部,新状态扩展为当前棋局的
    一个子结点
    此子结点做为新的当前状态递归调用  (此过程中可加入α-β裁减)
        思考：如果采用循环代替递归，保存所有已构造的节点，在下一次构造博奕树
时本次构造
        的节点可能重复利用，节省构造时间。
    三.构造过程的α-β裁减
    1.α裁减
       在考虑轮到棋手下棋的一个亲节点及轮到对手下棋的一个子节点时，
    如果该子节点的数值已经小于或等于其亲节点的回溯值，
    那么就不需要对该节点或者其后续节点做更多的处理了。
    计算的过程可以直接返回到亲节点上。
    2.β裁减
       在考虑轮到对手下棋的一个亲节点及轮到棋手下棋的一个子节点时，
    如果该子节点的部分回溯值已经大于或等于其亲节点的部分回溯值，
    那么就不需要对该子节点或者其后裔节点做更多的处理了。
    计算过程可以直接返回到亲节点上。
    四.棋局的状态估值函数
    此函数量化的方法描述棋局某一状态下某一方棋子的形式,对棋局形式的正确分析直
接关系到
    计算机棋力的高低
    考虑黑白棋的规则,棋局结速束时,棋盘上哪一方的棋子多哪一方则获胜,简单的状态
估值方法是
    对某一状态下棋子的个数做为状态分,但棋盘上很多棋子都可能被对方吃掉,所以比
较好的方法是
    计算棋盘上所有不可能被对方吃掉的棋子做为状态分.
    棋盘上任一个棋子是否能被对方吃掉由它四个方向其它棋格的状态决定,
    四个方向为:
     左上到右下的斜线(BD_AX)
     右上到左下的斜线(FD_AX)
     水平方向(H_AX)
     垂直方向(V_AX)
       一个棋子如果在这四个方向上都受保护,我们则认为此棋子不可能被对方吃掉,
    一个棋子是否在某一个方向上受保护,可由下面的方法判断：
          当出现下面的两种情况之一时，我们可以认为此棋子在此方向上受保护
          1.此方向上与此棋子相联的已方棋子已到达边界
    2.此方向上与此棋子相联的已方棋子两边没有空格子(对方棋子，或边界)
   由此知,棋盘空时,四个角上的棋子一定是不可被吃的棋子
         状态分的计分方法:
      1.不可被吃掉的棋子计四分
   2.三个方向受保护的棋子计三分
   3.两个方向上受保护的棋子计两分
   4.一个方向上受保护的棋子计一分
         另由于角的重要性下面的情况出现时被视为危险状态,将会被减分
          角边上有已方棋子,但在到达角的方向上没有受到保护,则减分
数据结构:
每一个棋格用一个字节记,低两位记录棋子颜色,高四位记录此子在四个方向上是否受保
护的情况
如果一个棋格为空,则对应字节为0x0,为避免边界检查，在棋盘四周加一边框，边框对应
值为0xFF
...
.................
【 在 tianyake (一半郁闷，一半快乐) 的大作中提到: 】
: 想至少望后推五步，可是反馈时间要求小于二十秒，怎样才能做到迅速抛弃
: 一些可能，从而达到这一效果
--

发信人: raphaelzl (小飞熊~笨笨), 信区: Programming
标  题: Re: 那里可以搞到C语言的CRC算法
发信站: BBS 水木清华站 (Tue Apr 17 10:42:25 2001)
#include<stdio.h>
#include<windows.h>
#define IN_FILE ".\\crc.in"
#define MAX_IN_FILE_SIZE 8192
#define MIN_IN_FILE_SIZE 1024
WORD CRC(unsigned char *info, DWORD len)
{
  WORD acc;
  unsigned char i;
  acc=0;
  while (len--) {
    acc=acc^(((unsigned int)(*info))<<8);
    info++;
    for (i=8;i>0;i--)
      if (acc&0x8000) acc=(acc<<1)^0x1021;
      else acc<<=1;
  }
  return acc;
}
void main()
{
HANDLE hFile = INVALID_HANDLE_VALUE;
char ch_in[MAX_IN_FILE_SIZE];
DWORD dwRW;
WORD  result;
hFile = CreateFile(IN_FILE, GENERIC_READ, 0,
   NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if(hFile == INVALID_HANDLE_VALUE){
  printf("LastError : %d\n", GetLastError());
  exit(1);
}
if(GetFileSize(hFile, NULL) > MAX_IN_FILE_SIZE ||
  GetFileSize(hFile, NULL) < MIN_IN_FILE_SIZE){
  printf("FileSize > %d or FileSize < %d",
   MAX_IN_FILE_SIZE, MIN_IN_FILE_SIZE);
  CloseHandle(hFile);
  exit(1);
}
ReadFile(hFile, ch_in, MAX_IN_FILE_SIZE, &dwRW, NULL);
CloseHandle(hFile);
result = CRC(ch_in, dwRW);
printf("The CRC code is : %x\n", result);
}
CRC32的一种
【 在 lightlk (天下最懒) 的大作中提到: 】
: rt
--
  ☆★☆★☆★☆★☆★☆★☆★☆★☆★
       真的好想拍拍小翅膀，
           就飞上那晴朗的天空。
  ☆★☆★☆★☆★☆★☆★☆★☆★☆★

发信人: raphaelzl (小飞熊~笨笨), 信区: Programming
标  题: Re: 那里可以搞到C语言的CRC算法
发信站: BBS 水木清华站 (Tue Apr 17 10:42:25 2001)
#include<stdio.h>
#include<windows.h>
#define IN_FILE ".\\crc.in"
#define MAX_IN_FILE_SIZE 8192
#define MIN_IN_FILE_SIZE 1024
WORD CRC(unsigned char *info, DWORD len)
{
  WORD acc;
  unsigned char i;
  acc=0;
  while (len--) {
    acc=acc^(((unsigned int)(*info))<<8);
    info++;
    for (i=8;i>0;i--)
      if (acc&0x8000) acc=(acc<<1)^0x1021;
      else acc<<=1;
  }
  return acc;
}
void main()
{
HANDLE hFile = INVALID_HANDLE_VALUE;
char ch_in[MAX_IN_FILE_SIZE];
DWORD dwRW;
WORD  result;
hFile = CreateFile(IN_FILE, GENERIC_READ, 0,
   NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if(hFile == INVALID_HANDLE_VALUE){
  printf("LastError : %d\n", GetLastError());
  exit(1);
}
if(GetFileSize(hFile, NULL) > MAX_IN_FILE_SIZE ||
  GetFileSize(hFile, NULL) < MIN_IN_FILE_SIZE){
  printf("FileSize > %d or FileSize < %d",
   MAX_IN_FILE_SIZE, MIN_IN_FILE_SIZE);
  CloseHandle(hFile);
  exit(1);
}
ReadFile(hFile, ch_in, MAX_IN_FILE_SIZE, &dwRW, NULL);
CloseHandle(hFile);
result = CRC(ch_in, dwRW);
printf("The CRC code is : %x\n", result);
}
CRC32的一种
【 在 lightlk (天下最懒) 的大作中提到: 】
: rt
--
  ☆★☆★☆★☆★☆★☆★☆★☆★☆★
       真的好想拍拍小翅膀，
           就飞上那晴朗的天空。
  ☆★☆★☆★☆★☆★☆★☆★☆★☆★

发信人: Marslv (梦幻人生), 信区: Program
标  题: 破解WINDOWS屏幕保护密码(转)
发信站: BBS汕头大学郁金香站 (Sat Oct 21 23:59:25 2000), 转信
发信人: woodmen (绝不虐待英语), 信区: Programming
标  题: 破解WINDOWS屏幕保护密码
发信站: 逸仙时空 Yat-sen Channel (Fri Oct 20 20:10:04 2000), 站内信件
[以下内容转自北大]
　　一日，忽然发现用自己输入的密码不能上网，知道自己的健忘症又犯了，于是
便坐下来苦苦回忆线索……只记得当初为方便记忆，上网与屏幕保护程序使用的是
同一密码。于是找出大叠资料，意欲破解屏幕保护密码！
　　大家都知道，屏幕保护密码最多为16个字符。微软内置了16字节的密钥：48
EE 76 1D 67 69 A1 1B 7A 8C 47 F8 54 95 97 5F。Windows便用上述密钥加密你
输入的密码。其加密过程为：首先将你输入的密码字符逐位转换为其16进制的ASC
Ⅱ码值（小写字母先转为大写字母），再依次与对应密钥逐位进行异或运算，把所
得16进制值的每一位当作字符，转换为其16进制ASCII码，并在其尾加上00作为结
束标志，存入注册表HKEY_CURRENT_USER\Control Panel\desktop下的二进制键
ScreenSave_Data中。
　　懂得其加密原理后，便不难编程破解我的屏幕保护密码（即上网密码）了。本
人用VB6.0编制了一读取注册表中ScrrenSave_Data值的函数GetBinaryValue(Entry
As String),读出其值为31 43 41 33 33 43 35 35 33 34 32 31 00,去掉其结束
标志00，把余下字节转换为对应的ASCII字符，并把每两个字符组成一16进制数：
1C A3 3C 55 34 21，显然，密码为6位，将其与前6字节密钥逐一异或后便得出密
码的ASCII码（16进制值）：54 4D 4A 48 53 48,对应的密码明文为TMJHSH，破解
成功！用它拔号一试，呵，立刻传来Modem欢快的叫声。
　　附VB源程序：(程序中使用了窗体Form1，文本框Text1，命令按钮Command1)
　　1、窗体代码：
　　Option Explicit
　　Dim Cryptograph As String
　　Dim i As Integer
　　Dim j As Integer
　　Dim k As Integer
　　Dim CryptographStr(32) As Integer
　　Dim PWstr As String
　　Dim PassWord As String
　　Private Sub Command1_Click()
　　PWstr = “"
　　PassWord = “"
　　Text1.Text =“"
　　Cryptograph = GetBinaryValue(“ScreenSave_Data")
　　k = Len(Cryptograph)
　　For j = 1 To k － 1
　　 For i = 32 To 126
　　 For i = 32 To 126
　　 If Mid(Cryptograph, j, 1) = Chr(i) Then
　　 CryptographStr(j) = i
　　 End If
　　 Next i
　　Next j
　　i = (k － 1) / 2 '密码位数为(h－1)/2,根据位数选择解密过程。
　　Select Case i
　　Case 16
　　 GoTo 16
　　Case 15
　　 GoTo 15
　　Case 14
　　 GoTo 14
　　Case 13
　　 GoTo 13
　　Case 12
　　 GoTo 12
　　Case 11
　　 GoTo 11
　　Case 10
　　 GoTo 10
　　 GoTo 10
　　Case 9
　　 GoTo 9
　　Case 8
　　 GoTo 8
　　Case 7
　　 GoTo 7
　　Case 6
　　 GoTo 6
　　Case 5
　　 GoTo 5
　　Case 4
　　 GoTo 4
　　Case 3
　　 GoTo 3
　　Case 2
　　 GoTo 2
　　Case 1
　　 GoTo 1
　　Case Else
　　 End
　　End Select
　　16: PWstr = PWstr ＆ Chr((“＆H" ＆ Chr(CryptographStr(31)) ＆
Chr(CryptographStr(32))) Xor ＆H5F)
　　15: PWstr = PWstr ＆ Chr((“＆H" ＆ Chr(CryptographStr(29)) ＆
Chr(CryptographStr(30))) Xor ＆H97)
　　14: PWstr = PWstr ＆ Chr((“＆H" ＆ Chr(CryptographStr(27)) ＆
Chr(CryptographStr(28))) Xor ＆H95)
　　13: PWstr = PWstr ＆ Chr((“＆H" ＆ Chr(CryptographStr(25)) ＆
Chr(CryptographStr(26))) Xor ＆H54)
　　12: PWstr = PWstr ＆ Chr((“＆H" ＆ Chr(CryptographStr(23)) ＆
Chr(CryptographStr(24))) Xor ＆HF8)
　　11: PWstr = PWstr ＆ Chr((“＆H" ＆ Chr(CryptographStr(21)) ＆
Chr(CryptographStr(22))) Xor ＆H47)
　　10: PWstr = PWstr ＆ Chr((“＆H" ＆ Chr(CryptographStr(19)) ＆
Chr(CryptographStr(20))) Xor ＆H8C)
　　9: PWstr = PWstr ＆ Chr((“＆H" ＆ Chr(CryptographStr(17)) ＆
Chr(CryptographStr(18))) Xor ＆H7A)
　　8: PWstr = PWstr ＆ Chr((“＆H" ＆ Chr(CryptographStr(15)) ＆
Chr(CryptographStr(16))) Xor ＆H1B)
　　7: PWstr = PWstr ＆ Chr((“＆H" ＆ Chr(CryptographStr(13)) ＆
Chr(CryptographStr(14))) Xor ＆HA1)
　　6: PWstr = PWstr ＆ Chr((“＆H" ＆ Chr(CryptographStr(11)) ＆
Chr(CryptographStr(12))) Xor ＆H69)
　　5: PWstr = PWstr ＆ Chr((“＆H" ＆ Chr(CryptographStr(9)) ＆
　　5: PWstr = PWstr ＆ Chr((“＆H" ＆ Chr(CryptographStr(9)) ＆
Chr(CryptographStr(10))) Xor ＆H67)
　　4: PWstr = PWstr ＆ Chr((“＆H" ＆ Chr(CryptographStr(7)) ＆
Chr(CryptographStr(8))) Xor ＆H1D)
　　3: PWstr = PWstr ＆ Chr((“＆H" ＆ Chr(CryptographStr(5)) ＆
Chr(CryptographStr(6))) Xor ＆H76)
　　2: PWstr = PWstr ＆ Chr((“＆H" ＆ Chr(CryptographStr(3)) ＆
Chr(CryptographStr(4))) Xor ＆HEE)
　　1: PWstr = PWstr ＆ Chr((“＆H" ＆ Chr(CryptographStr(1)) ＆
Chr(CryptographStr(2))) Xor ＆H48)
　　For i = i To 1 Step －1 '所得PWstr的值为密码的倒序列，将其倒置便得出
密码。
　　 PassWord = PassWord ＆ Mid(PWstr, i, 1)
　　Next i
　　Text1.Text = PassWord '在文本框内显示密码。
　　End Sub
　　2、模块代码：
　　Option Explicit
　　Const ERROR_SUCCESS = 0＆
　　Const ERROR_BADDB = 1009＆
　　Const ERROR_BADKEY = 1010＆
　　Const REG_EXPAND_SZ = 2＆
　　Const REG_BINARY = 3＆
　　Const KEY_QUERY_VALUE = ＆H1＆
　　Const KEY_ENUMERATE_SUB_KEYS = ＆H8＆
　　Const KEY_NOTIFY = ＆H10＆
　　Const READ_CONTROL = ＆H20000
　　Const STANDARD_RIGHTS_READ = READ_CONTROL
　　Const KEY_READ = STANDARD_RIGHTS_READ Or KEY_QUERY_VALUE Or
KEY_ENUMERATE_SUB_KEYS Or KEY_NOTIFY
　　Const HKEY_CURRENT_USER = ＆H80000001
　　Dim hKey As Long, MainKeyHandle As Long
　　Dim rtn As Long, lBuffer As Long, sBuffer As String, SubKey As
String
　　Dim lBufferSize As Long
　　Declare Function RegOpenKeyEx Lib “advapi32.dll" Alias “
RegOpenKeyExA" (ByVal hKey As Long, ByVal lpSubKey As String, ByVal
ulOptions As Long, ByVal samDesired As Long, phkResult As Long) As
Long
　　Declare Function RegCloseKey Lib “advapi32.dll" (ByVal hKey As
Long) As Long
　　Declare Function RegQueryValueEx Lib“advapi32.dll" Alias“Reg
QueryValueExA" (ByVal hKey As Long, ByVal lpValueName As String, ByVal
lpReserved As Long, lpType As Long, ByVal lpData As String, lpcbData
lpData As String, lpcbData
As Long) As Long
　　Function GetBinaryValue(Entry As String)
　　MainKeyHandle = HKEY_CURRENT_USER
　　SubKey = “Control Panel\desktop\"
　　rtn = RegOpenKeyEx(MainKeyHandle, SubKey, 0, KEY_READ, hKey)
　　 If rtn = ERROR_SUCCESS Then '如果HKEY_CURRENT_USER\Control
Panel\desktop键被成功打开
　　 lBufferSize = 1
　　 rtn = RegQueryValueEx(hKey, Entry, 0, REG_BINARY, 0, lBufferSize)
'读取ScreenSave_Data的值
　　 sBuffer = Space(lBufferSize)
　　 rtn = RegQueryValueEx(hKey, Entry, 0, REG_BINARY, sBuffer,
lBufferSize)
　　 If rtn = ERROR_SUCCESS Then '如果读取ScreenSave_Data的值成功
　　 rtn = RegCloseKey(hKey)
　　 GetBinaryValue = sBuffer '函数返回ScreenSave_Data的值
　　 Else '如果读取ScreenSave_Data的值不成功
　　 Call ErrorMsg
　　 End
　　 End If
　　Else '如果HKEY_CURRENT_USER\Control Panel\desktop键不能打开
　　 Call ErrorMsg '调用ErrorMsg()过程
　　 Call ErrorMsg '调用ErrorMsg()过程
　　 End
　　 End If
　　End Function
　　Private Sub ErrorMsg() '显示错误信息过程
　　 Select Case rtn
　　 Case ERROR_BADDB
　　 MsgBox (“您的计算机注册表有错误!")
　　Case ERROR_BADKEY, REG_EXPAND_SZ
　　 MsgBox (“您的计算机未设屏保密码！")
　　Case Else
　　 MsgBox (“破解过程中遇到未知错误，错误号：" ＆ Str＄(rtn))
　　 End Select
　　End Sub
--
            .      .-~\
           / `-'\.'    `- :
           |    /          `._
           |   |   .-.        {
            \  |   `-'         `.

穷举密码算法
breath
  
//*******************************************************************
//在许多情况下我们需要穷举组合的算法，比如密码词典。
//这个算法的关键是密码下标进位的问题。
//另外本例子中的写文件语句效率比较低，为了降低算法复杂度没有优化。
//如果要提高写文件的效率，可以使用缓冲区，分批写入。
//*********************************************breath.cnpick.com*****

void createpassword()
{
#define passwordmax 8//将生成密码的最大长度

char a[]="0123456789abcdefghijklmnopqrstuvwxyz";//可能的字符
long ndictcount=sizeof(a);//获得密码词典长度
char cpass[passwordmax+2];//将生成的密码
long nminl=1,nmaxl=3;//本例中密码长度从1-3
long array[passwordmax];//密码词典下标

assert(nminl<=nmaxl && nmaxl<=passwordmax);//容错保证
long nlength=nminl;
register long j,i=0;
bool bnext;
cstdiofile file;
file.open("c:\\dict.txt",cfile::modecreate|cfile::modewrite);
while(nlength<=nmaxl)
{
for(i=0;i<passwordmax;i++)
array[i]=0;
bnext=true;
while(bnext)
{
for(i=0;i<nlength;i++)
cpass[i]=a[array[i]];
cpass[i]='\0';
file.writestring(cpass);
file.writestring("\n");
for(j=nlength-1;j>=0;j--)//密码指针进位
{
array[j]++;
if(array[j]!=ndictcount-1)break;
else
{
array[j]=0;
if(j==0)bnext=false;
}
}

}
nlength++;
}
file.close();
}

发信人: Marslv (梦幻人生), 信区: Program
标  题: 生命法则(转）
发信站: BBS汕头大学郁金香站 (Sun Oct 22 09:16:08 2000), 转信
发信人: messages.bbs@bbs.whu.edu.cn (少年心气), 信区: DOS
标  题: 生命法则
发信站: 珞珈山水 (Sat May 22 19:05:50 1999)
转信站: argo!news.zsu.edu.cn!whunews!whubbs
发信人: vinc (never mind), 信区: Dos
标  题: 生命法则
发信站: 樱花城堡 (Sat May 22 17:22:38 1999), 转信
这是一个很有名的John Comway的生命法则命题，其大意是：
在一片空间上，有成一定形状的生命体的群体在生息繁衍着，
他们的生活规律是：
1.如果某生命体的周围有三个以上的生命体存在，它就将因
  过于拥挤而死去；
2.如果某生命体的周围的生命体少于两个，它就将因孤独而
  死去；
3.如果某空间上没有生命体存在，但其周围有两个或三个生
  命体存在，则这个空间上将产生新的生命体。
学过计算机算法的人一定对这个命题不陌生吧？
我用的汇编语言编的这个程序可以做到上述的要求（我还从
没有见人用汇编语言来编这个程序... faint...是汇编语言
太难了？太面向硬件？我觉得用汇编语言来编这个程序真的
是很酷耶！而且，我没有用常规的教科书上讲的pascal例程
采用的那种算法，书上的pascal例程用了两个缓冲区来存储
生命体的位置和处理中间结果，我只用了一个缓冲区...
嗯...真的是很爽...只是界面有点简单，这就是其他高级语
言的优势了...)，主要功能键是先移动上下左右方向键和回
车键布置第一代生命体的位置，两次回车确定。然后程序就
开始计算后代的命运了，每按一次任意键算出一代，按Esc
键重新开始程序，按q键退出。
;Life.ASM
code            segment
                assume cs:code,ds:code,es:code,ss:code
                org 100h
start:          jmp main
version         db "Bruce's Law of Life Version 1.00",0
gap             db 'Generation  00',07,00
buff            db 20*20 dup (?)
count           db 0
total           dw 0
row             db 0
col             db 0
disp:           mov ah,0eh
                mov bl,0fh
                int 10h
                ret
cls:            mov ax,0700h
                mov bh,0fh
                mov cx,0
                mov dx,184fh
                int 10h
                ret
down:           mov al,08h
                call disp
                mov al,0ah
                call disp
                mov al,'?
                jmp disp
line:           mov cx,14h
lop1:           mov al,'?
                call disp
                loop lop1
                ret
downline:       mov cx,14h
lop2:           call down
                loop lop2
                ret
setposition:    mov ah,02h
                mov bh,00h
                int 10h
                ret
echo:           lodsb
                or al,al
                jz return
                call disp
                jmp echo
return:         ret
turn:           mov dx,0a03h
                call setposition
                inc byte ptr [gap][0dh]
                cmp byte ptr [gap][0dh],'9'
                jbe ok
                mov byte ptr [gap][0dh],'0'
                inc byte ptr [gap][0ch]
ok:             mov si,offset gap
                call echo
                ret
chess:          mov ah,0eh
                mov bl,0fh
                mov al,'*'
                int 10h
                call back
                ret
back:           mov dl,[col]
                mov dh,[row]
                call setposition
                call getposition
                ret
compchar:       call readchar
                cmp al,'*'
                jnz return1
                inc count
return1:        ret
getposition:    mov ah,03h
                mov bh,00h
                int 10h
                mov [col],dl
                mov [row],dh
                ret
readchar:       mov ah,08h
                mov bh,00h
                int 10h
                ret
receive:        mov dx,0433h
                call setposition
                call getposition
                mov di,offset buff
                mov word ptr [total],0
lopr:           call compare
                call getposition
                inc dl
                cmp dl,46h
                jbe setr
                mov dl,33h
                inc dh
               ;cmp dh,17h
               ;jbe setr
               ;ret
setr:          ;xor ax,ax
                ;int 16h
                call setposition
                call getposition
                inc word ptr [total]
                cmp word ptr [total],20*20
                jb lopr
                ret
test1:          call setposition
                call compchar
                call back
                ret
compare:        mov count,0
                call getposition
                inc dh
                call test1
                dec dh
                call test1
                inc dl
                call test1
                dec dl
                call test1
                inc dh
                inc dl
                call test1
                inc dh
                dec dl
                call test1
                dec dh
                inc dl
                call test1
                dec dh
                dec dl
                call test1
                call readchar
                cmp al,'*'
                jz have
                cmp count,3
                jz point
blank:          mov al,20h
                stosb
                ret
have:           cmp count,3
                ja blank
                cmp count,2
                jb blank
point:          mov al,'*'
                stosb
                ret
putpicture:     mov dx,0433h
                call setposition
                call getposition
                mov si,offset buff
                mov word ptr [total],0
lopp:           call getposition
                cmp dl,46h
                jbe setp
                mov dl,33h
                inc dh
setp:           call setposition
                inc word ptr [total]
                lodsb
                call disp
                cmp word ptr [total],20*20
                jb lopp
                ret
main:           call cls
                mov cx,20*20
                mov di,offset buff
                mov al,0
                rep stosb
                mov word ptr [gap][0ch],3030h
                mov dx,0228h
                call setposition
                mov si,offset version
                call  echo
                mov dx,0332h
                call setposition
                mov al,'?
                call disp
                call line
                mov al,'?
                call disp
                call downline
                mov dx,0333h
                call setposition
                call downline
                mov al,08h
                call disp
                mov al,0ah
                call disp
                mov al,'?
                call disp
                call line
                mov al,'?
                call disp
                call turn
                mov dx,0e3dh
direct:         call setposition
                call getposition
getkey:         xor ax,ax
                int 16h
                cmp ax,011bh
                jz main
                cmp ax,4800h
                jnz dir_down
                cmp byte ptr [row],4
                jz getkey
                dec dh
                jmp direct
dir_down:       cmp ax,5000h
                jnz dir_left
                cmp byte ptr [row],17h
                jz getkey
                inc dh
                jmp direct
dir_left:       cmp ax,4b00h
                jnz dir_right
                cmp byte ptr [col],33h
                jz getkey
                dec dl
                jmp direct
dir_right:      cmp ax,4d00h
                jnz enter1
                cmp byte ptr [col],46h
                jz getkey
                inc dl
                jmp direct
exit:           call cls
                mov dx,0
                call setposition
                mov ax,4c00h
                int 21h
enter1:         cmp al,0dh
                jz confirmed
                jmp getkey
confirmed:      call readchar
                cmp al,20h
                jnz confirm_again
                call chess
no:             jmp getkey
confirm_again:  xor ax,ax
                int 16h
                cmp al,0dh
                jnz no
start_cal:      call turn
                call receive
                call putpicture
                xor ax,ax
                int 16h
                cmp ah,01h
                jnz continue
                jmp main
continue:       cmp ah,10h
                jz endcode
                jmp start_cal
endcode:        jmp exit
code            ends
                end     start
--
            .      .-~\
           / `-'\.'    `- :
           |    /          `._
           |   |   .-.        {
            \  |   `-'         `.

发信人: allanli (若尘), 信区: Program
标  题: 实现上下跳变触发.
发信站: BBS汕头大学郁金香站 (Wed May  3 16:14:18 2000), 转信
    下面程序是pic16cxx系列单片机汇编语言的一段代码,功能为按键延时,
由于某种原因不能用空循环来实现,不知还有没有更好的方法?
还有是计数程序段实现了只对脉冲上升沿计数,是否还有更好的方法?
;--------------------------------------------------------------------------
;*******************************************
;* 本函数用于初始化ISCONFIRM1所用到的寄存器 *
;*                                          *
;* 参见：  函数ISCONFIRM1                   *
;* 返回值：NOTHING                          *
;*******************************************
CLSCONFIRM1
clrf 0xc
clrf 0xd
retlw 0x0
; End Of CLSCONFIRM1;-------------------------------------------------------
------------------------------------
;******************************************
;* 本函数用于监测按键是否按下了20ms       *
;* 调用CLSCONFIRM1后开始算0秒             *
;*                                        *
;* 参见：  函数CLSCONFIRM1                *
;* 返回值：若超过20ms秒返回0xFF           *
;*                  否则返回0x0           *
;******************************************
ISCONFIRM1
movf   portc,W       ; PORTC->W,保留PORTC的状态到W
andlw  0x80          ; W的最高位保留过零比较器的输出值
xorwf  0xc,W         ; W的值与FC中保留的值相比较,影响Z位.
btfsc  0x3,0x2       ; 判断状态记存器z位是否为零,为零则W<>FC，也即发生过零。
retlw  0x0           ; Z位不为零,即w=FC,没过零,返回
xorwf  0xc           ; 若为零,即过零器过零,保存PORTC(7)的状态到FC中。
btfsc  0x3,0x2       ; 判断状态记存器z位是否为零
retlw  0x0           ; W=FC,此过零为负跳变,不计数,返回
incf   0xd           ; 过零,此过零为正跳变,计数,FD增1
movlw  0x2           ;
subwf  0xd,W         ; 判断FD是否>=2H，若是的话再判断键是否仍然按下
btfss  0x3,0x0       ; 检测C位
retlw  0x0           ; C位为0,有借位,FD<2H,返回0x0
movlw  0x2           ; C位为1,没借位,FD>=2H
movwf  0xd           ; 2H->Fd,保持FD>=2H
movf   portb,W       ; 判断键是否仍然按下
movwf  0x1F          ;
btfsc  0x1F,0x2      ; 检测RB2的状态，即判断是否有键按下
retlw  0xFF          ; 键仍然按下,返回0xFF
retlw  0x0           ; 键已松开,返回0x0
; End Of ISCONFIRM1
--
  既然要注定流浪，
  风又何必苦苦推难。                     E-Mail:allan_stu@163.net
  既然帆想要靠岸，
  海又何必处处阻拦。