精华内容
参与话题
问答
  • 华为java安全编码规范考试3.1 血与泪整理除的答案,当前时间保证是最新的,基本所有题都能找到。有几题答案没写出来,但是写了所有的错误答案…………排除法
  • java安全编码标准

    2018-05-24 12:30:00
    https://wiki.sei.cmu.edu/confluence/display/java/IDS00-J.+Prevent+SQL+injection 转载于:https://www.cnblogs.com/SEC-fsq/p/9082277.html

    https://wiki.sei.cmu.edu/confluence/display/java/IDS00-J.+Prevent+SQL+injection

    转载于:https://www.cnblogs.com/SEC-fsq/p/9082277.html

    展开全文
  • java安全编码标准》是java安全编码领域最权威、最全面、最详细的著作,java之父james a. gosling推荐。
  • java安全编码

    2020-10-21 11:08:58
    平台安全 其他 数据校验 外部来源的不可信数据,跨信任边界传递到目标系统前,必须进行校验。包括输入校验和输出校验。 接受已知好的数据。例如正则约束。 拒绝已知坏的数据。 例如,拒绝接受javascript字符串...
    • 数据校验
    • 方法与表达式
    • 数值与运算
    • 异常行为
    • 线程同步
    • I/O操作
    • 序列化与反序列化
    • 平台安全
    • 其他

    数据校验

    外部来源的不可信数据,跨信任边界传递到目标系统前,必须进行校验。包括输入校验和输出校验。

    • 接受已知好的数据。例如正则约束。

    • 拒绝已知坏的数据。
      例如,拒绝接受javascript字符串内容。是较弱的方式,需要一直维护约束集合。

    • ‘白名单’式净化
      将不可信数据净化,例如’ ! 'URL编码为%21。

    • '黑名单’式净化
      转化不可信数据,例如"\'"编码为"’" 。缺点是需要维护转化列表。

    对不可信数据校验时,禁止使用assert语句,原因:assert断言依赖于运行时属性,可被禁用,导致所有的校验失效。
    
    展开全文
  • 不仅从语言角度系统而详细地阐述java安全编码的要素、标准、规范和最佳实践,而且从架构设计的角度分析了java api存在的设计缺陷和可能存在的安全风险,以及应对的策略和措施。可以将本书作为java安全方面的工具书,...
  • Java安全编码标准

    2019-01-08 08:02:34
    Java安全编码标准》 基本信息 原书名:The CERT Oracle Secure Coding Standard for Java 作者: (美)Fred Long Dhruv Mohindra Robert C. Seacord Dean F. Sutherland David Svoboda 译者: 计文柯 杨晓春 ...
    《Java安全编码标准》
    基本信息
    原书名:The CERT Oracle Secure Coding Standard for Java
    作者: (美)Fred Long Dhruv Mohindra Robert C. Seacord Dean F. Sutherland David Svoboda
    译者: 计文柯 杨晓春
    丛书名: 华章程序员书库
    出版社:机械工业出版社
    ISBN:9787111428183
    上架时间:2013-6-13
    出版日期:2013 年6月
    开本:16开
    页码:1
    版次:1-1
    所属分类:计算机
    更多关于 》》》《Java安全编码标准
    内容简介
    计算机书籍
      《java安全编码标准》是java安全编码领域最权威、最全面、最详细的著作,java之父james a. gosling推荐。不仅从语言角度系统而详细地阐述java安全编码的要素、标准、规范和最佳实践,而且从架构设计的角度分析了java api存在的设计缺陷和可能存在的安全风险,以及应对的策略和措施。可以将本书作为java安全方面的工具书,根据自己的需要,找到自己感兴趣的规则进行阅读和理解,或者在实际开发中遇到安全问题时,根据书中列出的大致分类对规则进行索引和阅读,也可以通读全书的所有规则,系统地了解java安全规则,增强对java安全特性、语言使用、运行环境特性的理解。本书能指导java软件工程师设计出高质量的、安全的、可靠的、强大的、有弹性的、可用性和可维护性高的软件系统。
       《java安全编码标准》内容非常全面,包括基于java se 6平台的一系列应用于java语言和类库的安全编码规则,并且对这一系列规则进行了分类,包括输入数据验证、声明和初始化、表达式、数值类型和操作、面向对象、方法使用、异常处理、可见性和原子性、锁、线程、输入输出、序列化、平台安全特性、java运行环境等重要方面,对每一个方面所涉及的安全编码要素、规范和标准进行了详细阐释。
    目录
    《java安全编码标准》
    译者序
    前言
    致谢
    第1章 概述1
    1.1 错位的信任1
    1.2 注入攻击2
    1.3 敏感数据泄露3
    1.4 效能泄露5
    1.5 拒绝服务6
    1.6 序列化8
    1.7 并发性、可见性和内存8
    1.8 最低权限原则14
    1.9 安全管理器15
    1.10 类装载器16
    1.11 小结16
    第2章 输入验证和数据净化(ids)17
    规则17
    风险评估概要17
    .2.1 ids00-j净化穿越受信边界的非受信数据18
    2.2 ids01-j验证前标准化字符串26
    2.3 ids02-j在验证之前标准化路径名28
    2.4 ids03-j不要记录未经净化的用户输入31
    2.5 ids04-j限制传递给zipinputstream的文件大小33
    2.6 ids05-j使用ascii字符集的子集作为文件名和路径名35
    2.7 ids06-j从格式字符串中排除用户输入37
    2.8 ids07-j不要向runtime.exec()?方法传递非受信、未净化的数据38
    2.9 ids08-j净化传递给正则表达式的非受信数据41
    2.10 ds09-j如果没有指定适当的locale,不要使用locale相关方法处理与locale相关的数据44
    2.11 ids10-j不要拆分两种数据结构中的字符串45
    2.12 ids11-j在验证前去掉非字符码点50
    2.13 ids12-j在不同的字符编码中无损转换字符串数据51
    2.14 ids13-j在文件或者网络i/o两端使用兼容的编码方式53
    第3章 声明和初始化(dcl)56
    规则56
    风险评估概要56
    3.1 dcl00-j防止类的循环初始化56
    3.2 dcl01-j不要重用java标准库的已经公开的标识59
    3.3 dcl02-j将所有增强for语句的循环变量声明为final类型60
    第4章 表达式(exp)63
    规则63
    风险评估概要63
    4.1 exp00-j不要忽略方法的返回值63
    4.2 exp01-j不要解引用空指针65
    4.3 exp02-j使用两个参数的arrays.equals()方法来比较两个数组的内容67
    4.4 exp03-j不要用相等操作符来比较两个基础数据类型的值67
    4.5 exp04-j确保使用正确的类型来自动封装数值72
    4.6 exp05-j不要在一个表达式中对同一变量进行多次写入73
    4.7 exp06-j不要在断言中使用有副作用的表达式76
    第5章 数值类型与运算(num)78
    规则78
    风险评估概要78
    5.1 num00-j检测和避免整数溢出79
    5.2 num01-j不要对同一数据进行位运算和数学运算85
    5.3 num02-j确保除法运算和模运算中的除数不为088
    5.4 num03-j使用可容纳无符号数据合法取值范围的整数类型89
    5.5 num04-j不要使用浮点数进行精细计算90
    5.6 num05-j不要使用非标准化数92
    5.7 num06-j使用strictfp修饰符确保跨平台浮点运算的一致性94
    5.8 num07-j不要尝试与nan进行比较97
    5.9 num08-j检查浮点输入特殊的数值98
    5.10 num09-j不要使用浮点变量作为循环计数器100
    5.11 num10-j不要从浮点字元构造bigdecimal对象101
    5.12 num11-j不要比较或者审查以字符串表达的浮点数值102
    5.13 num12-j确保将数值转换成较小类型时不会产生数据丢失或曲解103
    5.14 num13-j转换基本整数类型至浮点类型时应避免精度损失107
    第6章 面向对象(obj)110
    规则110
    风险评估概要110
    6.1 obj00-j只有受信子类能对具有不变性的类和方法进行扩展111
    6.2 obj01-j声明数据成员为私有并提供可访问的封装器方法116
    6.3 obj02-j当改变基类时,保存子类之间的依赖关系118
    6.4 obj03-j在新代码中,不要混用具有泛型和非泛型的原始数据类型124
    6.5 obj04-j为可变类提供复制功能,并通过此功能允许将实例传递给非受信代码128
    6.6 obj05-j在返回引用之前,防御性复制私有的可变的类成员132
    6.7 obj06-j对可变输入和可变的内部组件创建防御性复制136
    6.8 obj07-j不允许敏感类复制其自身138
    6.9 obj08-j不要在嵌套类中暴露外部类的私有字段141
    6.10 obj09-j比较类而不是类名称143
    6.11 obj10-j不要使用公有静态的非final变量144
    6.12 obj11-j小心处理构造函数抛出异常的情况146
    第7章 方法(met)153
    规则153
    风险评估概要153
    7.1 met00-j验证方法参数154
    7.2 met01-j不要使用断言验证方法参数156
    7.3 met02-j不要使用弃用的或过时的类和方法157
    7.4 met03-j进行安全检测的方法必须声明为private或final158
    7.5 met04-j不要增加被覆写方法和被隐藏方法的可访问性160
    7.6 met05-j确保构造函数不会调用可覆写的方法161
    7.7 met06-j不要在clone()中调用可覆写的方法163
    7.8 met07-j不要定义类方法来隐藏基类或基类接口中声明的方法165
    7.9 met08-j确保比较等同的对象能得到相等的结果167
    7.10 met09-j定义了equlas()方法的类必须定义hashcode()方法174
    7.11 met10-j实现compareto()方法时遵守常规合约176
    7.12 met11-j确保比较中的关键码是不可变的178
    7.13 met12-j不要使用析构函数182
    第8章 异常行为(err)187
    规则187
    风险评估概要187
    8.1 err00-j不要消除或忽略可检查的异常187
    8.2 err01-j不能允许异常泄露敏感信息192
    8.3 err02-j记录日志时应避免异常196
    8.4 err03-j在方法失败时恢复对象先前的状态197
    8.5 err04-j不要在finally程序段非正常退出201
    8.6 err05-j不要在finally程序段中遗漏可检查异常202
    8.7 err06-j不要抛出未声明的可检查异常205
    8.8 err07-j不要抛出runtimeexception、exception或throwable209
    8.9 err08-j不要捕捉nullpointerexception或任何它的基类210
    8.10 err09-j禁止非受信代码终止jvm216
    第9章 可见性和原子性(vna)219
    规则219
    风险评估概要219
    9.1 vna00-j当需要读取共享基础数据类型变量时,需要保证其可见性219
    9.2 vna01-j保证对一个不可变对象的共享引用的可见性222
    9.3 vna02-j保证对于共享变量的组合操作是原子性的225
    9.4 vna03-j即使每一个方法都是相互独立并且是原子性的,也不要假设一组调用是原子性的230
    9.5 vna04-j保证串联在一起的方法调用是原子性的235
    9.6 vna05-j保证在读写64位的数值时的原子性239
    第10章 锁(lck)241
    规则241
    风险评估概要241
    10.1 lck00-j通过私有final锁对象可以同步那些与非受信代码交互的类242
    10.2 lck01-j不要基于那些可能被重用的对象进行同步246
    10.3 lck02-j不要基于那些通过getclass()返回的类对象来实现同步249
    10.4 lck03-j不要基于高层并发对象的内置锁来实现同步252
    10.5 lck04-j即使集合是可访问的,也不要基于集合视图使用同步253
    10.6 lck05-j对那些可以被非受信代码修改的静态字段,需要同步进入255
    10.7 lck06-j不要使用一个实例锁来保护共享静态数据256
    10.8 lck07-j使用相同的方式请求和释放锁来避免死锁258
    10.9 lck08-j在异常条件时,保证释放已经持有的锁266
    10.10 lck09-j不要执行那些持有锁时会阻塞的操作270
    10.11 lck10-j不要使用不正确形式的双重锁定检查惯用法273
    10.12 lck11-j当使用那些不能对锁策略进行承诺的类时,避免使用客户端锁定277
    第11章 线程api(thi)282
    规则282
    风险评估概要282
    11.1 thi00-j不要调用thread.run()282
    11.2 thi01-j不能调用threadgroup方法284
    11.3 thi02-j通知所有等待中的线程而不是单一线程287
    11.4 thi03-j始终在循环中调用wait()和await()方法292
    11.5 thi04-j确保可以终止受阻线程295
    11.6 thi05-j不要使用thread.stop()来终止线程300
    第12章 线程池(tps)304
    规则304
    风险评估概要304
    12.1 tps00-j使用线程池处理流量突发以实现降低性能运行304
    12.2 tps01-j不要使用有限的线程池来执行相互依赖的任务307
    12.3 tps02-j确保提交至线程池的任务是可中断的312
    12.4 tps03-j确保线程池中正在执行的任务不会失败而不给出任何提示315
    12.5 tps04-j使用线程池时,确保threadlocal变量可以重新初始化318
    第13章 与线程安全相关的其他规则(tsm)323
    规则323
    风险评估概要323
    13.1 tsm00-j不要使用非线程安全方法来覆写线程安全方法323
    13.2 tsm01-j不要让this引用在创建对象时泄漏326
    13.3 tsm02-j不要在初始化类时使用后台线程332
    13.4 tsm03-j不要发布部分初始化的对象336
    第14章 输入输出(fio)342
    规则342
    风险评估概要342
    14.1 fio00-j不要操作共享目录中的文件343
    14.2 fio01-j使用合适的访问权限创建文件351
    14.3 fio02-j发现并处理与文件相关的错误352
    14.4 fio03-j在终止前移除临时文件354
    14.5 fio04-j在不需要时关闭资源357
    14.6 fio05-j不要使用wrap()或duplicate()创建缓存,并将这些缓存暴露给非受信代码361
    14.7 fio06-j不能在一个单独的inputstream上创建多个缓存区封装器364
    14.8 fio07-j不要让外部进程阻塞输入和输出流367
    14.9 fio08-j对读取一个字符或者字节的方法,使用int类型的返回值370
    14.10 fio09-j不要使用write()方法输出超过0~255的整数372
    14.11 fio10-j使用read()方法保证填充一个数组373
    14.12 fio11-j不要将原始的二进制数据作为字符数据读入375
    14.13 fio12-j为小端数据的读写提供方法376
    14.14 fio13-j不要在受信边界之外记录敏感信息379
    14.15 fio14-j在程序终止时执行正确的清理动作381
    第15章 序列化(ser)387
    规则387
    风险评估概要387
    15.1 ser00-j在类的演化过程中维护其序列化的兼容性388
    15.2 ser01-j不要偏离序列化方法的正确签名390
    15.3 ser02-j在将对象向信任边界之外发送时,需要签名并且封装敏感对象392
    15.4 ser03-j不要序列化未经加密的敏感数据397
    15.5 ser04-j不要允许序列化和反序列化绕过安全管理器401
    15.6 ser05-j不要序列化内部类实例404
    15.7 ser06-j在反序列化时,对私有的可变的组件进行防御性复制405
    15.8 ser07-j不要对实现定义的不可变因素使用默认的序列化格式406
    15.9 ser08-j在从拥有特性的环境中进行反序列化之前最小化特权410
    15.10 ser09-j不要从readobject()方法中调用可以被覆写的方法413
    15.11 ser10-j在序列化时,避免出现内存和资源泄漏414
    15.12 ser11-j防止覆盖外部化的对象415
    第16章 平台安全性(sec)417
    规则417
    风险评估概要417
    16.1 sec00-j不要允许特权代码块越过受信边界泄露敏感信息417
    16.2 sec01-j不要在特权代码块中使用污染过的变量420
    16.3 sec02-j不要基于非受信源进行安全检查422
    16.4 sec03-j不要在允许非受信代码装载任意类之后装载受信类424
    16.5 sec04-j使用安全管理器检查来保护敏感操作426
    16.6 sec05-j不要使用反射来增加类、方法和字段的可访问性429
    16.7 sec06-j不要依赖于默认的由urlclassloader和java.util.jar提供的自动化签名检查434
    16.8 sec07-j当编写一个自定义的类装载器时调用基类的getpermissions()方法437
    16.9 sec08-j定义基于原生方法的封装器438
    第17章 运行环境(env)441
    规则441
    风险评估概要441
    17.1 env00-j不要签名只执行非特权操作的代码441
    17.2 env01-j将所有安全敏感的代码置于单独一个jar包中,并且在签名之后封装它443
    17.3 env02-j不要信任环境变量的值446
    17.4 env03-j不要赋予危险的权限组合448
    17.5 env04-j不要关闭字节码验证功能451
    17.6 env05-j不要部署一个被远程监视的应用452
    第18章 其他(msc)457
    规则457
    风险评估概要457
    18.1 msc00-j在交换安全数据时使用sslsocket而不是socket457
    18.2 msc01-j不要使用空的无限循环461
    18.3 msc02-j生成强随机数462
    18.4 msc03-j不要硬编码敏感信息464
    18.5 msc04-j防止内存泄漏466
    18.6 msc05-j不要耗尽堆空间473
    18.7 msc06-j当一个遍历正在进行时,不要修改它对应的集合477
    18.8 msc07-j防止多次实例化单例对象481
    术语表490
    参考资源497
    图书信息来源:互动出版网

     

    展开全文
  • JAVA安全编码标准

    2019-12-06 14:10:34
    以下内容摘取自《JAVA安全编码标准》,略做修改和补充解释,这是一个把书读薄和知识串通的过程 文章目录 一、输入验证和数据净化 二、声明和初始化 三、表达式 四、数值类型与运算 五、面向对象 六、方法 七、异常...

    以下内容摘取自《JAVA安全编码标准》,略做修改和补充解释,这是一个把书读薄和知识串通的过程

    文章目录

    一、输入验证和数据净化
    二、声明和初始化
    三、表达式
    四、数值类型与运算
    五、面向对象
    六、方法
    七、异常行为
    八、可见性和原子性
    九、锁
    十、线程API
    十一、线程池
    十二、与线程安全相关的其他规则
    十三、输入输出
    十四、序列化
    十五、平台安全性
    十六、其他

    一、输入验证和数据净化

    • 1、净化穿越受信边界的非受信数据,比如使用PreparedStatement防止SQL注入漏洞
    • 2、验证前规范化字符串,比如使用Unicode编码防止XSS跨站脚本漏洞
    • 3、在验证之前标准化路径名,使用file.getCannonicalPath()特殊处理软连接、”.”、“..”、相对路径,避免目录遍历漏洞
    • 4、不要记录未经净化的用户输入,以免注入,从而让管理员误以为系统行为
    • 5、限制传递给ZipInputStream的文件大小,通过ZipEntry.getSize()在解压前判断,如果过大则抛出异常
    • 6、使用ASCII字符集的子集作为文件名和路径名,当包括特殊字符如控制字符、空格、分隔符、命令行解释器、脚本和解析器时,会引起不可预期的行为
    • 7、从格式字符串中排除用户输入,避免拒绝服务
    • 8、不要向Runtime.exec()方法传递非受信、未净化的数据
    • 9、净化传递给正则表达式的非受信数据
    • 10、如果没有指定适当的locale,不要使用locale相关方法处理与locale相关的数据,最常见的就是大小写转换toUpperCase,正确做法是”title”.toUpperCase(Locale.ENGLISH)
    • 11、不要拆分两种数据结构的字符串,因为有补充字符和合并字符的存在,需要避免多字节编码问题
    • 12、移除或者替代任何字符串时,必须进行验证,避免成为关键字
    • 13、确保在不同的字符编码中无损转换字符串数据,不推荐使用string.getBytes(charset),推荐使用charsetEncoder类
    • 14、在文件或者网络IO两端使用兼容的编码方式

    二、声明和初始化

    • 1、防止类的循环初始化,因为声明为static final的一个字段为并不能保证它在被读之前已经完全初始化
    • 2、不要重用Java标准库的已经公共的标识、公共的工具类、接口或者包,重用名称和定义不良好的import会导致不可预期的行为
    • 3、将所有增强for语句的循环变量声明为final类型,比如Iterator迭代时,直接修改next时会抛异常,声明为final后会直接产生编译器错误
    public class Cycle {
        private final int balance;
        private static final Cycle c = new Cycle();
        private static final int deposit = (int) (Math.random()*100);
    
        public Cycle() {
            balance = deposit-10;
        }
    
        public static void main(String[] args) {
            //-10
            System.out.println("balance is:"+c.balance);
        }
    }

    三、表达式

    • 1、不要忽略方法的返回值
    • 2、不要解引用空指针
    • 3、使用两个参数的Arrays.equals()方法来比较两个数组的内容
    • 4、不要用相等操作符来比较两个基础数据类型的值
    • 5、确保使用正常的类型来自动封装数值
    • 6、不要在一个表达式中对同一变量进行多次写入
    • 7、不要在断言assert中使用有副作用的表达式,因为当关闭断言功能后,表达式将不会执行

    四、数值类型与运算

    • 1、检测和向上转型避免整数溢出
    • 2、不要对同一数据进行位运算和数学运算,避免对变量数据解析的混淆
    • 3、确保除法运算和模运算的除数不为0
    • 4、使用可容纳无符号数据合法取值范围的整数类型
    • 5、不要使用浮点数float和double进行精细计算
    • 6、使用stricftp修饰符确保跨平台浮点运算的一致性
    • 7、不要尝试与无序的非数值NaN进行比较,因为表达式NaN==NaN总是返回false
    • 8、检查浮点输入特殊的数值,比如Double.isNan(double d)、Double.isinfinite(double d)
    • 9、不要使用浮点变量作为循环计数器
    • 10、不要从浮点字元构造BigDecimal对象,避免精度损失
    • 11、不要比较或者审查以字符串表达的浮点数值,除非显式去除字符串额外尾随的0
    • 12、需要慎重处理向下转型,比如int类型转成byte类型,避免精度损失
    • 13、需要慎重处理向上转型,比如float类型转成double类型,避免精度损失

    五、面向对象

    • 1、只有受信子类能对具有不变性的类和方法进行扩展
    • 2、声明数据成员为私有并提供可访问的封装器方法
    • 3、当改变基类时,保存子类之间的依赖,不能破坏子类所依赖的程序不可变性。比如说,假设HashMap一开始只提供get、set方法,突然有一天新增了个entrySet方法,子类通过entrySet绕过权限检查进行修改
    • 4、在新代码中,不要混用具有范型和非范性的原始数据类型。当一个参数化的数个类型要访问一个对象,而这个对象又不是参数化数据类型时,会产生堆污染,未经检查的警告在错误时排查较困难
    • 5、不可变类为可变实例(成员)提供复制功能,避免传递给非受信代码时修改原来的实例,特别需要注意的是ThreadLocal是浅拷贝,避免引用逸出
    • 6、对可变输入和可变的内部组件创建防御性复制。起因是著名的TOCTOU漏洞, 一个程序先通过 access 判断用户是否有权限访问一个文件,然后通过 open 打开该文件,攻击者可以在时间间隙中间改变这个文件。当元素为可变对象的索引时,需要进行深复制
    • 7、不允许敏感类复制其自身,也就是不应该实现Cloneable接口,也不应该提供复制构造方法
    • 8、不要在嵌套类中暴露外部类的私有字段
    • 9、不要使用公有静态的非final变量
    • 10、在构造函数中尽可能的不出现异常

    六、方法

    • 1、不要使用断言验证方法参数,断言失败后并不会抛出一个适当真实的异常
    • 2、进行安全检测的方法必须声明为private或final
    • 3、对类、接口、方法和数据成员的可访问性进行限制,避免子类覆盖后访问权限过大
    • 4、确保构造函数不会调用可覆写的方法,避免子类发起基类的创建时却调用了子类的方法,得到一个未初始化的值
    • 5、不要在clone()中调用可覆写的方法
    • 6、定义了equals()方法的类必须定义hashCode()方法
    • 7、实现compareTo()方法时遵守常规合约,满足传递性等
    • 8、不要使用析构函数,因为它的执行是没有固定时间的,不能保证有效性,它的调用是无序的,另外在停止运行前,JVM可能不会去调用孤立对象的析构函数,尝试在析构函数中更新状态会失败也不会有警告

    七、异常行为

    • 1、不要消除或勿略可检查的异常
    • 2、不能允许异常泄漏敏感信息
    • 3、记录日记时应避免异常
    • 4、在方法失败时恢复对象先前的状态
    • 5、不要在finally程序段非正常退出,比如使用return\break\continute\throw,非正常退出会导致try程序段非正常终止,从而消除从try\catch中抛出的任何异常
    • 6、不要在finally程序段遗漏可检查异常
    • 7、不要抛出未声明的可检查异常
    • 8、不要抛出RuntimeException、Exception、Throwable,尽量抛出明确异常
    • 9、不要捕捉NullPointerException或任何它的基类

    八、可见性和原子性

    • 1、当需要读取共享基础数据类型变量时,需要保证其他可见性,勿必声明为volatile变量或者正确进行代码同步
    • 2、认为只包含不可变对象的引用的类是不可变的,这样的假设是错误的
    • 3、保证对于共享变量的组合操作(+=、++等)是原子性的
    • 4、即使每一个方法是相互独立并且是原子性的,也不要假设一组调用是原子性的,因为它可能仅仅是曾经满足条件而已
    • 5、保证串联在一起的方法调用(Builder模式)是原子性的
    • 6、保证在读写64位的数值时的原子性

    九、锁

    • 1、通过私有final锁对象可以同步那些与非受信代码交互的类,因为它满足不可变原则,JVM使尽优化也不会出现线程安全问题
    • 2、不要基于那些可能被重用的对象进行同步,比如说Boolean、Integer类型的锁
    • 3、不要基于那些通过getClass()返回的类对象来实现同步
    • 4、不要基于高层并发对象的内置锁来实现同步,java.util.concurrent.locks包中Lock和Condition接口的实现类,比如重入锁ReetrantLock
    • 5、即使集合是可访问的,也不要基于集合视图使用同步,可以使用Collections.synchronizedMap(map)进行同步,不可以使用map.keySet()进行同步
    • 6、对那些可以被非受信代码修改的静态字段,需要同步进入
    • 7、不要使用一个实例锁(非静态的类成员)来保护共享静态数据
    • 8、使用相同的方式请求和释放锁来避免死锁
    • 9、在异常条件时,保证释放已经持有的锁
    • 10、不要执行那些持有锁时会阻塞的操作
    • 11、不要使用不正确形式的双重检查惯用法,需要保证延迟初始化必须在多线程中是同步的
    • 12、当类方法和类成员使用不同的内置锁时,需要明确锁保护的是哪个对象,比如下面这段代码是线程不安全的
    public class ListHelper<E> {
    
        public List<E> list = Collections.synchronizedList(new ArrayList<>());
    
        public synchronized boolean putIfAbsent(E x) {
    	boolean absent = !list.contains(x);
    	if(absent) {
                list.add(x);
    	}
    	return absent;
        }
    }

    十、线程API

    • 1、不要调用Thread.run(),因为run方法中的语句是由当前线程而不是由新创建的线程来执行的,正确的操作是Thread.start()
    • 2、不能调用ThreadGroup方法,它的API可能会导致竞态、内存泄漏以及不一致的对象状态
    • 3、通过(notify()、signal())所有等待中的线程而不是单一线程,因为不能保证哪一个线程会接到通知,除非所有线程的等候条件是一致的
    • 4、始终在循环体中调用wait()和await()方法,避免中间线程修改状态、恶意的通知、误送的通知、虚拟唤醒的漏洞
    • 5、确保可以终止受阻线程,比如readlIne()阻塞于网络IO时,在IO完成前它无法对变更的标记做出响应,需要避免拒绝服务漏洞
    • 6、不要使用Thread.stop()来终止线程,stop会造成线程停止操作并抛出ThreadDeath异常,会使对象处于不一致的状态

    十一、线程池

    • 1、使用线程池处理流量突发情况以实现降低性能运行
    • 2、不要使用有限的线程池来执行相互依赖的任务,避免线程饥饿死锁
    • 3、确保提交至线程池的任务是可中断
    • 4、确保线程池中正在执行的任务不会失败而不给出任何提示,不仅会造成资源泄漏,还会对失败的诊断很困难,因为线程池中的线程是可回收的。可以覆写ThreadPoolExecutor回调的afterExecute()方法或者Future.get()
    • 5、程序必须确保线程池中的线程执行的每一个任务只能见到正确初始化的ThreadLocal对象实例

    十二、与线程安全相关的其他规则

    • 1、不要使用非线程安全方法来覆写线程安全方法
    • 2、不要让this引用在创建对象时泄漏,常见途径有:
    • 2.1、从创建对象的构造函数中调用一个非私有的、可覆写的方法时,该方法返回thirs
    • 2.2 、从可变类的一个非私有的方法返回this
    • 2.3、将this作为参数传递给一个在创建对象的构造函数中调用的外部方法
    • 2.4、使用内隐类,内隐类维护指向外部对象的this引用的一个副本
    • 2.5、在创建对象的构造函数中将this赋给公有的静态变量,从而将其公开
    • 2.6、从构造函数中抛出一个异常
    • 2.7、传递内部对象状态至一个外部方法
    • 3、不在在初始化类时使用后台线程,避免初始化循环和死锁
    • 4、不要发布部分初始化的对象,因为JMM允许多个线程在对象初始化开始后和结束后观察到对象

    十三、输入输出

    • 1、不要操作共享目录中的文件,因为强制文件锁FileLock有很多的限制
    • 2、使用合适的访问权限创建文件
    • 3、发现并处理与文件相关的错误,一般的文件操作方法通常使用返回值而不是抛出异常来指示其错误
    • 4、在终止前移除临时文件
    • 5、在不需要时关闭资源,推荐使用try-with-resource方案
    • 6、不要使用Buffer中的wrap()或duplicate()创建缓存,并将缓存暴露给非受信代码,对这些缓存区的修改会导致数值的修改
    • 7、不能在一个单独的InputStream上创建多个缓存区封装器,重定向InputStream会导致不可预期的错误,往征会抛出EOFException异常
    • 8、不要让外部进程阻塞输入和输出流
    • 9、对读取一个字符或者字节的方法,使用int类型的返回值,仅当读取到末尾时会返回-1,不要过早将返回的值转成byte或char类型
    • 10、不要使用write()方法输出超过0~255的整数,超过后数值的高位部分会被截去
    • 11、使用read()方法保证填充一个数组,如果没有达到len的要求,此方法会堵塞
    • 12、不要将原始的二进制数据作为字符数据读入,比如说不指定编码的情况下将BigInteger的字节数组转换成字符串时会损失信息
    • 13、为小端数据的读写提供方法,不要使用java.io.DataInputStream中readShort()、readByte()等和对应的写方法,它们仅针对大端字节序数据进行操作
    • 14、不要在受信边界外记录敏感信息
    • 15、在程序终止时执行正确的清理动作,避免在不确定的状态下继续执行,可利用addShutdownHook()

    十四、序列化

    • 1、在类的演化过程中维护其序列化的兼容性,保证显示指定serialVersionUID或者通过serialPersistenFields使用自定义的序列化
    • 2、不要偏离序列化方法的正确签名,也就是readObject()、readObjectNoData()、writeObject()方法必须声明为私有,而readResolve()、writeReplace()方法不能声明为私有
    • 3、在将对象向信任边界之外发送时,需要签名并且封装敏感对象
    • 4、不要序列化未经加密的敏感数据
    • 5、不要允许序列化和反序列化绕过安全管理器
    • 6、不能序列化内部类实例,当内部类被序列化时,包含在外部类的字段也会被序列化
    • 7、在反序列化时,必须在readObject()方法中对私有的可变组件进行防御性复制
    • 8、不要对实现定义的不可变因素使用默认的序列化格式,反序列会创建一个新的类实例但是不会调用它的构造函数
    • 9、不要从readObject()方法中调用可以被覆写的方法,因为基类的反序列化发生在类反序列化前,所以在readObject()调用可覆写方法会读取到子类被完全创建之前的状态
    • 10、在序列化时避免出现内存和资源泄漏,需要注意的是ObjectOutputStream维持了一个引用表来对先前序列化的对象进行跟踪
    • 11、不要在(会进行序列化和反序列化的)POJO类上做业务逻辑

    十五、平台安全性

    • 1、不要允许特权代码块越过受信边界泄漏敏感信息,比如从doPrivileged()代码块中返回指向敏感资源的引用
    • 2、不要在特权代码块中使用没有验证或者非受信的变量
    • 3、不要基于非受信源进行安全检查,任何非受信对象或者参数必须在检查之前做防御性深度复制
    • 4、使用安全管理器检查来操作敏感操作
    • 5、不要使用反射来增加类、方法、字段的可访问性
    • 6、不要依赖于默认的URLClassLoader和java.util.jar提供的自动化签名检查
    • 7、当编写一个自定义的类装载器时,在给源代码覆予任何权限前,必须调用基类的getPermissions()方法获知默认的系统规则

    十六、其他

    • 1、在交换安全数据时,使用SSLSocket而不是Socket
    • 2、生成强随机数,推荐使用SecureRandom类来生成高质量的随机数也不是Random类
    • 3、不要硬编码敏感信息
    • 4、当一个遍历正在进行时,不要修改它对应的集合,正常的做法是封装到同步集合中,如Collections.synchronizedList(list)或者new CopyOnWriteArrayList()
    • 5、防止多次实例化单例对象,需要确保设置构造方法为私有、跨线程的可见性、类不能被序列化、类不能被克隆,如果它是被一个自定义的类装载器装载,要防止类被垃圾回收
    展开全文
  • java安全编码指南之:输入注入injection

    千次阅读 热门讨论 2020-10-12 09:03:44
    注入问题是安全中一个非常常见的问题,今天我们来探讨一下java中的SQL注入和XML注入的防范。
  • java安全编码指南之:基础篇

    千次阅读 2020-08-25 14:48:27
    简介:作为一个程序员,只是写出好用的代码是不够的,我们还需要考虑到程序的...所以,安全很重要,今天本文将会探讨一下java中的安全编码指南。 简介作为一个程序员,只是写出好用的代码是不够的,我们还需要考虑到
  • Java安全编码标准》.pdf AVA规范、如《NASA的10条代码编写原则》、《阿里巴巴JAVA开发手册》
  • 【安全开发】java安全编码规范

    千次阅读 多人点赞 2018-11-30 15:44:00
    原文转载自:https://github.com/SecurityPaper/SecurityPaper-web/blob/master/_posts/2.SDL%E8%A7%84%E8%8C%83%E6%96%87%E6%A1%A3/2018-08-17-SDL-3-java%E5%AE%89%E5%85%A8%E7%BC%96%E7%A0%81%E8%A7%84...
  • JAVA安全编码规范

    千次阅读 2019-05-13 01:03:00
    2019独角兽企业重金招聘Python工程师标准>>> ...
  • java安全编码指南之:lock和同步的正确使用

    千次阅读 热门讨论 2020-10-10 08:57:22
    java多线程环境中,lock和同步是我们一定会使用到的功能。那么在java中编写lock和同步相关的代码之后,需要注意哪些问题呢?一起来看看吧。
  • CERT关于Java安全编码规范的新书

    千次阅读 2013-09-20 23:30:20
    CERT关于Java安全编码规范的新书:Java Coding Guidelines: 75 Recommendations for Reliable and Secure Programshttp://...
  • Java安全编码标准》迷你书  本书不仅从语言角度系统而详 细地阐述Java安全编码的要素、标准、规范和最佳实践,而且从架构设计的角度分析了Java API存在的设计缺陷和可能存 在的安全风险,以及应对的策略和...
  • java安全编码指南之:字符串和编码

    千次阅读 2020-09-16 09:41:28
    字符串是我们日常编码过程中使用到最多的java类型了。全球各个地区的语言不同,即使使用了Unicode也会因为编码格式的不同采用不同的编码方式,如UTF-8,UTF-16,UTF-32等。 我们在使用字符和字符串编码的过程中会...
  • java安全编码指南之:对象构建

    千次阅读 2020-09-01 09:29:59
    Finalizer Attack是什么?它和对象创建有什么关系?一起来看看吧。
  • java安全编码指南之:输入校验

    千次阅读 2020-09-21 10:27:04
    为了保证java程序的安全,任何外部用户的输入我们都认为是可能有恶意攻击意图,我们需要对所有的用户输入都进行一定程度的校验。 本文将带领大家探讨一下用户输入校验的一些场景。一起来看看吧。
  • java安全编码指南之:死锁dead lock

    千次阅读 2020-10-01 08:44:36
    java中为了保证共享数据的安全性,我们引入了锁的机制。有了锁就有可能产生死锁。 死锁的原因就是多个线程锁住了对方所需要的资源,然后现有的资源又没有释放,从而导致循环等待的情况。 通常来说如果不同的线程对...
  • java安全编码指南之:线程安全规则

    千次阅读 热门讨论 2020-10-23 09:26:22
    如果我们在多线程中引入了共享变量,那么我们就需要考虑一下多线程下线程安全的问题了。那么我们在编写代码的过程中,需要注意哪些线程安全的问题呢?

空空如也

1 2 3 4 5 ... 20
收藏数 198,558
精华内容 79,423
关键字:

java安全编码

java 订阅