java黑客工具_顶级黑客工具
作者:hacker | 分类:邮箱破解 | 浏览:108 | 日期:2022年08月23日文章目录:
电脑里的病毒程序是什么
一种恶意计算机代码，可以破坏系统程序，占用空间，盗取账号密码。严重可以导致网络、系统瘫痪。 详见计算机病毒
去除方法
使用安 巴尔的摩分类法是基于病毒mRNA的合成方式
全的杀毒软件清除。
病毒名
由以下6字段组成的：主行为类型.子行为类型.宿主文件类型.主名称.版本信息.主名称变种号#附属名称.附属名称变种号.病毒长度。其中字段之间使用“.”分隔，#号以后属于内部信息，为推举结构。
主行为类型与病毒子行为类型
病毒可能包含多个主行为类型，这种情况可以通过每种主行为类型的危害级别确定危害级别最高的作为病毒的主行为类型。同样的，病毒也可能包含多个子行为类型，这种情况可以通过每种主行为类型的危害级别确定危害级别最高的作为病毒的子行为类型。其中危害级别是指对病毒所在计算机的危害。 病毒主行为类型有是否显示的属性，用于生成病毒名时隐藏主行为名称。它与病毒子行为类型存在对应关系，见下表： 主行为类型 子行为类型 Backdoor 危害级别：1 说明： 中文名称—“后门”， 是指在用户不知道也不允许的情况下，在被感染的系统上以隐蔽的方式运行可以对被感染的系统进行远程控制，而且用户无法通过正常的方法禁止其运行。“后门”其实是木马的一种特例，它们之间的区别在于“后门”可以对被感染的系统进行远程控制（如：文件管理、进程控制等）。 Worm 危害级别：2 说明： 中文名称—“蠕虫”，是指利用系统的漏洞、外发邮件、共享目录、可传输文件的软件（如：MSN、OICQ、IRC等）、可移动存储介质（如：U盘、软盘），这些方式传播自己的病毒。这种类型的病毒其子型行为类型用于表示病毒所使用的传播方式。 Mail 危害级别：1 说明：通过邮件传播 IM 危害级别：2 说明：通过某个不明确的载体或多个明确的载体传播自己 MSN 危害级别：3 说明：通过MSN传播 QQ 危害级别：4 说明：通过OICQ传播 ICQ 危害级别：5 说明：通过ICQ传播 P2P 危害级别：6 说明：通过P2P软件传播 IRC 危害级别：7 说明：通过ICR传播 说明：不依赖其他软件进行传播的传播方式，如：利用系统漏洞、共享目录、可移动存储介质。 Trojan 危害级别：3 说明： 中文名称—“木马”，是指在用户不知道也不允许的情况下，在被感染的系统上以隐蔽的方式运行，而且用户无法通过正常的方法禁止其运行。这种病毒通常都有利益目的，它的利益目的也就是这种病毒的子行为。 Spy 危害级别：1 说明：窃取用户信息（如：文件等） PSW 危害级别：2 说明：具有窃取密码的行为 DL 危害级别：3 说明：下载病毒并运行 一、判定条款: 没有可调出的任何界面,逻辑功能为:从某网站上下载文件加载或运行. 二、逻辑条件引发的事件: 事件1、.不能正常下载或下载的文件不能判定为病毒。 操作准则:该文件不能符合正常软件功能组件标识条款的,确定为:Trojan.DL 事件2.下载的文件是病毒 操作准则: 下载的文件是病毒,确定为: Trojan.DL IMMSG 危害级别：4 说明：通过某个不明确的载体或多个明确的载体传播即时消息（这一行为与蠕虫的传播行为不同，蠕虫是传播病毒自己，木马仅仅是传播消息） MSNMSG 危害级别：5 说明：通过MSN传播即时消息 QQMSG 危害级别：6 说明：通过OICQ传播即时消息 ICQMSG 危害级别：7 说明：通过ICQ传播即时消息 UCMSG 危害级别：8 说明：通过UC传播即时消息 Proxy 危害级别：9 说明：将被感染的计算机作为代理服务器 Clicker 危害级别：10 说明：点击指定的网页 判定条款: 没有可调出的任何界面,逻辑功能为:点击某网页。 操作准则: 该文件不符合正常软件功能组件标识条款的,确定为:Trojan.Clicker。 (该文件符合正常软件功能组件标识条款,就参考流氓软件判定规则进行流氓软件判定) Dialer 危害级别：12 说明：通过拨号来骗取Money的程序 说明：无法描述其利益目的但又符合木马病毒的基本特征，则不用具体的子行为进行描述 AOL 按照原来病毒名命名保留。 Notifier 按照原来病毒名命名保留。 Virus 危害级别：4 说明：中文名称—“感染型病毒”，是指将病毒代码附加到被感染的宿主文件（如：PE文件、DOS下的COM文件、VBS文件、具有可运行宏的文件）中，使病毒代码在被感染宿主文件运行时取得运行权的病毒。 Harm 危害级别：5 说明：中文名称—“破坏性程序”，是指那些不会传播也不感染，运行后直接破坏本地计算机（如：格式化硬盘、大量删除文件等）导致本地计算机无法正常使用的程序。 Dropper 危害级别：6 说明：中文名称—“释放病毒的程序”，是指不属于正常的安装或自解压程序，并且运行后释放病毒并将它们运行。 一．Dropper判定条款: 没有可调出的任何界面，逻辑功能为:自释放文件加载或运行。 二．逻辑条件引发的事件: 事件1：.释放的文件不是病毒。 操作准则: 释放的文件和释放者本身没逻辑关系并该文件不符合正常软件功能组件标识条款的,确定为:Droper 事件2：释放的文件是病毒。 操作准则: 释放的文件是病毒，确定该文件为:Droper Hack 危害级别：无 说明：中文名称—“黑客工具”，是指可以在本地计算机通过网络攻击其他计算机的工具。 Exploit 说明：漏洞探测攻击工具 DDoser 说明：拒绝服务攻击工具 Flooder 说明：洪水攻击工具 说明：不能明确攻击方式并与黑客相关的软件，则不用具体的子行为进行描述 Spam 说明：垃圾邮件。 Nuker Sniffer Spoofer Anti 说明：免杀的黑客工具 Binder 危害级别：无 说明：捆绑病毒的工具 正常软件功能组件标识条款：被检查的文件体内有以下信息能标识出该文件是正常软件的功能组件：文件版本信息,软件信息（注册表键值、安装目录）等。 Autorun 危害级别：9 说明：用U盘传播的系统文件（被利用） 这样的病毒杀毒软件查不出来 宿主文件 宿主文件是指病毒所使用的文件类型，有是否显示的属性。目前的宿主文件有以下几种。 JS 说明：JavaScript脚本文件 VBS 说明：VBScript脚本文件 HTML 说明：HTML文件 Java 说明：Java的Class文件 COM 说明：Dos下的Com文件 EXE 说明：Dos下的Exe文件 Boot 说明：硬盘或软盘引导区 Word 说明：MS公司的Word文件 Excel 说明：MS公司的Excel文件 PE 说明：PE文件 WinREG 说明：注册表文件 Ruby 说明：一种脚本 Python 说明：一种脚本 BAT 说明：BAT脚本文件 IRC 说明：IRC脚本
主名称
病毒的主名称是由分析员根据病毒体的特征字符串、特定行为或者所使用的编译平台来定的，如果无法确定则可以用字符串”Agent”来代替主名称，小于10k大小的文件可以命名为“Samll”。
版本信息
版本信息只允许为数字，对于版本信息不明确的不加版本信息。
主名称变种号
如果病毒的主行为类型、行为类型、宿主文件类型、主名称均相同，则认为是同一家族的病毒，这时需要变种号来区分不同的病毒记录。如果一位版本号不够用则最多可以扩展3位，并且都均为小写字母a—z，如：aa、ab、aaa、aab以此类推。由系统自动计算，不需要人工输入或选择。
附属名称
病毒所使用的有辅助功能的可运行的文件，通常也作为病毒添加到病毒库中，这种类型的病毒记录需要附属名称来与病毒主体的病毒记录进行区分。附属名称目前有以下几种： Client 说明：后门程序的控制端 KEY_HOOK 说明：用于挂接键盘的模块 API_HOOK 说明：用于挂接API的模块 Install 说明：用于安装病毒的模块 Dll 说明：文件为动态库，并且包含多种功能 （空） 说明：没有附属名称，这条记录是病毒主体记录
附属名称变种号
如果病毒的主行为类型、行为类型、宿主文件类型、主名称、主名称变种号、附属名称均相同，则认为是同一家族的病毒，这时需要变种号来区分不同的病毒记录。变种号为不写字母a—z，如果一位版本号不够用则最多可以扩展3位，如：aa、ab、aaa、aab以此类推。由系统自动计算，不需要人工输入或选择。
病毒长度
病毒长度字段只用于主行为类型为感染型（Virus）的病毒，字段的值为数字。字段值为0，表示病毒长度可变。
怎么样才能写出安全的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 和他联系
关于黑客和JAVA
JAVA高级语言,对黑客毫无疑义,
编程序用的语言,想做黑客学汇编语言
更难,不过不可能用汇编来写程序,因为太难
java可以编黑客程序吗?
不可以！
java程序运行是需要虚拟机（JVM）支持的，也就是运行java程序的机器必须安装有jre或者jdk，你怎么保证被黑的机器上装了？如果没装，都运行不了，怎么黑别人？
