java安全编码指南之:对象构建操作

简介

程序员肯定是不缺对象的,因为随时都可以构建一个,对象多了肯定会出现点安全问题,一起来看看在java的对象构建中怎么保证对象的安全性吧。

构造函数的异常

考虑下面的一个例子:

public class SensitiveOperation {

  public SensitiveOperation(){
    if(!doSecurityCheck()){
      throw new SecurityException("Security check failed!");
    }
  }

  //Security check return false
  private boolean doSecurityCheck(){
    return false;
  }

  public void storeMoney(){
    System.out.println("Store 1000000 RMB!");
  }
}

上面的例子中,我们在构造函数中做了一个securityCheck,因为这个securityCheck返回的值是false,所以会抛出SecurityException。

看下调用的例子:

  public static void main(String[] args) {
    SensitiveOperation sensitiveOperation = new SensitiveOperation();
    sensitiveOperation.storeMoney();
  }

这个调用会抛出下面的异常:

Exception in thread "main" java.lang.SecurityException: Security check failed!
 at com.flydean.SensitiveOperation.<init>(SensitiveOperation.java:11)
 at com.flydean.SensitiveUsage.main(SensitiveUsage.java:10)

那么问题来了,上面的这个class是不是安全的呢?

Finalizer Attack

上面的class不是final的,所以我们可以构造一个class去继承它。然后考虑这样一个问题,当构造函数抛出异常之后,会执行什么操作呢?

如果该对象已经被构建了,那么这个对象在GC的时候需要执行finalize方法。那么我们是不是可以在finalize方法中绕过安全检查呢?

看下面的例子:

public class SensitiveOperationFinalizer extends SensitiveOperation{

  public SensitiveOperationFinalizer(){
  }

  @Override
  protected void finalize() {
    System.out.println("We can still do store Money action!");
    this.storeMoney();
    System.exit(0);
  }
}

上的例子中,我们继承了SensitiveOperation,并且实现了finalize方法,在finalize中,我们调用了storeMoney。看下运行的代码:

  public void testFinalizer() throws InterruptedException {
    try {
    SensitiveOperation sensitiveOperation = new SensitiveOperationFinalizer();
      sensitiveOperation.storeMoney();
    }catch (Exception e){
      System.out.println(e.getMessage());
    }
    System.gc();
    Thread.sleep(10000);
  }

运行结果:

Security check failed!
We can still do store Money action!
Store 1000000 RMB!

可以看到,虽然我们构造函数抛出了异常,但是storeMoney的操作还是被执行了!

这个操作就叫做Finalizer Attack。

解决Finalizer Attack

怎么解决这个构造函数抛出异常的问题呢?这里给大家介绍几种解决方法。

使用final class

如果使用final class,那么类是不能够被继承的,问题自然就解决了。

public final class SensitiveOperationFinal {

  public SensitiveOperationFinal(){
    if(!doSecurityCheck()){
      throw new SecurityException("Security check failed!");
    }
  }

  //Security check return false
  private boolean doSecurityCheck(){
    return false;
  }

  public void storeMoney(){
    System.out.println("Store 1000000 RMB!");
  }
}

使用final finalize方法

因为子类想要重写finalize方法,如果我们的父类中finalize方法定义为final,也可以解决这个问题。

public final class SensitiveOperationFinal {

  public SensitiveOperationFinal(){
    if(!doSecurityCheck()){
      throw new SecurityException("Security check failed!");
    }
  }

  //Security check return false
  private boolean doSecurityCheck(){
    return false;
  }

  public void storeMoney(){
    System.out.println("Store 1000000 RMB!");
  }

  final protected void finalize() {
  }
}

使用flag变量

我们可以在对象构建完毕的时候设置一个flag变量,然后在每次安全操作的时候都去判断一下这个flag变量,这样也可以避免之前提到的问题:

public class SensitiveOperationFlag {

  private volatile boolean flag= false;

  public SensitiveOperationFlag(){
    if(!doSecurityCheck()){
      throw new SecurityException("Security check failed!");
    }
    flag=true;
  }

