安徽工业大学密码学实验报告

安徽工业大学密码学实验报告

姓名：甘家伟

学号：109074288

班级：网101

指导教师：卫琳娜

2013年12月1日

实验一．古典密码学实验：

一、凯撒密码的加解密

1、实验原理

在密码学中存在着各种各样的置换方式，但所有不同的置换方式都包含2个相同的元素。密钥和协议(算法)。凯撒密码的密钥是3，算法是将普通字母表中的字母用密钥对应的字母替换。置换加密的优点就在于它易于实施却难于破解. 发送方和接收方很容易事先商量好一个密钥，然后通过密钥从明文中生成密文，即是敌人若获取密文，通过密文直接猜测其代表的意义，在实践中是不可能的。

凯撒密码的加密算法极其简单。其加密过程如下：

在这里，我们做此约定：明文记为m，密文记为c，加密变换记为E(k1,m)（其中k1为密钥），解密变换记为D(k2,m)（k2为解密密钥）（在这里不妨假设k1=k2,记为k）。凯撒密码的加密过程可记为如下一个变换：

c≡m+k mod n （其中n为基本字符个数）

同样，解密过程可表示为：

m≡c+k mod n （其中n为基本字符个数）

对于计算机而言，n可取256或128，m、k、c均为一个8bit的二进制数。显然，这种加密算法极不安全，即使采用穷举法，最多也只要255次即可破译。当然，究其本身而言，仍然是一个单表置换，因此，频率分析法对其仍是有效的。

2、程序源码

#include

#include

int main()

