189 8069 5689

java恶意代码防范 恶意代码的危害及防范

asp防止java恶意代码

过滤和这两个符号就可以了,用Replace替换成 lt 和 gt 去掉中间空格

创新互联专注为客户提供全方位的互联网综合服务,包含不限于成都网站设计、成都做网站、湖口网络推广、小程序制作、湖口网络营销、湖口企业策划、湖口品牌公关、搜索引擎seo、人物专访、企业宣传片、企业代运营等,从售前售中售后,我们都将竭诚为您服务,您的肯定,是我们最大的嘉奖;创新互联为所有大学生创业者提供湖口建站搭建服务,24小时服务热线:13518219792,官方网址:www.cdcxhl.com

各种在线编译C语言,java等语言的编译器是如何防止用户提交的恶意代码在后台运行的?

添加审核功能,把有用的筛选下来,没用的去掉。或者加一个提交限制,用户提交的里面包含有恶意的内容就不让他提交。再或者你就不用提交到后台,在前台来编译,类似于HTML、json等的编译

java正则表达式怎么防止代码漏洞

javaWeb安全漏洞及处理方式

关注

转载自:

1、SQL注入攻击

SQL注入攻击就是通过把SQL命令插入到Web表单提交或输入域名或页面请求的查询字符串,最终达到欺骗服务器执行恶意的SQL命令。具体来说,它是利用现有应用程序,将(恶意)的SQL命令注入到后台数据库引擎执行的能力,它可以通过在Web表单中输入(恶意)SQL语句得到一个存在安全漏洞的网站上的数据库,而不是按照设计者意图去执行SQL语句。

随着B/S框架结构在系统开发中的广泛应用,恶意攻击者利用SQL命令在Web表单中输入合法的字符或查询字符串来欺骗服务器执行SQL命令。当注入攻击得逞后,Web程序将泄露大量用户隐私数据和数据库中数据结构。攻击者能够获得系统较高的访问权限,进行破坏操作。

SQL注入可以分为平台层注入和代码层注入。前者由不安全的数据库配置或数据库平台的漏洞所致;后者主要是由于程序员对输入未进行细致地过滤,从而执行了非法的数据查询。基于此,SQL注入的产生原因通常表现在以下几方面:

1)不当的类型处理;

2)不安全的数据库配置;

3)不合理的查询集处理;

4)不当的错误处理;

5)转义字符处理不合适;

6) 多个提交处理不当。

解决方法:

数据库安全通信包括SQL注入攻击的防范、安全设置、异常信息处理三个方面。

1.服务端Filter对访问者输入的字符进行过滤检验,但是攻击者经常把危险字符潜藏在用户输入的有效字符中完 成过滤检验。

2.通过正则表达式对页面的文本框输入的数据进行限制可以减少过滤检验存在的漏洞。

3.使用prepareStatment预编译sql语句

2、XSS跨站脚本攻击

跨站脚本(Cross-site scripting,简称XSS),是一种迫使Web站点回显可执行代码的攻击技术,而这些可执行代码由攻击者提供、最终为用户浏览器加载。不同于大多数攻击(一般只涉及攻击者和受害者),XSS涉及到三方,即攻击者、客户端与网站。XSS的攻击目标是为了盗取客户端的cookie或者其他网站用于识别客户端身份的敏感信息。获取到合法用户的信息后,攻击者甚至可以假冒最终用户与网站进行交互。

XSS 属于被动式的攻击。攻击者先构造一个跨站页面,利用SCRIPT、IMG、IFRAME等各种方式使得用户浏览这个页面时,触发对被攻击站点的HTTP 请求。此时,如果被攻击者如果已经在被攻击站点登录,就会持有该站点cookie。这样该站点会认为被攻击者发起了一个HTTP请求。而实际上这个请求是在被攻击者不知情情况下发起的,由此攻击者在一定程度上达到了冒充被攻击者的目的。精心的构造这个攻击请求,可以达到冒充发文,夺取权限等多个攻击目的。在常见的攻击实例中,这个请求是通过script 来发起的,因此被称为Cross Site Script。

XSS漏洞成因是由于动态网页的Web应用对用户提交请求参数未做充分的检查过滤,允许用户在提交的数据中掺入HTML代码(最主要的是“”、“”),然后未加编码地输出到第三方用户的浏览器,这些攻击者恶意提交代码会被受害用户的浏览器解释执行。

分为三种类型:

1)反射型(数据流向:浏览器 -后端 - 浏览器)

反射型XSS脚本攻击即如我们上面所提到的XSS跨站脚本攻击方式,该类型只是简单地将用户输入的数据直接或未经过完善的安全过滤就在浏览器中进行输出,导致输出的数据中存在可被浏览器执行的代码数据。由于此种类型的跨站代码存在于URL中,所以黑客通常需要通过诱骗或加密变形等方式,将存在恶意代码的链接发给用户,只有用户点击以后才能使得攻击成功实施。

2)存储型(数据流向是:浏览器 -后端 - 数据库 - 后端- 浏览器)

存储型XSS脚本攻击是指Web应用程序会将用户输入的数据信息保存在服务端的数据库或其他文件形式中,网页进行数据查询展示时,会从数据库中获取数据内容,并将数据内容在网页中进行输出展示,因此存储型XSS具有较强的稳定性。

存储型XSS脚本攻击最为常见的场景就是在博客或新闻发布系统中,黑客将包含有恶意代码的数据信息直接写入文章或文章评论中,所有浏览文章或评论的用户,都会在他们客户端浏览器环境中执行插入的恶意代码。

3)基于DOM(数据流向是:URL--浏览器 )

基于DOM的XSS跨站脚本攻击是通过修改页面DOM节点数据信息而形成的XSS跨站脚本攻击。不同于反射型XSS和存储型XSS,基于DOM的XSS跨站脚本攻击往往需要针对具体的javascript DOM代码进行分析,并根据实际情况进行XSS跨站脚本攻击的利用。

解决方法:

1).输入过滤。对用户的所有输入数据进行检测,比如过滤其中的“”、“”、“/”等可能导致脚本注入的特殊字符,或者过滤“script”、“javascript”等脚本关键字,或者对输入数据的长度进行限制等等。同时,我们也要考虑用户可能绕开ASCII码,使用十六进制编码来输入脚本。因此,对用户输入的十六进制编码,我们也要进行相应的过滤。只要能够严格检测每一处交互点,保证对所有用户可能的输入都进行检测和XSS过滤,就能够有效地阻止XSS攻击。

2).输出编码。通过前面对XSS攻击的分析,我们可以看到,之所以会产生XSS攻击,就是因为Web应用程序将用户的输入直接嵌入到某个页面当中,作为该页面的HTML代码的一部分。因此,当Web应用程序将用户的输入数据输出到目标页面中时,只要用HtmlEncoder等工具先对这些数据进行编码,然后再输出到目标页面中。这样,如果用户输入一些HTML的脚本,也会被当成普通的文字,而不会成为目标页面HTML代码的一部分得到执行.

3、CSRF跨站请求伪造漏洞防护

CSRF是CrossSite Request Forgery的缩写,乍一看和XSS差不多的样子,但是其原理正好相反,XSS是利用合法用户获取其信息,而CSRF是伪造成合法用户发起请求。

字面理解意思就是在别的站点伪造了一个请求。专业术语来说就是在受害者访问一个网站时,其 Cookie 还没有过期的情况下,攻击者伪造一个链接地址发送受害者并欺骗让其点击,从而形成 CSRF 攻击。

根据HTTP协议,在HTTP头中有一个字段叫Referer,它记录了该HTTP请求的来源地址。在通常情况下,访问一个安全受限页面的请求必须来自于同一个网站。

解决方案:

配置FILTER拦截用户所有请求(POST/GET),对用户请求Referer头URL进行合法性校验。

4、URL链接注入漏洞防护

链接注入是修改站点内容的行为,其方式为将外部站点的 URL 嵌入其中,或将有易受攻击的站点中的脚本 的 URL 嵌入其中。将URL 嵌入易受攻击的站点中,攻击者便能够以它为平台来启动对其他站点的攻击,以及攻击这个易受攻击的站点本身。

解决方案:

1,二次验证,进行重要敏感操作时,要求用户进行二次验证。

2,验证码,进行重要敏感操作时,加入验证码。

3,验证 HTTP 的 Referer 字段。

4,请求地址中添加 Token 并验证。

5,HTTP 头中自定义属性并验证。

5、会话COOKIE中缺少HttpOnly防护

会话cookie中缺少HttpOnly属性会导致攻击者可以通过程序(JS脚本、Applet等)获取到用户的cookie信息,造成用户cookie信息泄露,增加攻击者的跨站脚本攻击威胁。