  //Security check return false
  private boolean doSecurityCheck(){
    return false;
  }

  public void storeMoney(){
    if(!flag){
      System.out.println("Object is not initiated yet!");
      return;
    }
    System.out.println("Store 1000000 RMB!");
  }
}

注意,这里flag需要设置为volatile,只有这样才能保证构造函数在flag设置之前执行。也就是说需要保证happens-before特性。

使用this或者super

在JDK6或者更高版本中,如果对象的构造函数在java.lang.Object构造函数退出之前引发异常,则JVM将不会执行该对象的finalize方法。

因为Java确保java.lang.Object构造函数在任何构造函数的第一条语句之上或之前执行。如果构造函数中的第一个语句是对超类的构造函数或同一个类中的另一个构造函数的调用,则java.lang.Object构造函数将在该调用中的某个位置执行。否则,Java将在该构造函数的代码中的任何一个执行之前执行超类的默认构造函数,并且将通过隐式调用执行java.lang.Object构造函数。

也就是说如果异常发生在构造函数中的第一条this或者super中的时候,JVM将不会调用对象的finalize方法:

public class SensitiveOperationThis {

  public SensitiveOperationThis(){
    this(doSecurityCheck());
  }

  private SensitiveOperationThis(boolean secure) {
  }

  //Security check return false
  private static boolean doSecurityCheck(){
     throw new SecurityException("Security check failed!");
  }

  public void storeMoney(){
    System.out.println("Store 1000000 RMB!");
  }
}

本文的例子:

learn-java-base-9-to-20/tree/master/security