{

char s[26],c;

int i,p,d,e;

printf(" 1.加密2.解密 3.退出\n\n");

printf("选择：");

scanf("%c",&c);

if(c=='1')

{

printf("输入明文:");

scanf("%s",&s);

p=strlen(s);

printf("请设置偏移量（1~26）:");

scanf("%d",&d);

for(i=0;i

{

if(s[i]>='a' && s[i]<='z')

s[i]=(s[i]-'a'+d)%26+'a';

else if(s[i]>='A' && s[i]<='Z')

s[i]=(s[i]-'A'+d)%26+'A';

else s[i]=s[i]+d;

}

printf("%s",s);

printf("\n\n\n");

}

if(c=='2')

{

printf("请输入密文:");

scanf("%s",&s);

p=strlen(s);

printf("请输入加密的偏移变量:"); scanf("%d",&d);

for(i=0;i

{

if(s[i]>='a' && s[i]<='z')

{

e=s[i]-'a'-d;

if(e<=0)

s[i]=(e+26)%26+'a';

else s[i]=e%26+'a';

}

else if(s[i]>='A' && s[i]<='Z') {

e=s[i]-'A'-d;

if(e<0)

s[i]=(e+26)%26+'A';

else s[i]=e%26+'A';

}

else s[i]=s[i]-d;

}

printf("%s",s);

printf("\n\n");

}

if(c=='3')

return 0;

return 0;

二、弗吉尼亚密码的加解密

1、实验原理

CIA总部波浪形铜板上的文字，是运用一种名为「弗吉尼亚密码」（Vigenere cipher）的方式加密，但相比之下还要复杂。

用弗吉尼亚密码加密，首要要想出一个「钥匙」。举例我们想将「GOODMORNING」一组字母加密，钥匙为「TEA」。被加密的第1个字母G，在26个英文字母中排第7；我们要用钥匙的第1个字母T来加密，就是选出由T开始的第7个字母（即Z，）。

第2、3个字母（两个O）则分别用E和A，以相同方法加密，第4个字母则重复使用T来加密，如此类推。最后该组字母便被加密成「ZSOWQOKRIGK」。我们也可以运用一个「弗吉尼亚表」，帮助加密。

但桑伯恩所运用的，则使用了一种名为「Quagmire III」的特别加密手法，制造出更复杂的弗吉尼亚表。CIA总部右边铜板包含着「KRYPTOS」英文字，和一般顺着英文字母排列的弗吉尼亚表不同。

要运用该表来解密，解密者要从左边铜板被加密文字的规律中，找出「PALIMPSEST」(羊皮纸卷)和「ABSCISSA」(几何的横座标）两个「钥匙」，然后将这些钥匙嵌入右边铜板，成为新的「弗吉尼亚表」，便可破译第1、2段加密文字。

2、程序源码

3、实验#include

#include

#include

void Encry()

{

char key[100];

char ch,temp;

int L,i=0,j=0;

if(getchar()=='\n')

temp=' ';

printf("请输入密钥: ");

gets(key);

L=strlen(key);

printf("输入明文: ");

while((ch=getchar())!='\n')

{

{

i++;

continue;

}

if(ch>='a'&&ch<='z')

{

printf("%c",(ch+key[j%L]-'a'-'a')%26+'A');

j++;

}

if(ch>='A'&&ch<='Z')

{

printf("%c",(ch+key[j%L]-'A'-'a')%26+'A');

j++;

}

if(j%L==0)

printf(" ");

i++;

}

putchar(ch);

}

void Decry()

{

char key[100];

char ch,temp;

int L,i=0,j=0;

if(getchar()=='\n')

temp=' ';

printf("请输入密钥: ");

gets(key);

L=strlen(key);

printf("输入密文: ");

while((ch=getchar())!='\n')

{

if(ch==' ')

{

i++;

continue;

}

if(ch>='A'&&ch<='Z')

{

printf("%c",(ch-key[j%L]-'A'+'a'+26)%26+'a');

j++;

}

printf(" ");

i++;

}

putchar(ch);

}

int Exit()

{

exit(0);

}

int main()

{

char ch;

for(;;)

{

printf("请输入你的操作(e/E加密;d/D解密;q/Q退出):");

ch=getchar();

if(ch=='e'||ch=='E')

Encry();

else if(ch=='d'||ch=='D')

Decry();

else if(ch=='q'||ch=='Q')

Exit();

else

{

printf("输入命令错误!");

putchar(getchar());

continue;

}

}

return 0;

}

实验二．对称密码学实验：DES算法实现加解密

1、实验原理

本世纪五十年代以来，密码学研究领域出现了最具代表性的两大成就。其中之一就是

1971年美国学者塔奇曼（Tuchman）和麦耶（Meyer）根据信息论创始人香农（Shannon）提出的「多重加密有效性理论」创立的，后於1977年由美国国家标準局颁布的数据加密标準。

DES密码实际上是Lucifer密码的进一步发展。它是一种採用传统加密方法的区组密码。它的算法是对称的，既可用於加密又可用於解密。

美国国家标準局1973年开始研究除国防部外的其它部门的计算机系统的数据加密标準，於1973年5月15日和1974年8月27日先后两次向公眾发出了徵求加密算法的公告。加密算法要达到的目的通常称為DES密码算法要求主要為以下四点：提供高质量的数据保护，防止数据未经授权的洩露和未被察觉的修改；具有相当高的复杂性，使得破译的开销超过可能获得的利益，同时又要便於理解和掌握DES 密码体制的安全性应该不依赖於算法的保密，其安全性仅以加密密钥的保密為基础实现经济，运行有效，并且适用於多种完全不同的应用。

1977年1月，美国政府颁布：採纳IBM公司设计的方案作為非机密数据的正式数据加密标準（DES枣Data Encryption Standard）。

目前在这裡，随著三金工程尤其是金卡工程的啟动，DES算法在POS、ATM、磁卡及智能卡（IC卡）、加油站、高速公路收费站等领域被广泛应用，以此来实现关键数据的保密，如信用卡持卡人的PIN的加密传输，IC卡与POS间的双向认证、金融交易数据包的MAC校验等，均用到DES算法。

DES算法的入口参数有三个：Key、Data、Mode。其中Key為8个字节共64位，是DES算法的工作密钥；Data也為8个字节64位，是要被加密或被解密的数据；Mode為DES的工作方式，有两种：加密或解密。

DES算法是这样工作的：如Mode為加密，则用Key 去把数据Data进行加密，生成Data的密码形式（64位）作為DES的输出结果；如Mode為解密，则用Key去把密码形式的数据Data解密，还原為Data的明码形式（64位）作為DES的输出结果。在通信网络的两端，双方约定一致的Key，在通信的源点用Key对核心数据进行DES加密，然后以密码形式在公共通信网（如电话网）中传输到通信网络的终点，数据到达目的地后，用同样的Key对密码数据进行解密，便再现了明码形式的核心数据。这样，便保证了核心数据（如PIN、MAC等）在公共通信网中传输的安全性和可靠性。

2、程序源码

#define PLAIN_FILE_OPEN_ERROR -1

#define CIPHER_FILE_OPEN_ERROR -2

#define OK 1

//初始置换表IP

int IP_Table[64] = {

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,

56,48,40,32,24,16,8,0,

58,50,42,34,26,18,10,2, 60,52,44,36,28,20,12,4, 62,54,46,38,30,22,14,6}; //逆初始置换表IP^-1 int IP_1_Table[64] = {

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,

32,0,40,8,48,16,56,24};

//扩充置换表E

int E_Table[48] = {31, 0, 1, 2, 3, 4, 3, 4, 5, 6, 7, 8,

7, 8,9,10,11,12,

11,12,13,14,15,16,

15,16,17,18,19,20,

19,20,21,22,23,24,

23,24,25,26,27,28,

27,28,29,30,31, 0};

//置换函数P

int P_Table[32] = {15,6,19,20,28,11,27,16, 0,14,22,25,4,17,30,9,

1,7,23,13,31,26,2,8,

18,12,29,5,21,10,3,24};

//S盒

int S[8][4][16] ={

//S1

{{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}},

//S2

{{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}},

//S3

{{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}},

//S4

{{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}},

//S5

{{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}},

//S6

{{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}},

//S7

{{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}},

//S8

{{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}}}; //置换选择1 int PC_1[56] = {

56,48,40,32,24,16,8,

0,57,49,41,33,25,17,

9,1,58,50,42,34,26,

18,10,2,59,51,43,35,

62,54,46,38,30,22,14,

6,61,53,45,37,29,21,

13,5,60,52,44,36,28,

20,12,4,27,19,11,3};

//置换选择2

int PC_2[48] = {

13,16,10,23,0,4,2,27,

14,5,20,9,22,18,11,3,

25,7,15,6,26,19,12,1,

40,51,30,36,46,54,29,39,

50,44,32,46,43,48,38,55,

33,52,45,41,49,35,28,31};

//对左移次数的规定

int MOVE_TIMES[16] = {1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1};

//加密单个分组

int DES_EncryptBlock(ElemType plainBlock[8], ElemType subKeys[16][48], ElemType cipher Block[8]){

ElemType plainBits[64];

ElemType copyRight[48];

int cnt;

Char8ToBit64(plainBlock,plainBits); //初始置换（IP置换）

DES_IP_Transform(plainBits);

//16轮迭代

for(cnt = 0; cnt < 16; cnt++){

memcpy(copyRight,plainBits+32,32);

//将右半部分进行扩展置换，从32位扩展到48位

DES_E_Transform(copyRight); //将右半部分与子密钥进行异或操作

DES_XOR(copyRight,subKeys[cnt],48); //异或结果进入S盒，输出32位结果

DES_SBOX(copyRight); //P置换

DES_P_Transform(copyRight); //将明文左半部分与右半部分进行异或

DES_XOR(plainBits,copyRight,32);

if(cnt != 15){

//最终完成左右部的交换

DES_Swap(plainBits,plainBits+32);

}

}

//逆初始置换（IP^1置换）

DES_IP_1_Transform(plainBits);

Bit64ToChar8(plainBits,cipherBlock);

return 0; }

//解密单个分组

int DES_DecryptBlock(ElemType cipherBlock[8], ElemType subKeys[16][48],ElemType plainB lock[8]){

ElemType cipherBits[64];

ElemType copyRight[48];

int cnt;

Char8ToBit64(cipherBlock,cipherBits); //初始置换（IP置换）

DES_IP_Transform(cipherBits);

//16轮迭代

for(cnt = 15; cnt >= 0; cnt--){

memcpy(copyRight,cipherBits+32,32);

//将右半部分进行扩展置换，从32位扩展到48位

DES_E_Transform(copyRight); //将右半部分与子密钥进行异或操作

DES_XOR(copyRight,subKeys[cnt],48); //异或结果进入S盒，输出32位结果

DES_SBOX(copyRight); //P置换

DES_P_Transform(copyRight); //将明文左半部分与右半部分进行异或

DES_XOR(cipherBits,copyRight,32);

if(cnt != 0){

//最终完成左右部的交换

DES_Swap(cipherBits,cipherBits+32);

}

}

//逆初始置换（IP^1置换）

DES_IP_1_Transform(cipherBits);

Bit64ToChar8(cipherBits,plainBlock);

return 0;

}

//加密文件

int DES_Encrypt(char *plainFile, char *keyStr,char *cipherFile){

FILE *plain,*cipher;

int count;

ElemType plainBlock[8],cipherBlock[8],keyBlock[8];

ElemType bKey[64];

ElemType subKeys[16][48];

if((plain = fopen(plainFile,"rb")) == NULL){

return PLAIN_FILE_OPEN_ERROR;

}

if((cipher = fopen(cipherFile,"wb")) == NULL){

return CIPHER_FILE_OPEN_ERROR;

}

//设置密钥

memcpy(keyBlock,keyStr,8); //将密钥转换为二进制流

Char8ToBit64(keyBlock,bKey); //生成子密钥

DES_MakeSubKeys(bKey,subKeys);

while(!feof(plain)){

//每次读8个字节，并返回成功读取的字节数

if((count = fread(plainBlock,sizeof(char),8,plain)) == 8){ DES_EncryptBlock(p lainBlock,subKeys,cipherBlock);

fwrite(cipherBlock,sizeof(char),8,cipher);

}

}

if(count){ //填充

memset(plainBlock + count,'\0',7 - count);

//最后一个字符保存包括最后一个字符在内的所填充的字符数量plainBlock[7] = 8 - count;

DES_EncryptBlock(plainBlock,subKeys,cipherBlock);

fwrite(cipherBlock,sizeof(char),8,cipher); }

fclose(plain); fclose(cipher); return OK; }

//解密文件

int DES_Decrypt(char *cipherFile, char *keyStr,char *plainFile){ FILE *plain, *cipher;

int count,times = 0;

long fileLen;

ElemType plainBlock[8],cipherBlock[8],keyBlock[8];

ElemType bKey[64];

ElemType subKeys[16][48];

if((cipher = fopen(cipherFile,"rb")) == NULL){

return CIPHER_FILE_OPEN_ERROR; }

if((plain = fopen(plainFile,"wb")) == NULL){

return PLAIN_FILE_OPEN_ERROR; }

//设置密钥

memcpy(keyBlock,keyStr,8); //将密钥转换为二进制流

Char8ToBit64(keyBlock,bKey); //生成子密钥

DES_MakeSubKeys(bKey,subKeys);

//取文件长度

fseek(cipher,0,SEEK_END); //将文件指针置尾

fileLen = ftell(cipher); //取文件指针当前位置

rewind(cipher); //将文件指针重指向文件头

while(1){

//密文的字节数一定是8的整数倍

fread(cipherBlock,sizeof(char),8,cipher);

DES_DecryptBlock(cipherBlock,subKeys,plainBlock); times += 8;

if(times < fileLen){

fwrite(plainBlock,sizeof(char),8,plain);

}

else{

break;

}

}

//判断末尾是否被填充

if(plainBlock[7] < 8)

{

for(count = 8 - plainBlock[7]; count < 7; count++)

{

if(plainBlock[count] != '\0')

{

break;

}

}

}

if(count == 7)

{//有填充

fwrite(plainBlock,sizeof(char),8 - plainBlock[7],plain);

}

else{//无填充

fwrite(plainBlock,sizeof(char),8,plain);

}

fclose(plain);

fclose(cipher);

return OK;

}

实验三．非对称密码学实验：RSA算法实现加解密

1、实验原理

RSA算法是一种非对称密码算法，所谓非对称，就是指该算法需要一对密钥，使用其中一个加密，则需要用另一个才能解密。

RSA的算法涉及三个参数，n、e1、e2。

其中，n是两个大质数p、q的积，n的二进制表示时所占用的位数，就是所谓的密钥长度。

e1和e2是一对相关的值，e1可以任意取，但要求e1与(p-1）*(q-1）互质；再选择e2，要求（e2*e1）mod((p-1）*(q-1））=1。

（n，e1）,(n，e2）就是密钥对。其中(n，e1）为公钥，(n，e2）为私钥。[1]

RSA加解密的算法完全相同，设A为明文，B为密文，则：A=B^e2 mod n；B=A^e1 mod n；（公钥加密体制中，一般用公钥加密，私钥解密）

e1和e2可以互换使用，即：

A=B^e1 mod n；B=A^e2 mod n;

2、程序源码

#include

#include

void main() {

int candp(int a,int b,int c);//函数声明

int fun(int x,int y);//函数声明

int prime(int m);//函数声明

int p;

int q;

int e;

int d;

int m;

int n;

int t;

int c;

int r;

printf("请输入两个素数p,q: ");

scanf("%d,%d",&p,&q);

for(;p>0,q>0;)//for循环判断p和q是否同时为素数

{

if(prime(p)&&prime(q))

{

break;

}

else

printf("输入有误，请重新输入：");

scanf("%d,%d",&p,&q);

}

n=p*q;

printf("计算得n为%d\n",n); t=(p-1)*(q-1); //求n 的欧拉数

printf("计算得t为%d\n",t);

printf("请输入一个与t互素的数，即公钥e: ");

scanf("%d",&e); for(;e>1,e

{

if(e<=1||e>=t||fun(e,t))

{

printf("e不合要求，请重新输入: "); //e<1 或e>t 或e 与t 不互素时，重新输入scanf("%d",&e);

}

else break;

}

d=1;

while(((e*d)%t)!=1)

d++; //由公钥e 求出私钥d

printf("经计算d 为%d\n",d);

printf("加密请输入1\n"); //加密或解密选择

printf("解密请输入2\n");

scanf("%d",&r);

switch(r) {

case 1: printf("请输入明文m: "); //输入要加密的明文数字scanf("%d",&m); c=candp(m,e,n);

printf("密文为%d\n",c);break;

case 2: printf("请输入密文c: "); //输入要解密的密文数字scanf("%d",&c); m=candp(c,d,n);

printf("明文为%d\n",m);break;

}

}

int candp(int a,int b,int c) //数据处理函数，实现幂的取余运算

{

int z;

z=1;

b=b+1;

while(b!=1)

{

z=z*a;

z=z%c;

b--;

}

printf("%d\n",z); return z;

}

int fun(int x,int y) //公钥e 与t 的互素判断

{

int s;

while(y) {

s=x;

x=y;

y=s%y;

}

if(x == 1)

return 0; //x 与y 互素时返回0 else

return 1; //x 与y 不互素时返回1

}

int prime(int m)//判断一个数是否为素数 {

int i;

int n;

if(m==1)

return 0;

n=(int)sqrt(m);

for(i=2;i<=n;i++)

if(m%i==0)

return 0;

else

return 1;

}

3、实验结果

实验四．病毒程序分析

病毒程序：

1、感染方式

它能通过某种途径潜伏在计算机的存储介质（或程序）里，当达到某种条件时即被激活，通过修改其他程序的方法将自己的精确拷贝或者可能演化的形式放入其他程序中。从而感染其他程序，对计算机资源进行破坏，所谓的病毒就是人为造成的，对其他用户的危害性很大。

2、工作原理

病毒是一个程序，一段人为编制的计算机程序代码。它通过想办法在正常程序运行之前运行，并处于特权级状态。这段程序代码一旦进入计算机并得以执行，对计算机的某些资源进行监视。它会搜寻其他符合其传染条件的程序或存储介质，确定目标后再将自身代码插入其中，达到自我繁殖的目的。只要一台计算机染毒，如不及时处理，那么病毒会在这台机子上迅速扩散，其中的大量文件（一般是可执行文件）会被感染。而被感染的文件又成了新的传染源，再与其他机器进行数据交换或通过网络接触，病毒会继续进行传染。一般正常的程序是由用户调用，再由系统分配资源，完成用户交给的任务。其目的对用户是可见的、透明的。而病毒具有正常程序的一切特性，它隐藏在正常程序中，当用户调用正常程序时窃取到系统的控制权，先于正常程序执行，病毒的动作、目的对用户时未知的，是未经用户允许的。

病毒一般是具有很高编程技巧、短小精悍的程序。通常附在正常程序中或磁盘较隐蔽的地方，也有个别的以隐含文件形式出现。目的是不让用户发现它的存在。如果不经过代码分析，病毒程序与正常程序是不容易区别开来的。一般在没有防护措施的情况下，计算机病毒程序取得系统控制权后，可以在很短的时间里传染大量程序。而且受到传染后，计算机系统通常仍能正常运行，使用户不会感到任何异常。试想，如果病毒在传染到计算机上之后，机器马上无法正常运行，那么它本身便无法继续进行传染了。正是由于隐蔽性，计算机病毒得以在用户没有察觉的情况下扩散到上百万台计算机中。大部分的病毒的代码之所以设计得非常短小，也是为了隐藏。病毒一般只有几百或1k字节，而PC机对DOS文件的存取速度可达每秒几百KB以上，所以病毒转瞬之间便可将这短短的几百字节附着到正常程序之中，使人非常不易被察觉。

大部分的病毒感染系统之后一般不会马上发作，它可长期隐藏在系统中，只有在满足其特定条件时才启动其表现（破坏）模块。只有这样它才可进行广泛地传播。如“PETER-2"在每年2月27日会提三个问题，答错后会将硬盘加密。著名的“黑色星期五”在逢13号的星期五发作。国内的“上海一号”会在每年三、六、九月的13日发作。当然，最令人难忘的便是26日发作的CIH。这些病毒在平时会隐藏得很好，只有在发作日才会露出本来面目。

任何病毒只要侵入系统，都会对系统及应用程序产生程度不同的影响。轻者会降低计算机工作效率，占用系统资源，重者可导致系统崩溃。由此特性可将病毒分为良性病毒与恶性病毒。良性病度可能只显示些画面或出点音乐、无聊的语句，或者根本没有任何破坏动作，但会占用系统资源。这类病毒较多，如：GENP、小球、W-BOOT等。恶性病毒则有明确得目的，或破坏数据、删除文件或加密磁盘、格式化磁盘，有的对数据造成不可挽回的破坏。

3、造成的破坏

所有的计算机病毒都是一种可执行程序，而这一可执行程序又必然要运行，所以对系统来讲，所有的计算机病毒都存在一个共同的危害，即降低计算机系统的工作效率，占用系统资源，其具体情况取决于入侵系统的病毒程序。

同时计算机病毒的破坏性主要取决于计算机病毒设计者的目的，如果病毒设计者的目的在于彻底破坏系统的正常运行的话，那么这种病毒对于计算机系统进行攻击造成的后果是难以设想的，它可以毁掉系统的部分数据，也可以破坏全部数据并使之无法恢复。但并非所有的病毒都对系统产生极其恶劣的破坏作用。有时几种本没有多大破坏作用的病毒交叉感染，也会导致系统崩溃等重大恶果。