devbox
Li_阴宅
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

M1卡控制位的解析源码的封装_读取失败可能控制位被写死

作者：Li_阴宅 | 2024-08-15 20:07:24

赞

踩

读取失败可能控制位被写死

额，最近在做关于M1卡读写的程序开发，由于控制位的问题因此要查询资料解决其解析与打包的问题，恰好在GITHUB上有一个很好的项目，附带上地址：点我看这个神奇的项目 ，我根据这位程序员的思路封装了自己的库（控制位的操作基本都是按位操作，好麻烦的说。我也想参透，乃至自己独立按照M1卡相关文档可以写出，奈何实力不够，被按位操作绕的眼花缭乱的），该有的注释，基本都在这个库里面加了，为了直观明了，我一个个根据文档上的位对应的权限来使用了较多的if语句来实现，因此代码有些冗余，为了好理解每一句的作用暂时不修改优化，有需要的可以根据自己的需求定制优化。

好的，话不多说，上代码：
  1. package test;
  2.  
  3. import java.util.HashMap;
  4.  
  5. public class AccessBitUitl {
  6. 	
  7. 	/*
  8. 	 * 控制位长度，4位字节八个十六进制字符
  9. 	 */
  10. 	public static final int CONTROLBIT_HEX_SIZE = 8;
  11. 	public static final int CONTROLBIT_BYTE_SIZE = 4;
  12. 	
  13. 	//可以实例化对象时使用的全局控制位缓存
  14. 	private byte[] mAcBytes = null;
  15.  
  16. 	//静态工具库，default构造方法设为私有较好
  17. 	private AccessBitUitl() { /*This is don't need*/ }
  18. 	
  19. 	//有参构造方法，简化对相同控制位解析时方法调用的实现
  20. 	private AccessBitUitl(byte[] acBytes) { this.mAcBytes = acBytes; }
  21. 	
  22. 	/*
  23. 	 * 参考文档
  24. 	 * https://blog.csdn.net/liujianhua1989/article/details/72639307
  25. 	 * https://www.cnblogs.com/h2zZhou/p/5250703.html
  26. 	 * https://github.com/ikarus23/MifareClassicTool
  27. 	 */
  28. 	
  29. 	/*认证后可执行下列操作：
  30. 	1、读数据块，读操作支持普通的数据块（0-2）与电子钱包块与尾块（trail）
  31. 	2、写数据块，写操作支持普通的数据块（0-2）与电子钱包块与尾块（trail）
  32. 	3、减值：减少数据块内的数值，并将结果保存在临时内部数据寄存器中。（仅支持电子钱包块）
  33. 	4、加值：增加数据块内的数值，并将结果保存在数据寄存器中。（仅支持电子钱包块）
  34. 	5、恢复：将数据块内容移入数据寄存器。（仅支持电子钱包块）
  35. 	6、转存：将临时内部数据寄存器的内容写入数值块。 （仅支持电子钱包块）
  36. 	枚举操作类型,依次为 -> 读卡 ， 写卡 ， 增值 ， 减值 ， 恢复 ， 转存
  37. 	*/
  38. 	public static enum Operation{ READ, WRITE, INCREMENT,DECREMENT, RESTORE, TRANSFER }
  39. 	
  40. 	//密钥的验证是有KeyA，KeyB的两种不同的选择的，
  41. 	//当控制位的条件成立时，Key也可当作鉴权值之一
  42. 	//三个枚举元素分别是 A密钥， B密钥，AB密钥，两者都没
  43. 	public static enum KeyType{ A , B , AB , NEVER }
  44. 	
  45. 	//对于一个扇区，能操作的只有两部分，一部分是数据块，一部分是尾部块
  46. 	public static enum SectorStructure{ DATA , TRAIL }
  47. 	
  48. 	/*
  49. 	 * 对数据块，能操作的总共有“三部分”，
  50. 	 * Block1和Block2和Block3,不同容量的卡块数量不同，
  51. 	 * 但是对于MIFARE CLASSIC CARD的兼容性来说，能操作的，就是“三部分”
  52. 	 */
  53. 	public static enum DataBlockStructure{ BLOCK0 , BLOCK1 , BLOCK2 , BLOCK3 }
  54. 	
  55. 	//对于特殊的块3，是有三部分的分割读写区域
  56. 	//其中分别是KeyA的读写，还有KeyB的读写， 还有控制位的读写
  57. 	//因此我们要根据要操作的区域对控制位进行解析鉴权
  58. 	public static enum TrailStructure{ KEYA , KEYB , CONTROLBIT }
  59. 	
  60. 	//对于控制位，是有C1 , C2, C3的编号
  61. 	public static enum ControlBitNum{ C1 , C2 , C3 }
  62. 	
  63. 	/*块具有相对于区的独立性，16扇区各自拥有独立的鉴权方式，
  64. 	 *块鉴权在控制位的约束下，对于密码的权限是依赖控制位的实现
  65. 	 *依据控制位的约束，密钥对于块进行上述操作是必须要条件成立
  66. 	 *每个数据块和尾块的读写条件均由3个bit定义，
  67. 	 *并以非取反和取反形式保存在各个区的尾块中。
  68. 	 **尾部块由C13 C23 C33三个控制位来控制，由于不是数据块，因此仅支持读写操作
  69. 	 *数据块2由C12 C22 C32三个控制位控制，由于是数据块，因此支持读写增值减值操作
  70. 	 *数据块1由C11 C21 C31三个控制位控制，由于是数据块，因此支持读写增值减值操作
  71. 	 *数据块0由C10 C20 C30三个控制位控制，由于是数据块，因此支持读写增值减值操作
  72. 	 */
  73. 	
  74. 	/*							警告，若控制位错误，将导致扇区锁死						*/
  75. 	
  76. 	/*
  77. 	 * 尾部块操作权限解析方法
  78. 	 * 根据传入的控制字节对操作进行解析，返回对应的ENUM对象
  79. 	 * @param c1 控制字节1
  80. 	 * @param c2 控制字节2
  81. 	 * @param c3 控制字节3
  82. 	 * @param opera 将要进行的操作
  83. 	 * @param whereToOpera 将要操作尾部块那一部分
  84. 	 */
  85. 	public static KeyType trailOperation(byte c1, byte c2, byte c3, 
  86. 			Operation opera, TrailStructure whereToOpera) {
  87. 		//判断传入的操作类型是否正确，如果不正确则直接返回NEVER
  88. 		//特别警告！！！在尾部块，操作仅限于支持读操作与写操作
  89. 		if(opera != Operation.READ && opera != Operation.WRITE) return KeyType.NEVER;
  90. 		//为了简化鉴权过程，先执行把操作为读的鉴权
  91. 		if(opera == Operation.READ) {
  92. 			//在尾部块的操作为在KeyA部分上进行的时候的鉴权
  93. 			if(whereToOpera == TrailStructure.KEYA) {
  94. 				//当控制位为000时KeyA部分禁止读
  95. 				if(c1 == 0 && c2 == 0 && c3 == 0) return KeyType.NEVER;
  96. 				//当控制位为001时KeyA部分禁止读
  97. 				if(c1 == 0 && c2 == 0 && c3 == 1) return KeyType.NEVER;
  98. 				//当控制位为010时KeyA部分禁止读
  99. 				if(c1 == 0 && c2 == 1 && c3 == 0) return KeyType.NEVER;
  100. 				//当控制位为011时KeyA部分禁止读
  101. 				if(c1 == 0 && c2 == 1 && c3 == 1) return KeyType.NEVER;
  102. 				//当控制位为100时KeyA部分禁止读
  103. 				if(c1 == 1 && c2 == 0 && c3 == 0) return KeyType.NEVER;
  104. 				//当控制位为101时KeyA部分禁止读
  105. 				if(c1 == 1 && c2 == 0 && c3 == 1) return KeyType.NEVER;
  106. 				//当控制位为110时KeyA部分禁止读
  107. 				if(c1 == 1 && c2 == 1 && c3 == 0) return KeyType.NEVER;
  108. 				//当控制位为111时KeyA部分禁止读
  109. 				if(c1 == 1 && c2 == 1 && c3 == 1) return KeyType.NEVER;
  110. 			}
  111. 			//在尾部块的操作为在控制位部分上进行的时候的鉴权
  112. 			if(whereToOpera == TrailStructure.CONTROLBIT) {
  113. 				//当控制位为000时控制位部分允许验证密钥A后读
  114. 				if(c1 == 0 && c2 == 0 && c3 == 0) return KeyType.A;
  115. 				//当控制位为001时控制位部分允许验证密钥A后读
  116. 				if(c1 == 0 && c2 == 0 && c3 == 1) return KeyType.A;
  117. 				//当控制位为010时控制位部分允许验证密钥A后读
  118. 				if(c1 == 0 && c2 == 1 && c3 == 0) return KeyType.A;
  119. 				//当控制位为011时控制位部分允许验证密钥A|B后读
  120. 				if(c1 == 0 && c2 == 1 && c3 == 1) return KeyType.AB;
  121. 				//当控制位为100时控制位部分允许验证密钥A|B后读
  122. 				if(c1 == 1 && c2 == 0 && c3 == 0) return KeyType.AB;
  123. 				//当控制位为101时控制位部分允许验证密钥A|B后读
  124. 				if(c1 == 1 && c2 == 0 && c3 == 1) return KeyType.AB;
  125. 				//当控制位为110时控制位部分允许验证密钥A|B后读
  126. 				if(c1 == 1 && c2 == 1 && c3 == 0) return KeyType.AB;
  127. 				//当控制位为111时控制位部分允许验证密钥A|B后读
  128. 				if(c1 == 1 && c2 == 1 && c3 == 1) return KeyType.AB;
  129. 			}
  130. 			//在尾部块的操作为在KeyB部分上进行的时候的鉴权
  131. 			if(whereToOpera == TrailStructure.KEYB) {
  132. 				//当控制位为000时KeyB部分允许验证密钥A后读
  133. 				if(c1 == 0 && c2 == 0 && c3 == 0) return KeyType.A;
  134. 				//当控制位为001时KeyB部分允许验证密钥A后读
  135. 				if(c1 == 0 && c2 == 0 && c3 == 1) return KeyType.A;
  136. 				//当控制位为010时KeyB部分允许验证密钥A后读
  137. 				if(c1 == 0 && c2 == 1 && c3 == 0) return KeyType.A;
  138. 				//当控制位为011时KeyB部分禁止读
  139. 				if(c1 == 0 && c2 == 1 && c3 == 1) return KeyType.NEVER;
  140. 				//当控制位为100时KeyB部分禁止读
  141. 				if(c1 == 1 && c2 == 0 && c3 == 0) return KeyType.NEVER;
  142. 				//当控制位为101时KeyB部分禁止读
  143. 				if(c1 == 1 && c2 == 0 && c3 == 1) return KeyType.NEVER;
  144. 				//当控制位为110时KeyB部分禁止读
  145. 				if(c1 == 1 && c2 == 1 && c3 == 0) return KeyType.NEVER;
  146. 				//当控制位为111时KeyB部分禁止读
  147. 				if(c1 == 1 && c2 == 1 && c3 == 1) return KeyType.NEVER;
  148. 			}
  149. 			
  150. 		}
  151. 		//然后再执行操作为写的鉴权
  152. 		if(opera == Operation.WRITE) {
  153. 			//在尾部块的操作为在KeyA部分上进行的时候的鉴权
  154. 			if(whereToOpera == TrailStructure.KEYA) {
  155. 				//当控制位为000时KeyA部分允许验证密钥A后写
  156. 				if(c1 == 0 && c2 == 0 && c3 == 0) return KeyType.A;
  157. 				//当控制位为001时KeyA部分允许验证密钥A后写
  158. 				if(c1 == 0 && c2 == 0 && c3 == 1) return KeyType.A;
  159. 				//当控制位为010时KeyA部分禁止写
  160. 				if(c1 == 0 && c2 == 1 && c3 == 0) return KeyType.NEVER;
  161. 				//当控制位为011时KeyA部分允许验证密钥B后写
  162. 				if(c1 == 0 && c2 == 1 && c3 == 1) return KeyType.B;
  163. 				//当控制位为100时KeyA部分允许验证密钥B后写
  164. 				if(c1 == 1 && c2 == 0 && c3 == 0) return KeyType.B;
  165. 				//当控制位为101时KeyA部分禁止写
  166. 				if(c1 == 1 && c2 == 0 && c3 == 1) return KeyType.NEVER;
  167. 				//当控制位为110时KeyA部分禁止写
  168. 				if(c1 == 1 && c2 == 1 && c3 == 0) return KeyType.NEVER;
  169. 				//当控制位为111时KeyA部分禁止写
  170. 				if(c1 == 1 && c2 == 1 && c3 == 1) return KeyType.NEVER;
  171. 			}
  172. 			//在尾部块的操作为在控制位部分上进行的时候的鉴权
  173. 			if(whereToOpera == TrailStructure.CONTROLBIT) {
  174. 				//当控制位为000时控制位部分允许验证密钥B后写
  175. 				if(c1 == 0 && c2 == 0 && c3 == 0) return KeyType.B;
  176. 				//当控制位为001时控制位部分允许验证密钥A后写
  177. 				if(c1 == 0 && c2 == 0 && c3 == 1) return KeyType.A;
  178. 				//当控制位为010时控制位部分禁止写
  179. 				if(c1 == 0 && c2 == 1 && c3 == 0) return KeyType.NEVER;
  180. 				//当控制位为011时控制位部分允许验证密钥B后写
  181. 				if(c1 == 0 && c2 == 1 && c3 == 1) return KeyType.B;
  182. 				//当控制位为100时控制位部分禁止写
  183. 				if(c1 == 1 && c2 == 0 && c3 == 0) return KeyType.NEVER;
  184. 				//当控制位为101时控制位部分允许验证密钥B后写
  185. 				if(c1 == 1 && c2 == 0 && c3 == 1) return KeyType.B;
  186. 				//当控制位为110时控制位部分禁止写
  187. 				if(c1 == 1 && c2 == 1 && c3 == 0) return KeyType.NEVER;
  188. 				//当控制位为111时控制位部分禁止写
  189. 				if(c1 == 1 && c2 == 1 && c3 == 1) return KeyType.NEVER;
  190. 			}
  191. 			//在尾部块的操作为在KeyB部分上进行的时候的鉴权
  192. 			if(whereToOpera == TrailStructure.KEYB) {
  193. 				//当控制位为000时KeyB部分允许验证密钥A后写
  194. 				if(c1 == 0 && c2 == 0 && c3 == 0) return KeyType.A;
  195. 				//当控制位为001时KeyB部分允许验证密钥A后写
  196. 				if(c1 == 0 && c2 == 0 && c3 == 1) return KeyType.A;
  197. 				//当控制位为010时KeyB部分禁止写
  198. 				if(c1 == 0 && c2 == 1 && c3 == 0) return KeyType.NEVER;
  199. 				//当控制位为011时KeyB部分允许验证密钥B后写
  200. 				if(c1 == 0 && c2 == 1 && c3 == 1) return KeyType.B;
  201. 				//当控制位为100时KeyB部分允许验证密钥B后写
  202. 				if(c1 == 1 && c2 == 0 && c3 == 0) return KeyType.B;
  203. 				//当控制位为101时KeyB部分禁止写
  204. 				if(c1 == 1 && c2 == 0 && c3 == 1) return KeyType.NEVER;
  205. 				//当控制位为110时KeyB部分禁止写
  206. 				if(c1 == 1 && c2 == 1 && c3 == 0) return KeyType.NEVER;
  207. 				//当控制位为111时KeyB部分禁止写
  208. 				if(c1 == 1 && c2 == 1 && c3 == 1) return KeyType.NEVER;
  209. 			}
  210. 		}
  211. 		//在条件都不成立时返回NEVER
  212. 		return KeyType.NEVER;
  213. 	}
  214. 	
  215. 	/*
  216. 	 * 数据块操作权限解析方法
  217. 	 * 根据传入的控制字节对操作进行解析，返回对应的ENUM对象
  218. 	 * @param c1 控制字节1
  219. 	 * @param c2 控制字节2
  220. 	 * @param c3 控制字节3
  221. 	 * @param opera 将要对数据块进行的操作
  222. 	 */
  223. 	public static KeyType generalOperation(byte c1, byte c2, byte c3, Operation opera) {
  224. 		//1、进行数据块读操作的鉴权
  225. 		if(opera == Operation.READ) {
  226. 			//在控制位为000时允许密钥AB后读
  227. 			if(c1 == 0 && c2 == 0 && c3 == 0) return KeyType.AB;
  228. 			//在控制位为010时允许密钥AB后读
  229. 			if(c1 == 0 && c2 == 1 && c3 == 0) return KeyType.AB;
  230. 			//在控制位为100时允许密钥AB后读
  231. 			if(c1 == 1 && c2 == 0 && c3 == 0) return KeyType.AB;
  232. 			//在控制位为110时允许密钥AB后读
  233. 			if(c1 == 1 && c2 == 1 && c3 == 0) return KeyType.AB;
  234. 			//在控制位为001时允许密钥AB后读
  235. 			if(c1 == 0 && c2 == 0 && c3 == 1) return KeyType.AB;
  236. 			//在控制位为011时允许密钥B后读
  237. 			if(c1 == 0 && c2 == 1 && c3 == 1) return KeyType.B;
  238. 			//在控制位为101时允许密钥B后读
  239. 			if(c1 == 1 && c2 == 0 && c3 == 1) return KeyType.B;
  240. 			//在控制位为111时禁止读
  241. 			if(c1 == 0 && c2 == 0 && c3 == 1) return KeyType.NEVER;
  242. 		}
  243. 		//1、进行数据块写操作的鉴权
  244. 		if(opera == Operation.WRITE) {
  245. 			//在控制位为000时允许密钥AB后写
  246. 			if(c1 == 0 && c2 == 0 && c3 == 0) return KeyType.AB;
  247. 			//在控制位为010时允许密钥B后写
  248. 			if(c1 == 0 && c2 == 1 && c3 == 0) return KeyType.B;
  249. 			//在控制位为100时允许密钥B后写
  250. 			if(c1 == 1 && c2 == 0 && c3 == 0) return KeyType.B;
  251. 			//在控制位为110时允许密钥B后写
  252. 			if(c1 == 1 && c2 == 1 && c3 == 0) return KeyType.B;
  253. 			//在控制位为001时禁止读
  254. 			if(c1 == 0 && c2 == 0 && c3 == 1) return KeyType.NEVER;
  255. 			//在控制位为011时允许密钥B后写
  256. 			if(c1 == 0 && c2 == 1 && c3 == 1) return KeyType.B;
  257. 			//在控制位为101时禁止写
  258. 			if(c1 == 1 && c2 == 0 && c3 == 1) return KeyType.NEVER;
  259. 			//在控制位为111时禁止写
  260. 			if(c1 == 0 && c2 == 0 && c3 == 1) return KeyType.NEVER;
  261. 		}
  262. 		//3、进行数据块增值操作的鉴权
  263. 		if(opera == Operation.INCREMENT) {
  264. 			//在控制位为000时允许密钥AB后增值
  265. 			if(c1 == 0 && c2 == 0 && c3 == 0) return KeyType.AB;
  266. 			//在控制位为010时允许密钥B后增值
  267. 			if(c1 == 0 && c2 == 1 && c3 == 0) return KeyType.NEVER;
  268. 			//在控制位为100时允许密钥B后增值
  269. 			if(c1 == 1 && c2 == 0 && c3 == 0) return KeyType.NEVER;
  270. 			//在控制位为110时允许密钥B后增值
  271. 			if(c1 == 1 && c2 == 1 && c3 == 0) return KeyType.B;
  272. 			//在控制位为001时禁止增值
  273. 			if(c1 == 0 && c2 == 0 && c3 == 1) return KeyType.NEVER;
  274. 			//在控制位为011时允许密钥B后增值
  275. 			if(c1 == 0 && c2 == 1 && c3 == 1) return KeyType.NEVER;
  276. 			//在控制位为101时禁止增值
  277. 			if(c1 == 1 && c2 == 0 && c3 == 1) return KeyType.NEVER;
  278. 			//在控制位为111时禁止增值
  279. 			if(c1 == 0 && c2 == 0 && c3 == 1) return KeyType.NEVER;
  280. 		}
  281. 		//4、进行数据块减值操作的鉴权
  282. 		//5、进行数据块恢复操作的鉴权
  283. 		//6、进行数据块转存操作的鉴权
  284. 		if(opera == Operation.DECREMENT || 
  285. 				opera == Operation.RESTORE || 
  286. 				opera == Operation.TRANSFER) {
  287. 			//在控制位为000时允许密钥AB后减值转存恢复
  288. 			if(c1 == 0 && c2 == 0 && c3 == 0) return KeyType.AB;
  289. 			//在控制位为010时允许密钥B后减值转存恢复
  290. 			if(c1 == 0 && c2 == 1 && c3 == 0) return KeyType.NEVER;
  291. 			//在控制位为100时允许密钥B后减值转存恢复
  292. 			if(c1 == 1 && c2 == 0 && c3 == 0) return KeyType.NEVER;
  293. 			//在控制位为110时允许密钥AB后减值转存恢复
  294. 			if(c1 == 1 && c2 == 1 && c3 == 0) return KeyType.AB;
  295. 			//在控制位为001时允许密钥AB后减值转存恢复
  296. 			if(c1 == 0 && c2 == 0 && c3 == 1) return KeyType.AB;
  297. 			//在控制位为011时禁止减值转存恢复
  298. 			if(c1 == 0 && c2 == 1 && c3 == 1) return KeyType.NEVER;
  299. 			//在控制位为101时禁止减值转存恢复
  300. 			if(c1 == 1 && c2 == 0 && c3 == 1) return KeyType.NEVER;
  301. 			//在控制位为111时禁止减值转存恢复
  302. 			if(c1 == 0 && c2 == 0 && c3 == 1) return KeyType.NEVER;
  303. 		}
  304. 		//在条件都不成立时返回NEVER
  305. 		return KeyType.NEVER;
  306. 	}
  307. 	
  308. 	/*
  309. 	 * 密钥B可读性判断方法
  310. 	 * 返回TRUE则keyB可读并可用于存储数据的访问控制条件
  311. 	 * 尾块和key A被预定义为传输配置状态。
  312. 	 * 因为在传输配置状态下key B可读，
  313. 	 * (KeyB可读的情况下)新卡必须用keyA认证。
  314. 	 * @param c1 控制字节1
  315. 	 * @param c2 控制字节2
  316. 	 * @param c3 控制字节3
  317. 	 */
  318. 	public static boolean isKeyBReadable(byte c1, byte c2, byte c3) {
  319. 		return c1 == 0	
  320. 				//在控制位为000时密钥B可读
  321.                 && (c2 == 0 && c3 == 0)
  322.                 //在控制位为010时密钥B可读
  323.                 || (c2 == 1 && c3 == 0)
  324.                 //在控制位为001时密钥B可读
  325.                 || (c2 == 0 && c3 == 1);
  326.     }
  327. 	
  328. 	/*
  329. 	 * 传输配置状态检测方法
  330. 	 * @param c1 控制字节1
  331. 	 * @param c2 控制字节2
  332. 	 * @param c3 控制字节3
  333. 	 * @param block 要操作的区域
  334. 	 */
  335. 	public static boolean isTranspotConfiguration(byte c1, byte c2, byte c3,
  336. 			SectorStructure block) {
  337. 		if(c1 == 0 && c2 == 0) {
  338. 			//操作数据块的情况下如果控制位为000则为传输配置状态
  339. 			if(block == SectorStructure.DATA && c3 == 0) return true;
  340. 			//操作尾部块的情况下如果控制位为001则为传输配置状态
  341. 			if(block == SectorStructure.TRAIL && c3 == 1) return true;
  342. 		}
  343. 		return false;
  344. 	}
  345. 	
  346. 	/*
  347. 	 * 解析控制字节的方法
  348. 	 * @param controlBit 长度为4byte的控制位
  349. 	 * @param block 枚举对象，用于判断要解析的块的控制位的鉴权
  350. 	 * 返回对应的区块的控制权限_对应的byte
  351. 	 */
  352. 	public static HashMap<ControlBitNum,Byte> unpackAccessInfo(byte[] controlBit, DataBlockStructure block) {
  353. 		//控制位长度查错
  354. 		if(controlBit.length != CONTROLBIT_BYTE_SIZE) {
  355. 			throw new RuntimeException("The ControlBit length is error!!!");
  356. 		}
  357. 		//存结果的图表
  358. 		HashMap<ControlBitNum,Byte> result = new HashMap<>();
  359. 		//建立一个矩阵数组，存控制位换算结果
  360. 		//三个控制位，四个块
  361. 		byte[][] acMatrix = new byte[3][4];
  362. 		//验证控制位的可行性
  363.         if (	(byte)((controlBit[1]>>>4)&0x0F)  ==
  364.                         (byte)((controlBit[0]^0xFF)&0x0F) &&
  365.                 (byte)(controlBit[2]&0x0F) ==
  366.                         (byte)(((controlBit[0]^0xFF)>>>4)&0x0F) &&
  367.                 (byte)((controlBit[2]>>>4)&0x0F)  ==
  368.                         (byte)((controlBit[1]^0xFF)&0x0F)) {
  369.             // C1, Block 0-3
  370.             for (int i = 0; i < 4; i++) {
  371.                 acMatrix[0][i] = (byte)((controlBit[1]>>>4+i)&0x01);
  372.             }
  373.             // C2, Block 0-3
  374.             for (int i = 0; i < 4; i++) {
  375.                 acMatrix[1][i] = (byte)((controlBit[2]>>>i)&0x01);
  376.             }
  377.             // C3, Block 0-3
  378.             for (int i = 0; i < 4; i++) {
  379.                 acMatrix[2][i] = (byte)((controlBit[2]>>>4+i)&0x01);
  380.             }
  381.         }
  382. 		if(block == DataBlockStructure.BLOCK0) {
  383. 			result.put(ControlBitNum.C1, acMatrix[0][0]);
  384. 			result.put(ControlBitNum.C2, acMatrix[1][0]);
  385. 			result.put(ControlBitNum.C3, acMatrix[2][0]);
  386. 			return result;
  387. 		}
  388. 		if(block == DataBlockStructure.BLOCK1) {
  389. 			result.put(ControlBitNum.C1, acMatrix[0][1]);
  390. 			result.put(ControlBitNum.C2, acMatrix[1][1]);
  391. 			result.put(ControlBitNum.C3, acMatrix[2][1]);
  392. 			return result;
  393. 		}
  394. 		if(block == DataBlockStructure.BLOCK2) {
  395. 			result.put(ControlBitNum.C1, acMatrix[0][2]);
  396. 			result.put(ControlBitNum.C2, acMatrix[1][2]);
  397. 			result.put(ControlBitNum.C3, acMatrix[2][2]);
  398. 			return result;
  399. 		}
  400. 		if(block == DataBlockStructure.BLOCK3) {
  401. 			result.put(ControlBitNum.C1, acMatrix[0][3]);
  402. 			result.put(ControlBitNum.C2, acMatrix[1][3]);
  403. 			result.put(ControlBitNum.C3, acMatrix[2][3]);
  404. 			return result;
  405. 		}
  406. 		return null;
  407. 	}
  408. 	
  409. 	/*
  410. 	 * 打包控制字节的方法
  411. 	 * @param controlBit 全部控制位的实现，当有四个对象,每个对象里有用C1 , C2 , C3
  412. 	 * 三个键值对,对应四个块的三个控制位
  413. 	 * 返回全部区块的控制权限_对应的byte（三个，不包括预留字节）
  414. 	 */
  415. 	public static byte[] packAccessInfo(HashMap<DataBlockStructure,HashMap<ControlBitNum,Byte>> controlBit) {
  416. 		//建立一个矩阵数组，存控制位换算结果
  417. 		//三个控制位，四个块,从图表中取出来填充到矩阵数组中
  418. 		byte[][] acMatrix = new byte[3][4];
  419. 		//外层迭代
  420. 		for(int i = 0; i < 3; ++i) {
  421. 			//内层迭代
  422. 			for(int j = 0; j < 4; ++j) {
  423. 				acMatrix[i][j] = 
  424. 						//取出对应扇区的控制比特位封包
  425. 						controlBit.get(DataBlockStructure.values()[j])
  426. 						//取出封包中的比特位打包进矩阵中
  427. 						.get(ControlBitNum.values()[i]);
  428. 			}
  429. 		}
  430. 		//开始将比特矩阵数组转化为字节数组
  431. 		if (acMatrix != null && acMatrix.length == 3) {
  432.             for (int i = 0; i < 3; i++) {
  433.                 if (acMatrix[i].length != 4)
  434.                     // Error.
  435.                     return null;
  436.             }
  437.         } else {
  438.             // Error.
  439.             return null;
  440.         }
  441.         byte[] acBytes = new byte[3];
  442.         // Byte 6, Bit 0-3.
  443.         acBytes[0] = (byte)((acMatrix[0][0]^0xFF)&0x01);
  444.         acBytes[0] |= (byte)(((acMatrix[0][1]^0xFF)<<1)&0x02);
  445.         acBytes[0] |= (byte)(((acMatrix[0][2]^0xFF)<<2)&0x04);
  446.         acBytes[0] |= (byte)(((acMatrix[0][3]^0xFF)<<3)&0x08);
  447.         // Byte 6, Bit 4-7.
  448.         acBytes[0] |= (byte)(((acMatrix[1][0]^0xFF)<<4)&0x10);
  449.         acBytes[0] |= (byte)(((acMatrix[1][1]^0xFF)<<5)&0x20);
  450.         acBytes[0] |= (byte)(((acMatrix[1][2]^0xFF)<<6)&0x40);
  451.         acBytes[0] |= (byte)(((acMatrix[1][3]^0xFF)<<7)&0x80);
  452.         // Byte 7, Bit 0-3.
  453.         acBytes[1] = (byte)((acMatrix[2][0]^0xFF)&0x01);
  454.         acBytes[1] |= (byte)(((acMatrix[2][1]^0xFF)<<1)&0x02);
  455.         acBytes[1] |= (byte)(((acMatrix[2][2]^0xFF)<<2)&0x04);
  456.         acBytes[1] |= (byte)(((acMatrix[2][3]^0xFF)<<3)&0x08);
  457.         // Byte 7, Bit 4-7.
  458.         acBytes[1] |= (byte)((acMatrix[0][0]<<4)&0x10);
  459.         acBytes[1] |= (byte)((acMatrix[0][1]<<5)&0x20);
  460.         acBytes[1] |= (byte)((acMatrix[0][2]<<6)&0x40);
  461.         acBytes[1] |= (byte)((acMatrix[0][3]<<7)&0x80);
  462.         // Byte 8, Bit 0-3.
  463.         acBytes[2] = (byte)(acMatrix[1][0]&0x01);
  464.         acBytes[2] |= (byte)((acMatrix[1][1]<<1)&0x02);
  465.         acBytes[2] |= (byte)((acMatrix[1][2]<<2)&0x04);
  466.         acBytes[2] |= (byte)((acMatrix[1][3]<<3)&0x08);
  467.         // Byte 8, Bit 4-7.
  468.         acBytes[2] |= (byte)((acMatrix[2][0]<<4)&0x10);
  469.         acBytes[2] |= (byte)((acMatrix[2][1]<<5)&0x20);
  470.         acBytes[2] |= (byte)((acMatrix[2][2]<<6)&0x40);
  471.         acBytes[2] |= (byte)((acMatrix[2][3]<<7)&0x80);
  472.  
  473.         return acBytes;
  474. 	}
  475. 	
  476. 	/**
  477.      * Convert the Access Condition bytes to a matrix containing the
  478.      * resolved C1, C2 and C3 for each block.
  479.      * @param acBytes 控制位字节数组
  480.      * @return 返回由3字节的控制位解析出来的控制位（bit）矩阵
  481.      * null will be returned.
  482.      */
  483.     public static byte[][] acBytesToACMatrix(byte acBytes[]) {
  484.         // ACs correct?
  485.         // C1 (Byte 7, 4-7) == ~C1 (Byte 6, 0-3) and
  486.         // C2 (Byte 8, 0-3) == ~C2 (Byte 6, 4-7) and
  487.         // C3 (Byte 8, 4-7) == ~C3 (Byte 7, 0-3)
  488.         byte[][] acMatrix = new byte[3][4];
  489.         if (acBytes.length > 2 &&
  490.                 (byte)((acBytes[1]>>>4)&0x0F)  ==
  491.                         (byte)((acBytes[0]^0xFF)&0x0F) &&
  492.                 (byte)(acBytes[2]&0x0F) ==
  493.                         (byte)(((acBytes[0]^0xFF)>>>4)&0x0F) &&
  494.                 (byte)((acBytes[2]>>>4)&0x0F)  ==
  495.                         (byte)((acBytes[1]^0xFF)&0x0F)) {
  496.             // C1, Block 0-3
  497.             for (int i = 0; i < 4; i++) {
  498.                 acMatrix[0][i] = (byte)((acBytes[1]>>>4+i)&0x01);
  499.             }
  500.             // C2, Block 0-3
  501.             for (int i = 0; i < 4; i++) {
  502.                 acMatrix[1][i] = (byte)((acBytes[2]>>>i)&0x01);
  503.             }
  504.             // C3, Block 0-3
  505.             for (int i = 0; i < 4; i++) {
  506.                 acMatrix[2][i] = (byte)((acBytes[2]>>>4+i)&0x01);
  507.             }
  508.             return acMatrix;
  509.         }
  510.         return null;
  511.     }
  512.  
  513.     /**
  514.      * 把矩阵控制位（比特类型的矩阵数组）转换为3字节的控制位
  515.      * @param acMatrix bit类型的控制位矩阵数组
  516.      * @return 返回3字节的字节数组
  517.      */
  518.     public static byte[] acMatrixToACBytes(byte acMatrix[][]) {
  519.         if (acMatrix != null && acMatrix.length == 3) {
  520.             for (int i = 0; i < 3; i++) {
  521.                 if (acMatrix[i].length != 4)
  522.                     // Error.
  523.                     return null;
  524.             }
  525.         } else {
  526.             // Error.
  527.             return null;
  528.         }
  529.         byte[] acBytes = new byte[3];
  530.         // Byte 6, Bit 0-3.
  531.         acBytes[0] = (byte)((acMatrix[0][0]^0xFF)&0x01);
  532.         acBytes[0] |= (byte)(((acMatrix[0][1]^0xFF)<<1)&0x02);
  533.         acBytes[0] |= (byte)(((acMatrix[0][2]^0xFF)<<2)&0x04);
  534.         acBytes[0] |= (byte)(((acMatrix[0][3]^0xFF)<<3)&0x08);
  535.         // Byte 6, Bit 4-7.
  536.         acBytes[0] |= (byte)(((acMatrix[1][0]^0xFF)<<4)&0x10);
  537.         acBytes[0] |= (byte)(((acMatrix[1][1]^0xFF)<<5)&0x20);
  538.         acBytes[0] |= (byte)(((acMatrix[1][2]^0xFF)<<6)&0x40);
  539.         acBytes[0] |= (byte)(((acMatrix[1][3]^0xFF)<<7)&0x80);
  540.         // Byte 7, Bit 0-3.
  541.         acBytes[1] = (byte)((acMatrix[2][0]^0xFF)&0x01);
  542.         acBytes[1] |= (byte)(((acMatrix[2][1]^0xFF)<<1)&0x02);
  543.         acBytes[1] |= (byte)(((acMatrix[2][2]^0xFF)<<2)&0x04);
  544.         acBytes[1] |= (byte)(((acMatrix[2][3]^0xFF)<<3)&0x08);
  545.         // Byte 7, Bit 4-7.
  546.         acBytes[1] |= (byte)((acMatrix[0][0]<<4)&0x10);
  547.         acBytes[1] |= (byte)((acMatrix[0][1]<<5)&0x20);
  548.         acBytes[1] |= (byte)((acMatrix[0][2]<<6)&0x40);
  549.         acBytes[1] |= (byte)((acMatrix[0][3]<<7)&0x80);
  550.         // Byte 8, Bit 0-3.
  551.         acBytes[2] = (byte)(acMatrix[1][0]&0x01);
  552.         acBytes[2] |= (byte)((acMatrix[1][1]<<1)&0x02);
  553.         acBytes[2] |= (byte)((acMatrix[1][2]<<2)&0x04);
  554.         acBytes[2] |= (byte)((acMatrix[1][3]<<3)&0x08);
  555.         // Byte 8, Bit 4-7.
  556.         acBytes[2] |= (byte)((acMatrix[2][0]<<4)&0x10);
  557.         acBytes[2] |= (byte)((acMatrix[2][1]<<5)&0x20);
  558.         acBytes[2] |= (byte)((acMatrix[2][2]<<6)&0x40);
  559.         acBytes[2] |= (byte)((acMatrix[2][3]<<7)&0x80);
  560.         
  561.         return acBytes;
  562.     }
  563.     
  564.     /*
  565.      * 根据一个控制位来进行所有的操作时使用的对象
  566.      * @param acBytes 控制位字节,四字节的控制位字节数组
  567.      * @return 返回this
  568.      */
  569.     public static AccessBitUitl operaOneAc(byte[] acBytes) {
  570.     	return new AccessBitUitl(acBytes);
  571.     }
  572.     
  573.     
  574.     /*
  575.      * 重载unpackAccessInfo，简化调用
  576.      */
  577.     public HashMap<ControlBitNum,Byte> unpackAccessInfo(DataBlockStructure block){
  578.     	return unpackAccessInfo(mAcBytes,block);
  579.     }
  580.     
  581.     /*
  582.      * 重载unpackAccessInfo，简化调用
  583.      */
  584.     public HashMap<DataBlockStructure,HashMap<ControlBitNum,Byte>> unpackAccessInfo(){
  585.     	DataBlockStructure[] blocks = { DataBlockStructure.BLOCK0 ,
  586.     			DataBlockStructure.BLOCK1 , 
  587.     			DataBlockStructure.BLOCK2 , 
  588.     			DataBlockStructure.BLOCK3 };
  589.     	HashMap<DataBlockStructure,HashMap<ControlBitNum,Byte>> result = new HashMap<DataBlockStructure,HashMap<ControlBitNum,Byte>>();
  590.     	for(int i = 0; i < 4; ++i) {
  591.     		result.put(blocks[i] , unpackAccessInfo(blocks[i]));
  592.     	}
  593.     	return result;
  594.     }
  595.     
  596.     
  597. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Li_阴宅/article/detail/985050
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号