以上这篇java安全编码指南之:对象构建操作就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • java安全编码指南之:表达式规则说明

    简介 在java编写过程中,我们会使用到各种各样的表达式,在使用表达式的过程中,有哪些安全问题需要我们注意的呢?一起来看看吧. 注意表达式的返回值 我们在使用JDK库的时候,一定要注意认真的读一下JDK中方法的含义和它的返回值. 有些返回值可能表示这个操作是否成功,有的返回值可能是方法操作的结果.我们看两个常见的例子: public void deleteFileWrong(){ File file= new File("/tmp/www.jb51.net.txt"); file.de

  • java安全编码指南之:Mutability可变性详解

    简介 mutable(可变)和immutable(不可变)对象是我们在java程序编写的过程中经常会使用到的. 可变类型对象就是说,对象在创建之后,其内部的数据可能会被修改.所以它的安全性没有保证. 而不可变类型对象就是说,对象一旦创建之后,其内部的数据就不能够被修改,我们可以完全相信这个对象. 虽然mutable对象安全性不够,但是因为其可以被修改,所以会有效的减少对该对象的拷贝. 而immutable对象因为不可改变,所以尝试对该对象的修改都会导致对象的拷贝,从而生成新的对象. 我们最常使用

  • java安全编码指南之:Number操作详解

    简介 java中可以被称为Number的有byte,short,int,long,float,double和char,我们在使用这些Nubmer的过程中,需要注意些什么内容呢?一起来看看吧. Number的范围 每种Number类型都有它的范围,我们看下java中Number类型的范围: 考虑到我们最常用的int操作,虽然int的范围够大,但是如果我们在做一些int操作的时候还是可能超出int的范围. 超出了int范围会发送什么事情呢?看下面的例子: public void testIntege

  • 在java中使用SPI创建可扩展的应用程序操作

    简介 什么是可扩展的应用程序呢?可扩展的意思是不需要修改原始代码,就可以扩展应用程序的功能.我们将应用程序做成插件或者模块. 这样可以在不修改原应用的基础上,对系统功能进行升级或者定制化. 本文将会向大家介绍如何通过java中的SPI机制实现这种可扩展的应用程序. SPI简介 SPI的全称是Java Service Provider Interface.是java提供的一种服务发现的机制. 通过遵循相应的规则编写应用程序之后,就可以使用ServiceLoader来加载相应的服务了. SPI的实现

  • java安全编码指南之:声明和初始化说明

    简介 在java对象和字段的初始化过程中会遇到哪些安全性问题呢?一起来看看吧. 初始化顺序 根据JLS(Java Language Specification)中的定义,class在初始化过程中,需要同时初始化class中定义的静态初始化程序和在该类中声明的静态字段(类变量)的初始化程序. 而对于static变量来说,如果static变量被定义为final并且它值是编译时常量值,那么该static变量将会被优先初始化. 那么使用了final static变量,是不是就没有初始化问题了呢? 我们来

  • Java开发中常用的 Websocket 技术参考

    1. 前言 Websocket是 HTML5 开始提供的一种在单个 TCP 连接上进行全双工通讯的协议.WebSocket 使得客户端和服务器之间的数据交换变得更加简单,允许服务端主动向客户端推送数据,当然也支持客户端发送数据到服务端.通常用来社交聊天.弹幕.多玩家游戏.协同编辑.股票基金实时报价.资讯自动更新等场景,那么今天就简单聊一下在 Java 开发中对Websocket的技术选型. 技术选型是结合自身业务选择最适合的技术方案,并不存在褒贬. 2. 常用的 Websocket 技术 2.1

  • java安全编码指南之:对象构建操作

    简介 程序员肯定是不缺对象的,因为随时都可以构建一个,对象多了肯定会出现点安全问题,一起来看看在java的对象构建中怎么保证对象的安全性吧. 构造函数的异常 考虑下面的一个例子: public class SensitiveOperation { public SensitiveOperation(){ if(!doSecurityCheck()){ throw new SecurityException("Security check failed!"); } } //Securit

  • 详解java安全编码指南之可见性和原子性

    不可变对象的可见性 不可变对象就是初始化之后不能够被修改的对象,那么是不是类中引入了不可变对象,所有对不可变对象的修改都立马对所有线程可见呢? 实际上,不可变对象只能保证在多线程环境中,对象使用的安全性,并不能够保证对象的可见性. 先来讨论一下可变性,我们考虑下面的一个例子: public final class ImmutableObject { private final int age; public ImmutableObject(int age){ this.age=age; } }

  • 浅谈java安全编码指南之死锁dead lock

    不同的加锁顺序 我们来看一个不同加锁顺序的例子: public class DiffLockOrder { private int amount; public DiffLockOrder(int amount){ this.amount=amount; } public void transfer(DiffLockOrder target,int transferAmount){ synchronized (this){ synchronized (target){ if(amount< tr

  • 浅谈java安全编码指南之堆污染

    产生堆污染的例子 有同学可能会问了,既然JDK5引入了泛型,为什么还会出现堆污染呢? 这是一个好问题,让我们看一个例子: public void heapPollution1(){ List normalList= Arrays.asList("www.flydean.com",100); List<Integer> integerList= normalList; } 上面的例子中,我们使用Arrays.asList创建了一个普通的List. 这个List中包含了int和

  • Java对象序列化操作详解

    本文实例讲述了Java对象序列化操作.分享给大家供大家参考,具体如下: 当两个进程在进行远程通信时,彼此可以发送各种类型的数据.无论是何种类型的数据,都会以二进制序列的形式在网络上传送.发送方需要把这个Java对象转换为字节序列,才能在网络上传送:接收方则需要把字节序列再恢复为Java对象. 只能将支持 java.io.Serializable 接口的对象写入流中.每个 serializable 对象的类都被编码,编码内容包括类名和类签名.对象的字段值和数组值,以及从初始对象中引用的其他所有对象

  • java对象序列化操作实例分析

    本文实例讲述了java对象序列化操作.分享给大家供大家参考,具体如下: 在java中可以将对象进行序列化操作 要使对象能够被序列化,那么被序列化的对象要实现接口Serializable,此接口位于java.io包中 pakacge demo; import java.io.Serializable; /** * 实现了Serializable 接口的demo类 */ public class Demo1 implements Serializable { private String name;

随机推荐