HttpOnly是微软对cookie做的扩展,该值指定cookie是否可通过客户端脚本访问。Microsoft Internet Explorer 版本 6 Service Pack 1 和更高版本支持cookie属性HttpOnly。

如果在Cookie中没有设置HttpOnly属性为true,可能导致Cookie被窃取。窃取的Cookie可以包含标识站点用户的敏感信息。

如果在Cookie中设置HttpOnly属性为true,兼容浏览器接收到HttpOnly cookie,那么客户端通过程序(JS脚本、Applet等)将无法读取到Cookie信息,这将有助于缓解跨站点脚本威胁。

解决方案:

配置filter拦截器,将服务器端返回请求,向所有会话cookie中添加“HttpOnly”属性。

示例代码:

HttpServletResponseresponse=(HttpServletResponse)paramServletResponse;

response.setHeader("SET-COOKIE","JSESSIONID=" + sessionid + "; HttpOnly");

6、点击劫持漏洞(Clickjacking)防护

点击劫持是一种视觉上的欺骗手段,攻击者使用一个透明的、不可见的iframe,覆盖在一个网页上,然后诱使用户在该网页上进行操作,此时用户在不知情的情况下点击了透明的iframe页面。通过调整iframe页面的位置,可以诱使用户恰好点击在iframe页面的一些功能性按钮上。

解决方案:

配置FILTER拦截器,在服务器端返回请求中,使用一个HTTP头“X-Frame-Options”值为SAMEORIGIN-同源策略 ,则frame页面的地址只能为同源域名下面的页面,防止点击劫持漏洞发生。

示例代码:

HttpServletResponseresponse=(HttpServletResponse)paramServletResponse;

response.addHeader("x-frame-options","SAMEORIGIN");

7、HTTP host 头攻击漏洞

使用HTTP代理工具,可以篡改HTTP报文头部中HOST字段时,该值可被注入恶意代码。因为需要控制客户端的输入,故该漏洞较难利用。

解决方案:

配置FILTER拦截器,对请求输入HOST头信息进行信息安全性校验,防止HOST头信息被恶意篡改利用。

示例代码:

HttpServletRequest request =(HttpServletRequest)servletRequest;

//主机ip和端口 或 域名和端口

String myhosts = request.getHeader("host");

if(!StringUtils.equals(myhosts, "xx.xx.xxx.xxx:xxxx")

!StringUtils.equals(myhosts, "xx.xx.xxx.xxx:xxxx")

!StringUtils.equals(myhosts,"xx.xx.xxx.xxx:xxxx")StringUtils.equals(myhosts,"xx.xx.xxx.xxx")

!StringUtils.equals(myhosts,"xx.xx.xxx.xxx") !StringUtils.equals(myhosts,"xx.xx.xxx.xxx" ){

logger.error("======访问host非法,已拦截======");

response.sendRedirect(request.getContextPath() + "/login.jsp");

return;

}

8、越权访问漏洞防护

越权访问(Broken Access Control,简称BAC)是Web应用程序中一种常见的漏洞,分为垂直越权访问和水平越权访问。垂直越权是指不同用户级别之间的越权,如普通用户执行管理员用户的权限。水平越权是指相同级别用户之间的越权操作。

Web应用程序如果存在越权访问漏洞,可能导致以下危害:

1)导致任意用户敏感信息泄露;

2)导致任意用户信息被恶意修改或删除。

解决方案:

配置FILTER拦截器,对请求所有URL进行拦截,对于需要进行授权的URL进行权限校验,防止用户越权访问系统资源。

9.弱口令漏洞

解决方案:最好使用至少6位的数字、字母及特殊字符组合作为密码。数据库不要存储明文密码,应存储MD5加密后的密文,由于目前普通的MD5加密已经可以被破解,最好可以多重MD5加密,或者多种加密方式叠加组合。

10.JSP页面抛出的异常可能暴露程序信息。

有经验的入侵者,可以从JSP程序的异常中获取很多信息,比如程序的部分架构、程序的物理路径、SQL注入爆出来的信息等。

解决方案:自定义一个Exception,将异常信息包装起来不要抛到页面上。

11.本地缓存漏洞

合法用户“注销”后,在未关闭浏览器的情况下,点击浏览器“后退”按钮,可从本地页面缓存中读取数据,绕过了服务端filter过滤。

解决方案:配置filter对存放敏感信息的页面限制页面缓存。如:

