锐客网

  1. 首页 > 生活百科 > it技术 > >

java检查代码安全工具 java代码安全性

IT技术代码

java的测试代码有人检查吗静态测试包括代码检查、静态结构分析、代码质量度量等 。它可以由人工进行java检查代码安全工具 ， 充分发挥人的逻辑思维优势，也可以借助软件工具自动进行 。代码检查代码检查包括代码走查、桌面检查、代码审查等，主要检查代码和设计的一致性， 代码对标准的遵循、可读性 ， 代码的逻辑表达的正确性 ， 代码结构的合理性等方面；可以发现违背程序编写标准的问题 ， 程序中不安全、不明确和模糊的部分，找出程序中不可移植部分、违背程序编程风格的问题 ， 包括变量检查、命名和类型审查、程序逻辑审查、程序语法检查和程序结构检查等内容 。” 。看了一系列的静态代码扫描或者叫静态代码分析工具后，总结对工具的看法java检查代码安全工具：静态代码扫描工具，和编译器的某些功能其实是很相似的，java检查代码安全工具他们也需要词法分析，语法分析，语意分析...但和编译器不一样的是他们可以自定义各种各样的复杂的规则去对代码进行分析 。
【转】如何保护Java代码以下从技术角度就常见的保护措施 和常用工具来看看如何有效保护java代码：1. 将java包装成exe特点：将jar包装成可执行文件，便于使用，但对java程序没有任何保护 。不要以为生成了exe就和普通可执行文件效果一样了 。这些包装成exe的程序运行时都会将jar文件释放到临时目录，很容易获取 。常用的工具有exe4j、jsmooth、NativeJ等等 。jsmooth生成的exe运行时临时目录在exe所在目录中或是用户临时目录 中；exe4j生成的exe运行时临时目录在用户临时目录中；NativeJ生成的exe直接用winrar打开，然后用zip格式修复成一个jar文件，就得到了原文件 。如果只是为了使用和发布方便，不需要保护java代码 ， 使用这些工具是很好的选择 。2. java混淆器特点：使用一种或多种处理方式将class文件、java源代码进行混淆处理后生成新的class，使混淆后的代码不易被反编译 ， 而反编译后的代码难以阅 读和理解 。这类混淆器工具很多，而且也很有成效 。缺点：虽然混淆的代码反编译后不易读懂 ， 但对于有经验的人或是多花些时间，还是能找到或计算出你代码中隐藏的敏感内容，而且在很多应用中不是全部代码都能混淆的 ， 往往一些关键的库、类名、方法名、变量名等因使用要求的限制反而还不能混淆 。3. 隔离java程序到服务端特点：把java程序放到服务端，让用户不能访问到class文件和相关配套文件 ， 客户端只通过接口访问 。这种方式在客户/服务模式的应用中能较好地保护java代码 。缺点是：必须是客户/服务模式，这种特点限制了此种方式的使用范围；客户端因为逻辑的暴露始终是较为薄弱的环节，所以访问接口时一般都需要安全性认证 。4. java加密保护特点：自定义ClassLoader，将class文件和相关文件加密，运行时由此ClassLoader解密相关文件并装载类，要起到保护作用必须自定 义本地代码执行器将自定义ClassLoader和加密解密的相关类和配套文件也保护起来 。此种方式能很有效地保护java代码 。缺点：可以通过替换JRE包中与类装载相关的java类或虚拟机动态库截获java字节码 。jar2exe属于这类工具 。5. 提前编译技术(AOT)特点：将java代码静态编译成本地机器码 ， 脱离通用JRE 。此种方式能够非常有效地保护java代码，且程序启动比通用JVM快一点 。具有代表性的是GNU的gcj，可以做到对java代码完全提前编译，但gcj存在诸多局限性 ， 如：对JRE 5不能完整支持、不支持JRE 6及以后的版本 。由于java平台的复杂性，做到能及时支持最新java版本和JRE的完全提前编译是非常困难的，所以这类工具往往采取灵活方式 ， 该用即时编译的地方还是 要用，成为提前编译和即时编译的混合体 。缺点：由于与通用JRE的差异和java运用中的复杂性，并非java程序中的所有jar都能得到完全的保护；只能使用此种工具提供的一个运行环境，如果工具更新滞后或你需要特定版本的JRE ， 有可能得不到此种工具的支持 。Excelsior JET属于这类工具 。6. 使用jni方式保护特点：将敏感的方法和数据通过jni方式处理 。此种方式和“隔离java程序到服务端”有些类似，可以看作把需要保护的代码和数据“隔离”到动态库中，不同的是可以在单机程序中运用 。缺点和上述“隔离java程序到服务端”类似 。7. 不脱离JRE的综合方式保护特点：非提前编译，不脱离JRE，采用多种软保护方式，从多方面防止java程序被窃取 。此种方式由于采取了多种保护措施，比如自定义执行器和装载器、加密、JNI、安全性检测、生成可执行文件等等，使保护力度大大增强，同样能够非常有效地保护java代码 。缺点：由于jar文件存在方式的改变和java运用中的复杂性，并非java程序中的所有jar都能得到完全的保护；很有可能并不支持所有的JRE版本 。JXMaker属于此类工具 。8. 用加密锁硬件保护特点：使用与硬件相关的专用程序将java虚拟机启动程序加壳，将虚拟机配套文件和java程序加密，启动的是加壳程序，由加壳程序建立一个与硬件相关的 受保护的运行环境，为了加强安全性可以和加密锁内植入的程序互动 。此种方式与以上“不脱离JRE的综合方式保护”相似 ， 只是使用了专用硬件设备，也能很好地保护java代码 。缺点：有人认为加密锁用户使用上不太方便 ， 且每个安装需要附带一个 。从以上描述中我们可以看出：1. 各种保护方式都有其优缺点，应根据实际选用2. 要更好地保护java代码应该使用综合的保护措施3. 单机环境中要真正有效保护java代码，必须要有本地代码程序配合当然，安全都是相对的，一方面看你的保护措施和使用的工具能达到的程度 ， 一方面看黑客的意愿和能力，不能只从技术上保护知识产权 。总之，在java 代码保护方面可以采取各种可能的方式，不可拘泥于那些条条框框 。
java中，代码检查工具check-style检查出来的错误很多，请教各位，有什么快速修改的方法不某些错误产生并不一定代表程序无法编译通过java检查代码安全工具，而是不符合某个规范或用了比较旧版本java检查代码安全工具的jdk所导致的java检查代码安全工具，check-style应该可以设置错误类型的 ， 比如没有构造方法这样的错误就可以忽略的，别急，慢慢来 ， 一般调试别人的程序需要3-4周时间 ， 熟练了就好 。
怎么样才能写出安全的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 和他联系
最受欢迎的软件安全性测试工具有哪些？ 之前在做 国内软件测试现状调查 之时，因为安全性测试工具太多，结果显示其分布比较广 ， 填写“其它”占的比重很高（66%），为此专门做了一个调查 ， 虽然收集的有效反馈不多（不到100），但基本反映了测试工具的使用现状 。
1. 从总体看，（静态的）代码分析工具和（动态的）渗透测试工具应用还是比较普遍 ，超过60%，而且渗透测试工具（73.68%）略显优势，高出10% 。模糊测试工具，可能大家感觉陌生，低至16% ， 但它在安全性、可靠性测试中还是能发挥作用的 。从理论上看 ， 代码分析工具应该能达到95%以上，因为它易用，且安全性已经是许多公司的红线，得到足够重视 。希望以后各个公司能够加强代码分析工具和模糊测试工具的应用 。
2. Java代码安全性分析工具前三名是 ： IBM AppScan Source Edition（42.11%）、Fotify Static Code Analyzer（36.84%）、Findbugs（26.32%） ，而JTest、PMD等没进入前三名，虽然和第3名差距不大，只有5%左右 。也有公司使用Checkmarx ， 不在此调查中 。Coverity也支持Java，可能Java的开源工具较多，人们很少用它 。
3.C/C代码安全性分析工具前三名是 ： CTest（38.89%）、IBM AppScan Source Edition（38.89%）、Fotify Static Code Analyzer（27.78%）、Visual Studio（27.78%）。Coverity、CppCheck、LDRA Testbed 没能进入前三名，可能LDRA Testbed比较贵，关键的嵌入式软件采用比较多 ， 而Coverity Cloud针对Github等上面的代码有免费服务（），大家可以尝试应用 。
4. JavaScript代码安全性分析工具应用最多的是 Google's Closure Compiler，其次是JSHint，也有的公司用Coverity来进行JS的代码分析 。
5. Python代码安全性分析工具应用最多的是Pychecker，其次是PyCharm ， 而Pylint使用比较少，也有几个公司用Coverity来进行Python的代码分析 。
6. Web应用安全性测试的商用工具中 ， IBM AppScan异军突起 ，高达70%的市场，其它商用工具无法与它抗衡 ， 第2名SoapUI和它差距在50%以上 ， HP webInspect 不到10% 。
7. Web应用安全性测试的开源工具中，Firebug明显领先 ， 将近50%，比第2名OWASP ZAP高12%，第三名是Firefox Web Developer Tools，超过了20% 。
8. Android App的安全性测试工具中，Android Tamer领先 ，将近30%，比第2、3名AndroBugs、Mobisec、Santoku高15%左右 。也有用其它不在调查项中的工具 ， 总体看，Android App安全性测试工具分布比较散 。
9. 网络状态监控与分析工具中，Wireshark遥遥领先，超过70% 。其次就是Tcpdump、Burp Suite，占30%左右 。网络状态监控与分析工具挺多的，但从这次调查看，越来越集中到几个工具中 ， 特别是Wireshark功能强 ， 覆盖的协议比较多，深受欢迎 。
10. SQL注入测试工具排在前三位的：SQLInjector、SQL Power Injector、OWASP SQLiX， 三者比较接近，差距在6%左右 。其它两项工具Pangolin、SQLSqueal也占了10%，而Antonio Parata、Blind SQL Injections、Bsqlbf-v2、Multiple DBMS Sql Injection、Sqlninja几乎没什么人用 。
安全性测试工具很多，还包括黑客常用的一些工具，如暴力破解口令工具、端口扫描工具、防火墙渗透工具、渗透测试平台等 。从某种意义看，它们超出软件范畴，更多属于网络空间安全、密码学等范畴 ， 在此就不展开了 。概括起来最受欢迎的软件安全性测试工具有：
【java检查代码安全工具 java代码安全性】java检查代码安全工具的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java代码安全性、java检查代码安全工具的信息别忘了在本站进行查找喔 。

    推荐阅读


    上一篇：开车去西藏买什么手机好，想去西藏自驾游,应该买一辆什么样的车?

    下一篇：flutter按钮禁用，flutter button