httpResponse.setHeader("Cache-Control","no-cache");

httpResponse.setHeader("Cache-Control","no-store");

httpResponse.setDateHeader("Expires",0);

httpResponse.setHeader("Pragma","no-cache");

12.文件上传漏洞。

前台仅使用JS对文件后缀做了过滤,这只能针对普通的用户,而恶意攻击者完全可以修改表单去掉JS校验。

13.Java WEB容器默认配置漏洞。

如TOMCAT后台管理漏洞,默认用户名及密码登录后可直接上传war文件获取webshell。

解决方案:最好删除,如需要使用它来管理维护,可更改其默认路径,口令及密码。

怎么样才能写出安全的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的安全机制有哪些?

》类装载器结构

(class

loader)

》class文件检查器

(the

class

file

verifier)

》内置于Java虚拟机(及语言)的安全特性

》安全管理器及Java

API

(security

manager)

在Java沙箱中,类装载器体系结构是第一道防线。它在三个方面对Java的沙箱起作用:

1它防止恶意代码区干涉善意的代码

2它守护了被信任的代码的边界

3它将代码归于某类(称为保护域),该类确定了代码可以进行哪种操作

Class文件检查器:

Class文件检查器保证装载的class文件内容有正确的内部结构,并且这些class文件互相间协调一致。Class文件检查器实现的安全目标之一就是程序的健壮性。如果某个有漏洞的编译器,或某个聪明的黑客,产生了一个class文件,而这个class文件中包含了一个方法,则合格方法的字节码中含有一条跳转到方法之外的指令,那么,一旦这个方法被调用,它将导致虚拟机的崩溃,所以,处于对健壮性的考虑,由虚拟机检验它装载的字节码的完整性非常重要。

Class文件检查器要进行四趟独立的扫描来完成它的操作。

第一趟:Class文件的结构检查

在这一趟扫描中,对每一段将被当做类型导入的字节序列,Class文件检查器都会确认它是否符合JavaClass文件的节本结构。在这一趟检查中检查器会进行很多检查例如:每个Class文件都必须以四个同样的字节开始:0xCAFEBABE。因为这个魔数Class文件分析器会很容易判断出某个文件具有明显问题而加以拒绝。检查器还必须确认在Class文件中声明的版本号和次版本号,这个版本号必须在这个虚拟机实现可以支持的范围之内。而且第一趟扫描还必须确认这个Class文件有没有被删减。总之第一趟扫描的目的就是保证这个字节序列正确的定义了一个新类型。

第二趟:类型数据的语义检查

第二趟扫描,检查器要查看每个组成部分,确认它们是否是其所属类型的实例,他们的结构是否正确。另外还要检查这个类本身是否符合特定的条件,它们是由Java编程语言规定的。例如,检查器强制规定除Object类以外的类必须有一个超类,或者检查final类有没有被子化等。

第三趟:字节码验证

这一趟是要确保采用任何路径在字节码流中都得到一个确定的操作码,确保操作数栈总是包含正确的数值以及正确的类型。

第四趟:符号引用的验证

在动态链接的过程中,如果包含在一个Class文件中的符号引用被解析时,Class文件检查器要进行第四趟检查。第四趟扫描仅仅是动态链接过程的一部分。当一个Class文件被装载时,它包含了对其他类的符号引用以及它们的字段和方法。一个符号引用是一个字符串,它给出了名字,并且可能还包含了其他关于这个被引用项的信息------这些信息必须足以唯一的识别一个类、方法、字段。这样对于其他类的符号引用必须给出这个类的全名;对于其他类的字段的符号引用必须给出类名、字段名以及字段描述符;对于其他类中的方法的引用必须给出类名、方法名以及方法的描述符。

所谓的动态链接是一个将符号引用解析为直接引用的过程。

此外,由于Java程序是动态链接的,所以Class文件检查器在进行第四次扫描中,必须检查相互引用类之间的兼容性。

除此之外,Java虚拟机还有一些内置的安全特性:

》类型安全的引用转换

》结构化的内存访问

》自动垃圾收集(不必显式地释放被分配的内存)

》空引用检查

通过保证一个Java程序只能使用类型安全的、结构化的方法去访问内存,Java虚拟机使得Java程序更为健壮。


文章标题:java恶意代码防范 恶意代码的危害及防范
文章网址:http://cdxtjz.cn/article/hgpeij.html

其他资讯