├── README.md
├── ServerTest.java
├── Simple8583Test.java
├── com
    └── simple8583
    │   ├── client
    │       ├── AbstractClient.java
    │       └── SimpleClient.java
    │   ├── exception
    │       └── Simple8583Exception.java
    │   ├── factory
    │       ├── AbstractIsoMsgFactory.java
    │       ├── IsoMsgFactory.java
    │       └── XmlReader.java
    │   ├── key
    │       └── SimpleConstants.java
    │   ├── model
    │       ├── BitMap.java
    │       ├── IsoContainer.java
    │       ├── IsoField.java
    │       ├── IsoHeaderList.java
    │       ├── IsoPackage.java
    │       └── IsoType.java
    │   ├── server
    │       ├── AbstractServer.java
    │       └── DefaultServer.java
    │   ├── type
    │       ├── BINARY.java
    │       ├── CHAR.java
    │       ├── IsoType.java
    │       ├── LLLVAR.java
    │       └── LLVAR.java
    │   └── util
    │       ├── EncodeUtil.java
    │       ├── SimpleUtil.java
    │       ├── TraceGenerator.java
    │       └── encrypt
    │           ├── DES.java
    │           ├── MacUtil.java
    │           └── TripleDES.java
├── simple8583.dtd
└── simple8583.xml


/README.md:
--------------------------------------------------------------------------------
1 | Simple Iso8583 FrameWork
2 | 
3 | Encountering Iso8583 when I access in bank's interface. I complete a framework to simplify the difficulty in development. I publish it on github to help you to enhance your efficiency and have more time to get rest and play.
4 | 
5 | This version is built upon pure j2se, no external dependency, it is  small and flexible. There is also have another Maven Version to use.Here is the configuration:
6 | 
7 | Please contact <a href="mailto:out_lier@126.com">Magic Joey</a> when you have any problem or want to join me in open source.
8 | 


--------------------------------------------------------------------------------
/ServerTest.java:
--------------------------------------------------------------------------------
 1 | import com.simple8583.factory.XmlReader;
 2 | import com.simple8583.server.DefaultServer;
 3 | 
 4 | 
 5 | /**
 6 |  * <p>服务器端测试类.</p>
 7 |  *
 8 |  * @author Magic Joey
 9 |  * @version Server8583Test.java 1.0 Created@2015-06-16 13:19 $
10 |  */
11 | public class ServerTest {
12 | 
13 | 
14 |     public static void main(String[] args) throws  Exception {
15 |         XmlReader xmlReader  = new XmlReader("simple8583.xml");
16 |         new DefaultServer().init(xmlReader);
17 |     }
18 | 
19 | 
20 | }
21 | 


--------------------------------------------------------------------------------
/Simple8583Test.java:
--------------------------------------------------------------------------------
 1 | import com.simple8583.client.SimpleClient;
 2 | import com.simple8583.factory.XmlReader;
 3 | import com.simple8583.key.SimpleConstants;
 4 | 
 5 | import javax.xml.bind.JAXBException;
 6 | import java.io.IOException;
 7 | import java.util.HashMap;
 8 | import java.util.Map;
 9 | 
10 | /**
11 |  * <p>测试类.</p>
12 |  *
13 |  * @author Magic Joey
14 |  * @version Simple8583Test.java 1.0 Created@2015-6-15 12:46 $
15 |  */
16 | public class Simple8583Test {
17 | 
18 |     public static void main(String[] args) throws Exception {
19 |         Map<String,String> requestMap = new HashMap<String,String>();
20 |         requestMap.put(SimpleConstants.MTI,"0430");
21 |         requestMap.put("15","SP99515061500104387");
22 |         requestMap.put("13","张清源");
23 |         requestMap.put("14","156");
24 |         requestMap.put("12","pay");
25 |         requestMap.put("3","12M01041");
26 |         requestMap.put("2","470000");
27 |         requestMap.put("7","492500");
28 |         requestMap.put("6","6228210250013865710");
29 |         requestMap.put("5","04");
30 |         requestMap.put("4","01041");
31 |         requestMap.put("9","012");
32 |         requestMap.put("8","SP99515061500104387");
33 |         String ip = "localhost";
34 |         int port = 8999;
35 |         int timeout = 15000;//15s超时
36 | 
37 |         String macKey = "helloSimple8583";
38 |         SimpleClient simpleClient = new SimpleClient(ip,port,timeout);
39 |         simpleClient.setMacKey(macKey);
40 |         XmlReader xmlReader = new XmlReader("simple8583.xml");
41 |         Map<String,String> resultMap = simpleClient.sendToBank(requestMap,xmlReader);
42 |         System.out.println(resultMap);
43 |     }
44 | 
45 | 
46 | }
47 | 


--------------------------------------------------------------------------------
/com/simple8583/client/AbstractClient.java:
--------------------------------------------------------------------------------
  1 | package com.simple8583.client;
  2 | 
  3 | import java.net.InetAddress;
  4 | import java.net.InetSocketAddress;
  5 | import java.net.Socket;
  6 | import java.util.Map;
  7 | 
  8 | import com.simple8583.exception.Simple8583Exception;
  9 | import com.simple8583.factory.IsoMsgFactory;
 10 | import com.simple8583.factory.XmlReader;
 11 | import com.simple8583.model.IsoPackage;
 12 | 
 13 | /**
 14 |  * <p>发送客户端抽象类.</p>
 15 |  *
 16 |  * @author Magic Joey
 17 |  * @version AbstractClient.java 1.0 Created@2014-07-10 10:43 $
 18 |  */
 19 | public abstract class AbstractClient {
 20 |     //默认18s超时
 21 | 	protected int timeout = 18000;
 22 |     //Ip地址
 23 | 	protected String ip;
 24 |     //端口号
 25 | 	protected int port;
 26 |     //加密串，用于MD5或者DES加密
 27 | 	protected String macKey;
 28 | 
 29 | 	public AbstractClient(String ip, int port){
 30 | 		this.ip = ip;
 31 | 		this.port = port;
 32 | 	}
 33 | 
 34 | 	//设置访问的Ip地址，端口号和超时时间
 35 | 	public AbstractClient(String ip, int port, int timeout) {
 36 | 		this(ip, port);
 37 | 		this.timeout = timeout;
 38 | 	}
 39 | 
 40 | 	//发送接受报文的方法
 41 | 	public Map<String, String> sendToBank(Map<String, String> dataMap,
 42 | 			XmlReader xmlReader) throws Exception {
 43 | 		//单例
 44 | 		IsoMsgFactory factory = IsoMsgFactory.getInstance();
 45 | 		factory.setMacKey(macKey);
 46 | 		String mti = dataMap.get("mti");
 47 | 		IsoPackage pack = xmlReader.getIsoConfig().get(mti);
 48 | 		byte[] buf = null;
 49 | 		try {
 50 | 			byte[] sendData = factory.pack(dataMap, pack);
 51 | 			Socket socket = new Socket();
 52 | 			InetAddress inetAddress = InetAddress.getByName(this.ip);
 53 | 			InetSocketAddress address = new InetSocketAddress(inetAddress, port);
 54 | 			try {
 55 | 				// 发送的报文
 56 | //				System.out.println("发送报文：" + EncodeUtil.hex(sendData));
 57 | 				socket.setReuseAddress(true);
 58 | 				socket.connect(address);
 59 | 				socket.setSoTimeout(this.timeout);
 60 | 				//发送数据
 61 | 				socket.getOutputStream().write(sendData);
 62 | 				socket.getOutputStream().flush();
 63 | 				//两字节长度
 64 | 				byte[] lenbuf = new byte[2];
 65 | 				while (socket != null && socket.isConnected()) {
 66 | 					if (socket.getInputStream().read(lenbuf) == 2) {
 67 | 						//计算前两位报文所表示的报文长度
 68 | 						int size = computeLength(lenbuf);
 69 | 						//新建对应长度字节数组
 70 | 						buf = new byte[size];
 71 | 						//读取数据
 72 | 						socket.getInputStream().read(buf);
 73 | 						break;
 74 | 					}
 75 | 				}
 76 | 				
 77 | //				System.out.println(EncodeUtil.hex(buf));
 78 | 			} finally {
 79 | 				if (socket != null) {
 80 | 					try {
 81 | 						socket.close();
 82 | 					} catch (Exception e) {
 83 | 						
 84 | 					}
 85 | 				}
 86 | 			}
 87 | 		} catch (Exception e) {
 88 | //			e.printStackTrace();
 89 | 			//抛出可能的异常，比如连接超时等
 90 | 			throw new Simple8583Exception("网络通讯异常",e);
 91 | 		}
 92 | 		//将前面的MsgLength域剔除
 93 | 		pack.remove(0);
 94 | 		//根据IsoPackage的结构解析接受到的报文
 95 | 		return factory.unpack(buf, pack);
 96 | 	}
 97 | 	
 98 | 	protected abstract int computeLength(byte[] lenBts);
 99 | 
100 | 
101 |     public void setMacKey(String macKey) {
102 |         this.macKey = macKey;
103 |     }
104 | 
105 | }
106 | 


--------------------------------------------------------------------------------
/com/simple8583/client/SimpleClient.java:
--------------------------------------------------------------------------------
 1 | package com.simple8583.client;
 2 | 
 3 | 
 4 | /**
 5 |  * <p>发送客户端.</p>
 6 |  *
 7 |  * @author Magic Joey
 8 |  * @version AbstractClient.java 1.0 Created@2014-07-10 10:43 $
 9 |  */
10 | public class SimpleClient extends AbstractClient{
11 | 	
12 | 	//构造方法
13 | 	public SimpleClient(String ip, int port){
14 | 		super(ip, port);
15 | 	}
16 | 	
17 | 	public SimpleClient(String ip,int port,int timeout) {
18 | 		super(ip, port, timeout);
19 | 	}
20 | 
21 | 	
22 | 	// 接口长度的定义方式，可根据需求更改
23 | 	// 第一字节值=len/256;
24 | 	// 第二字节值=len%256;
25 | 	@Override
26 | 	protected int computeLength(byte[] lenBts){
27 | 		if(lenBts.length!=2){
28 | 			throw new IllegalArgumentException("字节长度不正确，预期值为2，实际值为："+lenBts.length);
29 | 		}
30 | 		// int size = ((lenbuf[0] & 0xff) << 8) | (lenbuf[1] & 0xff);//普通的长度编码
31 | 		return (lenBts[0] & 0xff) * 256
32 | 				+ (lenBts[1] & 0xff);
33 | 	}
34 | 
35 | }
36 | 


--------------------------------------------------------------------------------
/com/simple8583/exception/Simple8583Exception.java:
--------------------------------------------------------------------------------
 1 | package com.simple8583.exception;
 2 | 
 3 | /**
 4 |  * <p>框架运行时异常.</p>
 5 |  *
 6 |  * @author Magic Joey
 7 |  * @version Simple8583Exception.java 1.0 Created@2015-06-15 22:18 $
 8 |  */
 9 | public class Simple8583Exception extends RuntimeException{
10 | 
11 |     public Simple8583Exception() {
12 |         super();
13 |     }
14 | 
15 |     public Simple8583Exception(String s) {
16 |         super(s);
17 |     }
18 | 
19 |     public Simple8583Exception(String s, Throwable throwable) {
20 |         super(s, throwable);
21 |     }
22 | 
23 |     public Simple8583Exception(Throwable throwable) {
24 |         super(throwable);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/com/simple8583/factory/AbstractIsoMsgFactory.java:
--------------------------------------------------------------------------------
  1 | package com.simple8583.factory;
  2 | 
  3 | import java.io.ByteArrayOutputStream;
  4 | import java.io.IOException;
  5 | import java.io.UnsupportedEncodingException;
  6 | import java.util.ArrayList;
  7 | import java.util.HashMap;
  8 | import java.util.List;
  9 | import java.util.Map;
 10 | 
 11 | import com.simple8583.key.SimpleConstants;
 12 | import com.simple8583.model.BitMap;
 13 | import com.simple8583.model.IsoField;
 14 | import com.simple8583.model.IsoPackage;
 15 | import com.simple8583.util.EncodeUtil;
 16 | import com.simple8583.util.SimpleUtil;
 17 | 
 18 | 
 19 | /**
 20 |  * <p>报文组装抽象类.</p>
 21 |  *
 22 |  * @author Magic Joey
 23 |  * @version AbstractIsoMsgFactory.java 1.0 Created@2014-07-10 10:43 $
 24 |  */
 25 | public abstract class AbstractIsoMsgFactory {
 26 | 
 27 | 	protected String macKey;
 28 | 
 29 | 	protected AbstractIsoMsgFactory() {
 30 | 
 31 | 	}
 32 | 	
 33 | 	// 入口和出口
 34 | 	public byte[] pack(Map<String, String> dataMap,final IsoPackage pack)
 35 |             throws IOException, ClassNotFoundException {
 36 |         //深度拷贝，对拷贝后的对象进行操作，
 37 | 		IsoPackage packClone = pack.deepClone();
 38 | 
 39 | 		List<Integer> dataFieldList = new ArrayList<Integer>(dataMap.size());
 40 | 		for (String key : dataMap.keySet()) {
 41 | 			IsoField field = packClone.getIsoField(key);
 42 | 			if (field == null) {
 43 | 				continue;
 44 | 			}
 45 | 			field.setValue(dataMap.get(key));
 46 | 			//数据域
 47 | 			if (SimpleUtil.isNumeric(key)) {
 48 | 				int val = Integer.valueOf(key);
 49 | 				if(packClone.isBit64()&&val>64){
 50 |                     //设置位非64位图模式，即128模式
 51 |                     packClone.setBit64(false);
 52 |                     //将bitMap第一位置为1，表示这个数据域为128位长
 53 | 					dataFieldList.add(1);
 54 | 				}
 55 | 				dataFieldList.add(val);
 56 | 			}
 57 | 		}
 58 | 		// 生成BitMap
 59 | 		BitMap bitMap = null;
 60 | 		if(packClone.isBit64()){
 61 |             bitMap = new BitMap(64);
 62 | 		}else{
 63 |             bitMap = new BitMap(128);
 64 | 		}
 65 | 		byte[] bitMapByte = bitMap.addBits(dataFieldList);
 66 | 		//设置BitMap的值
 67 | 		packClone.getIsoField(SimpleConstants.BIT_MAP).setByteValue(bitMapByte);
 68 | 		//将数组合并
 69 | 		return merge(packClone);
 70 | 	}
 71 | 
 72 |     /**
 73 |      * 将返回信息拆成Map返回
 74 |      * @param bts
 75 |      * @param pack
 76 |      * @return
 77 |      * @throws Exception
 78 |      */
 79 | 	public Map<String, String> unpack(byte[] bts,final IsoPackage pack)
 80 | 			throws Exception {
 81 | 		if (pack == null || pack.size() == 0) {
 82 | 			throw new IllegalArgumentException("配置为空，请检查IsoPackage是否为空");
 83 | 		}
 84 | 		Map<String, String> returnMap = new HashMap<String, String>();
 85 | 		// 起判断的作用
 86 | 		int offset = 0;
 87 |         //深度拷贝
 88 | 		IsoPackage target =  pack.deepClone();
 89 | 		// 获取到bitMap
 90 | 		boolean hasBitMap = false;
 91 | 		BitMap bitMap = null;
 92 | 		for (IsoField field : target) {
 93 | 				
 94 | 			if (field.isAppData()) {
 95 | 				if (hasBitMap) {
 96 | 					int index = Integer.valueOf(field.getId());
 97 | 					if(index==1){
 98 | 						continue;//第一位不处理，只是标志位
 99 | 					}
100 | 					if (bitMap.getBit(index - 1) == 1) {
101 | 						offset += subByte(bts, offset, field);
102 | 						returnMap.put(field.getId(), field.getValue());
103 | 					}
104 | 				}
105 | 			} else {
106 | 				offset += subByte(bts, offset, field);
107 | 				returnMap.put(field.getId(), field.getValue());
108 | 				if (field.getId().equalsIgnoreCase(SimpleConstants.BIT_MAP)) {
109 | 					hasBitMap = true;
110 | 					bitMap = BitMap.addBits(field.getByteValue());
111 | 				}
112 | 			}
113 | 		}
114 | 		//MAC校验
115 | 		macValidate(pack,returnMap);
116 | 		return returnMap;
117 | 	}
118 | 
119 | 	private int subByte(byte[] bts, int offset, IsoField field)
120 | 			throws UnsupportedEncodingException {
121 | 		byte[] val = null;
122 | 		int length = field.getLength();
123 | 		switch (field.getIsoType()) {
124 | 		case NUMERIC:
125 | 		case CHAR:
126 | 		case BINARY:
127 | 			val = new byte[field.getLength()];
128 | 			System.out.println(field.getId());
129 | 			System.arraycopy(bts, offset, val, 0, length);
130 | 			break;
131 | 		case LLVAR_NUMERIC:
132 | 			byte[] llvarNumLen = new byte[1];
133 | 			llvarNumLen[0] = bts[offset];
134 | 			// 除以2的原因是LLVAR_NUMERIC前面的报文域长度是数字长度而非字节长度
135 | 			int firstNumLen = Integer.valueOf(EncodeUtil.hex(llvarNumLen)) / 2;
136 | 			val = new byte[firstNumLen];
137 | 			System.arraycopy(bts, offset + 1, val, 0, firstNumLen);
138 | 			length = 1 + firstNumLen;
139 | 			break;
140 | 		case LLVAR:
141 | 			byte[] llvarLen = new byte[1];
142 | 			llvarLen[0] = bts[offset];
143 | 			int firstLen = Integer.valueOf(EncodeUtil.hex(llvarLen));
144 | 			val = new byte[firstLen];
145 | 			System.arraycopy(bts, offset + 1, val, 0, firstLen);
146 | 			length = 1 + firstLen;
147 | 			break;
148 | 		case LLLVAR:
149 | 			byte[] lllvarLen = new byte[2];
150 | 			lllvarLen[0] = bts[offset];
151 | 			lllvarLen[1] = bts[offset + 1];
152 | 			int first2Len = Integer.valueOf(EncodeUtil.hex(lllvarLen));
153 | 			val = new byte[first2Len];
154 | 			System.arraycopy(bts, offset + 2, val, 0, first2Len);
155 | 			length = 2 + first2Len;
156 | 			break;
157 | 		default:
158 | 			break;
159 | 		}
160 | 		field.setByteValue(val);
161 | 		return length;
162 | 	}
163 | 
164 | 	// Byte数组的合并，不同byte数组域将被整合为一个大的byte数组
165 | 	private byte[] merge(IsoPackage isoPackage) throws IOException {
166 | 		ByteArrayOutputStream byteOutPut = new ByteArrayOutputStream(100);
167 | 		for (IsoField field : isoPackage) {
168 | 			if (field.isChecked()) {
169 |                 //Mac
170 | 				if (isoPackage.isMacPos(field.getId())) {
171 | 					try {
172 | 						byteOutPut.write(mac(isoPackage));
173 | 					} catch (Exception e) {
174 | 						e.printStackTrace();
175 | 					}
176 | 					continue;
177 | 				}
178 | 				switch (field.getIsoType()) {
179 | 				case LLVAR_NUMERIC:
180 | 					byte[] lengthByte0 = new byte[1];
181 | 					lengthByte0 = EncodeUtil.bcd(field.getValue().length(), 1);
182 | 					byteOutPut.write(lengthByte0);
183 | 					break;
184 | 				case LLVAR:
185 | 					byte[] lengthByte = new byte[1];
186 | 					lengthByte = EncodeUtil.bcd(field.getByteValue().length, 1);
187 | 					byteOutPut.write(lengthByte);
188 | 					break;
189 | 				case LLLVAR:
190 | 					byte[] lengthByte2 = new byte[2];
191 | 					lengthByte2 = EncodeUtil
192 | 							.bcd(field.getByteValue().length, 2);
193 | 					byteOutPut.write(lengthByte2);
194 | 					break;
195 | 				default:
196 | 					break;
197 | 				}
198 | 				System.out.println(field.getId() + ":"
199 | 						+ EncodeUtil.hex(field.getByteValue()));
200 | 
201 | 				byteOutPut.write(field.getByteValue());
202 | 			}
203 | 		}
204 | 		byte[] beforeSend = byteOutPut.toByteArray();
205 | 		byte[] bts = new byte[beforeSend.length + 2];
206 | 		byte[] lenArr = msgLength(beforeSend.length);
207 | 		//
208 | 		System.arraycopy(lenArr, 0, bts, 0, 2);
209 | 		System.arraycopy(beforeSend, 0, bts, 2, beforeSend.length);
210 | 		return bts;
211 | 	}
212 | 	
213 | 	//生成前两个字节的长度位
214 | 	//根据约定不同需要对此方法进行重写
215 | 	protected abstract byte[] msgLength(int length);
216 | 	
217 | 	//生成最后一位的MAC加密
218 | 	protected abstract byte[] mac(IsoPackage isoPackage) throws Exception;
219 | 	
220 | 	//对返回的数据进行MAC校验
221 | 	protected abstract void macValidate(IsoPackage isoPackage,Map<String,String> map);
222 | 
223 |     public void setMacKey(String macKey) {
224 |         this.macKey = macKey;
225 |     }
226 | }
227 | 


--------------------------------------------------------------------------------
/com/simple8583/factory/IsoMsgFactory.java:
--------------------------------------------------------------------------------
 1 | package com.simple8583.factory;
 2 | 
 3 | import java.util.Map;
 4 | 
 5 | import com.simple8583.model.IsoField;
 6 | import com.simple8583.model.IsoPackage;
 7 | import com.simple8583.util.EncodeUtil;
 8 | import com.simple8583.util.encrypt.TripleDES;
 9 | 
10 | 
11 | /**
12 |  * <p>报文组装抽象类.</p>
13 |  *
14 |  * @author Magic Joey
15 |  * @version IsoMsgFactory.java 1.0 Created@2014-07-09 17:41 $
16 |  */
17 | public class IsoMsgFactory extends AbstractIsoMsgFactory{
18 | 	
19 | 	private  static IsoMsgFactory isoMsgFactory=new IsoMsgFactory();
20 | 	
21 | 	protected IsoMsgFactory(){
22 | 		
23 | 	}
24 | 
25 | 	public static IsoMsgFactory getInstance(){
26 | 		return isoMsgFactory;
27 | 	}
28 | 
29 | 
30 | 	// 编码规则
31 | 	// 2 Primary Account Number
32 | 	// 3 Processing Code
33 | 	// 4 Amount, Transaction
34 | 	// 11 System Trace Audit Number
35 | 	// 12 Time, Local Transaction
36 | 	// 13 Date, Local Transaction
37 | 	// 49 Currency Code, Transaction
38 | 	// 38 Authorization Identification Response
39 | 	// 39 Response Code
40 | 	// 41 Card Acceptor Terminal Identification
41 | 	@Override
42 | 	protected byte[] mac(IsoPackage isoPackage) throws Exception {
43 | 		String[] md5Array = { "2", "3", "4", "11", "12", "13", "49", "38",
44 | 				"39", "41" };
45 | 		StringBuffer accum = new StringBuffer();
46 | 		for (String key : md5Array) {
47 | 			IsoField field = isoPackage.getIsoField(key);
48 | 			if (field == null) {
49 | 				continue;
50 | 			}
51 | 			if (field.getValue() == null) {
52 | 				continue;
53 | 			}
54 | 			if (field.getId().equals("49")) {
55 | 				accum.append(field.getValue().substring(1));
56 | 			} else {
57 | 				accum.append(field.getValue());
58 | 			}
59 | 		}
60 | 		String original = accum.toString();
61 | 		String val = TripleDES.getMac(macKey, original);
62 | 		return EncodeUtil.bcd(val);
63 | 	}
64 | 
65 | 
66 | 	//生成前两个字节的长度位
67 | 	//根据约定不同需要对此方法进行重写
68 | 	@Override
69 | 	protected byte[] msgLength(int length) {
70 | 		byte[] rByte = new byte[2];
71 | 		rByte[0] = (byte)(length/255);
72 | 		rByte[1] = (byte)(length%255);
73 | 		return rByte;
74 | 	}
75 | 
76 | 	//重写MAC校验方法，验证失败则抛出运行时异常
77 | 	@Override
78 | 	protected void macValidate(IsoPackage isoPackage, Map<String, String> map) {
79 | 		String mac = null;
80 | 		try {
81 | 			mac =  EncodeUtil.hex(mac(isoPackage));
82 | 		} catch (Exception e) {
83 | 			e.printStackTrace();
84 | 		}
85 | 		String returnMac = EncodeUtil.hex(EncodeUtil.binary(map.get("64")));//Binary编码转换为hex编码
86 | 		if(!(mac.substring(0,8).equals(returnMac.substring(0,8)))){
87 | 			throw new RuntimeException("MAC校验失败，返回值"+returnMac+",计算值"+mac);
88 | 		}
89 | 	}
90 | 
91 | 
92 | }


--------------------------------------------------------------------------------
/com/simple8583/factory/XmlReader.java:
--------------------------------------------------------------------------------
 1 | package com.simple8583.factory;
 2 | 
 3 | import java.io.IOException;
 4 | import java.io.InputStream;
 5 | import java.util.ArrayList;
 6 | import java.util.Map;
 7 | import java.util.concurrent.ConcurrentHashMap;
 8 | 
 9 | import javax.xml.bind.JAXBContext;
10 | import javax.xml.bind.JAXBException;
11 | import javax.xml.bind.Unmarshaller;
12 | 
13 | import com.simple8583.exception.Simple8583Exception;
14 | import com.simple8583.model.IsoContainer;
15 | import com.simple8583.model.IsoField;
16 | import com.simple8583.model.IsoHeaderList;
17 | import com.simple8583.model.IsoPackage;
18 | 
19 | /**
20 |  * <p>XmlReader 本方法的实现是通过JaxB来实现的，比较方便得将Xml文件与Object文件做相互转换.</p>
21 |  *
22 |  * @author Magic Joey
23 |  * @version XmlReader.java 1.0 Created@2014-07-12 13:28 $
24 |  */
25 | public class XmlReader {
26 | 
27 | 	// 配置的记录信息
28 | 	// mti
29 | 	private Map<String, IsoPackage> isoConfig = new ConcurrentHashMap<String, IsoPackage>();
30 | 
31 | 	public Map<String, IsoPackage> getIsoConfig() {
32 | 		return isoConfig;
33 | 	}
34 | 
35 | 	public XmlReader(String path) throws JAXBException, IOException {
36 | 		// 如果配置为空，则初始化，否则跳过
37 | 		if (isoConfig.size() == 0) {
38 | 			init(path);
39 | 		}
40 | 	}
41 | 
42 | 	// 负责将配置文件解析缓存在
43 | 	@SuppressWarnings("unchecked")
44 | 	private void init(String path) throws IOException {
45 | 		InputStream is = null;
46 | 		try {
47 | 			// 获取
48 | 			is = ClassLoader.getSystemResourceAsStream(path);
49 | 			if (is == null) {
50 | 				throw new Simple8583Exception("配置文件路径错误:" + path);
51 | 			}
52 | 			IsoContainer container = this.readConfigFromStream(
53 | 					IsoContainer.class, is);
54 | //			System.out.println(container.size());
55 | 			is = ClassLoader.getSystemResourceAsStream(path);
56 | 			IsoHeaderList headerList = readConfigFromStream(
57 | 					IsoHeaderList.class, is);
58 | //			System.out.println(headerList.size());
59 | 			for (IsoPackage pack : container) {
60 | 				// 将读取到的header信息插入前面
61 | 				pack.addAll(0, (ArrayList<IsoField>) (headerList.clone()));
62 | 				this.isoConfig.put(String.valueOf(pack.getMti()), pack);
63 | 			}
64 | 		} finally {
65 | 			if (is != null) {
66 | 				is.close();
67 | 			}
68 | 
69 | 		}
70 | 	}
71 | 
72 | 	@SuppressWarnings("unchecked")
73 | 	private <T> T readConfigFromStream(Class<T> clazz,
74 | 			final InputStream dataStream) {
75 | 		try {
76 | 			JAXBContext jc = JAXBContext.newInstance(clazz);
77 | 			Unmarshaller u = jc.createUnmarshaller();
78 | 			return (T) u.unmarshal(dataStream);
79 | 		} catch (JAXBException e) {
80 | 			throw new Simple8583Exception(e);
81 | 		}
82 | 	}
83 | 
84 | }
85 | 


--------------------------------------------------------------------------------
/com/simple8583/key/SimpleConstants.java:
--------------------------------------------------------------------------------
 1 | package com.simple8583.key;
 2 | 
 3 | 
 4 | /**
 5 |  * <p>存储一些关键字.</p>
 6 |  *
 7 |  * @author Magic Joey
 8 |  * @version SimpleConstants.java 1.0 Created@2014-07-12 13:28 $
 9 |  */
10 | public interface SimpleConstants {
11 | 
12 | 	
13 | //	public static String MSG_LENGTH = "MsgLength";
14 | 	public static String MTI = "mti";
15 | 	public static String TPDU = "tpdu";
16 | 	public static String VERSION_NO = "VersionNo";
17 | 	public static String BIT_MAP = "BitMap";
18 | 	
19 | 	public static String ENCODING = "GBK";
20 | 	
21 | }
22 | 


--------------------------------------------------------------------------------
/com/simple8583/model/BitMap.java:
--------------------------------------------------------------------------------
  1 | package com.simple8583.model;
  2 | 
  3 | import java.lang.IllegalArgumentException;
  4 | import java.util.List;
  5 | 
  6 | import com.simple8583.util.EncodeUtil;
  7 | 
  8 | /**
  9 |  * <p>位图类.</p>
 10 |  *
 11 |  * @author Magic Joey
 12 |  * @version BitMap.java 1.0 Created@2014-07-12 13:28 $
 13 |  */
 14 | public class BitMap {
 15 | 
 16 | 	private int[] bits = null;
 17 | 	private int length;
 18 | 	private final static int[] bitValue = { 0x80000000, 0x40000000, 0x20000000,
 19 | 			0x10000000, 0x08000000, 0x04000000, 0x02000000, 0x01000000,
 20 | 			0x00800000, 0x00400000, 0x00200000, 0x00100000, 0x00080000,
 21 | 			0x00040000, 0x00020000, 0x00010000, 0x00008000, 0x00004000,
 22 | 			0x00002000, 0x00001000, 0x00000800, 0x00000400, 0x00000200,
 23 | 			0x00000100, 0x00000080, 0x00000040, 0x00000020, 0x00000010,
 24 | 			0x00000008, 0x00000004, 0x00000002, 0x00000001 };
 25 | 
 26 | 	public BitMap(int length) {
 27 | 		if (length < 0) {
 28 | 			throw new IllegalArgumentException("长度必须大于0!");
 29 | 		}
 30 | 		bits = new int[length / 32 + ((length % 32) > 0 ? 1 : 0)];
 31 | 		this.length = length;
 32 | 	}
 33 | 
 34 | 	public int getBit(int index) {
 35 | 		if (index < 0 || index > length) {
 36 | 			throw new IllegalArgumentException("length value illegal!");
 37 | 		}
 38 | 		int intData = bits[index / 32];
 39 | 		return ((intData & bitValue[index % 32]) >>> (32 - index % 32 - 1));
 40 | 	}
 41 | 	
 42 | 	public byte[] addBits(List<Integer> list){
 43 | 		for(int val:list){
 44 | 			//本处-1的原因是，BitMap在1~64之间，而实际存储为0~63
 45 | 			addBit(val-1);
 46 | 		}
 47 | 		return getBitMap();
 48 | 	}
 49 | 	
 50 | 	public byte[] addBits(int[] bitArray){
 51 | 		for(int i=0;i<bitArray.length;i++){
 52 | 			if(bitArray[i]==1){
 53 | 				addBit(i);
 54 | 			}
 55 | 		}
 56 | 		return getBitMap();
 57 | 	}
 58 | 	
 59 | 	public byte[] addBits(String regix){
 60 | 		String[] vals = regix.split(",");
 61 | 		for(String val:vals){
 62 | 			//本处-1的原因是，BitMap在1~64之间，而实际存储为0~63
 63 | 			addBit(Integer.valueOf(val)-1);
 64 | 		}
 65 | 		return getBitMap();
 66 | 	}
 67 | 	
 68 | 	//根据返回的bit值
 69 | 	public static BitMap addBits(byte[] bits){
 70 | 		BitMap bitMap = new BitMap(bits.length*8);
 71 | 		int pointer=0;
 72 | 		for(byte bt:bits){
 73 | 			for(int pos=7;pos>=0;pos--){
 74 | 				//判断该位是否为0
 75 | 				if((int)(bt>>>pos&0x01)==1){
 76 | 					bitMap.addBit(pointer);
 77 | 				}
 78 | 				pointer++;
 79 | 			}
 80 | 		}
 81 | 		return bitMap;
 82 | 	}
 83 | 
 84 | 	public void addBit(int index) {
 85 | 		if (index < 0 || index > length) {
 86 | 			throw new IllegalArgumentException("长度有误!");
 87 | 		}
 88 | 		int intData = bits[index / 32];
 89 | 		bits[index / 32] = intData | bitValue[index % 32];
 90 | //		if (value == 1) {
 91 | //		}/* else {
 92 | //			bits[index / 32] = intData & ~bitValue[index % 32];
 93 | //		}*/
 94 | 	}
 95 | 	
 96 | 	
 97 | 	public byte[] getBitMap(){
 98 | 		StringBuffer accum = new StringBuffer();
 99 | 		for(int index=1;index<=length;index++){
100 | //			System.out.println(index);
101 | 			accum.append(this.getBit(index-1));
102 | 		}
103 | 		return EncodeUtil.binary(accum.toString());
104 | 	}
105 | 
106 | 	public int getLength() {
107 | 		return length;
108 | 	}
109 | 	
110 | 	@Override
111 | 	public String toString(){
112 | 		StringBuffer accum = new StringBuffer();
113 | 		accum.append("length:"+this.length+",选中的域:");
114 | 		for(int i=0;i<length;i++){
115 | 			if(this.getBit(i)==1){
116 | 				accum.append(i+1+",");
117 | 			}
118 | 		}
119 | 		return accum.toString();
120 | 	}
121 | 
122 | 	public static void main(String[] args) {
123 | //		BitMap bitArray = new BitMap(64);
124 | //		bitArray.addBits("1,2,15,");
125 | //		System.out.println(EncodeUtil.hex(bitArray.getBitMap()));
126 | //		byte[] i=new byte[8];
127 | //		for(int pos = 0;pos<8;pos++){
128 | //			i[pos]=(byte)10;
129 | //		}
130 | //		addBits(i);
131 | 		byte[] bts = EncodeUtil.bcd("7124058104F18005");
132 | 		int[] intArr = new int[bts.length*8];
133 | 		int curse = 0;
134 | 		StringBuilder accum = new StringBuilder();
135 | 		for(int i=0;i<8;i++){
136 | 			for(int j=7;j>=0;j--){
137 | 				intArr[curse++] = (bts[i]>>>j)&0x01;
138 | 			}
139 | 		}
140 | 		int c=0;
141 | 		
142 | 		for(int i:intArr){
143 | 			if(i==1){
144 | 				accum.append(c+1+",");
145 | 				System.out.println(c+1);
146 | 			}
147 | 			c++;
148 | 		}
149 | 		System.out.println(accum.toString());
150 | 	}
151 | 
152 | }
153 | 


--------------------------------------------------------------------------------
/com/simple8583/model/IsoContainer.java:
--------------------------------------------------------------------------------
 1 | package com.simple8583.model;
 2 | 
 3 | import java.util.Vector;
 4 | import javax.xml.bind.annotation.XmlAccessType;
 5 | import javax.xml.bind.annotation.XmlAccessorType;
 6 | import javax.xml.bind.annotation.XmlElement;
 7 | import javax.xml.bind.annotation.XmlRootElement;
 8 | 
 9 | /**
10 |  * <p>组织包报文格式类.</p>
11 |  *
12 |  * @author Magic Joey
13 |  * @version IsoContainer.java 1.0 Created@2014-07-10 15:49 $
14 |  */
15 | @XmlRootElement(name="simple8583-config")
16 | @XmlAccessorType(XmlAccessType.FIELD)
17 | public class IsoContainer extends Vector<IsoPackage>{
18 | 
19 | 	private static final long serialVersionUID = -4470632464434928749L;
20 | 
21 | 	@XmlElement(name="package")
22 |     public Vector<IsoPackage> getPackages(){
23 |         return this;
24 |     }
25 | 
26 |     public IsoPackage getPackByMti(String mti){
27 |         for(IsoPackage pack:this){
28 |             if(pack.getMti().equals(mti)){
29 |                 return pack;
30 |             }
31 |         }
32 |         return null;
33 |     }
34 | 
35 | }


--------------------------------------------------------------------------------
/com/simple8583/model/IsoField.java:
--------------------------------------------------------------------------------
  1 | package com.simple8583.model;
  2 | 
  3 | import java.io.Serializable;
  4 | import java.io.UnsupportedEncodingException;
  5 | 
  6 | import javax.xml.bind.annotation.XmlAccessType;
  7 | import javax.xml.bind.annotation.XmlAccessorType;
  8 | import javax.xml.bind.annotation.XmlAttribute;
  9 | 
 10 | import com.simple8583.key.SimpleConstants;
 11 | import com.simple8583.util.EncodeUtil;
 12 | import com.simple8583.util.SimpleUtil;
 13 | 
 14 | /**
 15 |  * <p>报文域详情.</p>
 16 |  *
 17 |  * @author Magic Joey
 18 |  * @version IsoField.java 1.0 Created@2014-07-10 15:49 $
 19 |  */
 20 | @XmlAccessorType(XmlAccessType.FIELD)
 21 | public class IsoField implements Serializable{
 22 | 
 23 | 	@XmlAttribute(name = "id", required = true)
 24 | 	private String id;
 25 | 
 26 | 	@XmlAttribute(name = "type", required = true)
 27 | 	private String type;
 28 | 
 29 | 	//该属性为字节长度
 30 | 	@XmlAttribute(name = "length")
 31 | 	private int length = 0;
 32 | 
 33 | 	// 字符值的value
 34 | 	private String value;
 35 | 
 36 | 	// 字节数组值的value
 37 | 	private byte[] byteValue;
 38 | 
 39 | 	// 域类型
 40 | 	private IsoType isoType;
 41 | 
 42 | 	// 该域是否被使用
 43 | 	private boolean checked = false;
 44 | 
 45 | 	public int getLength() {
 46 | 		return length;
 47 | 	}
 48 | 
 49 | 	public void setLength(int length) {
 50 | 		this.length = length;
 51 | 	}
 52 | 
 53 | 	public String getId() {
 54 | 		return id;
 55 | 	}
 56 | 
 57 | 	public void setId(String id) {
 58 | 		this.id = id;
 59 | 	}
 60 | 
 61 | 	public String getType() {
 62 | 		return type;
 63 | 	}
 64 | 
 65 | 	public void setType(String type) {
 66 | 		this.type = type;
 67 | 	}
 68 | 
 69 | 	// 获取本域的IsoType
 70 | 	public IsoType getIsoType() {
 71 | 		if (this.isoType == null) {
 72 | 			this.isoType = IsoType.valueOf(this.type);
 73 | 		}
 74 | 		return isoType;
 75 | 	}
 76 | 
 77 | 	public String getValue() {
 78 | 		return value;
 79 | 	}
 80 | 
 81 | 	public boolean isChecked() {
 82 | 		return checked;
 83 | 	}
 84 | 
 85 | 	public byte[] getByteValue() {
 86 | 		return byteValue;
 87 | 	}
 88 | 
 89 | 	public void setByteValue(byte[] bts) throws UnsupportedEncodingException {
 90 | 		this.byteValue = bts;
 91 | 		this.checked = true;
 92 | 		switch (this.getIsoType()) {
 93 | 		case BINARY:
 94 | 			this.value = EncodeUtil.binary(bts);
 95 | 			break;
 96 | 		case NUMERIC:
 97 | 		case LLVAR_NUMERIC:
 98 | 			this.value = EncodeUtil.hex(bts);
 99 | 			break;
100 | 		case CHAR:
101 | 		case LLVAR:
102 | 		case LLLVAR:
103 | 			this.value = new String(bts, SimpleConstants.ENCODING);
104 | 			break;
105 | 		default:
106 | 			this.checked = false;// 无效设置
107 | 			break;
108 | 		}
109 | 	}
110 | 
111 | 	public void setValue(String value) throws UnsupportedEncodingException {
112 | 		// 应用数据域被选中
113 | 		this.checked = true;
114 | 		this.value = value;
115 | 		// 格式化
116 | 		format(this.value, this.length);
117 | 		if (this.value != null) {
118 | 			switch (this.getIsoType()) {
119 | 			case BINARY:
120 | 				this.byteValue = EncodeUtil.binary(this.value);
121 | 				break;
122 | 			case NUMERIC:
123 | 			case LLVAR_NUMERIC:
124 | 				this.byteValue = EncodeUtil.bcd(this.value);
125 | 				break;
126 | 			case CHAR:
127 | 			case LLVAR:
128 | 			case LLLVAR:
129 | 				this.byteValue = this.value.getBytes(SimpleConstants.ENCODING);
130 | 				break;
131 | 			default:
132 | 				this.checked = false;
133 | 				break;
134 | 			}
135 | 		}
136 | 	}
137 | 
138 | 	public void format(String value, int length)
139 | 			throws UnsupportedEncodingException {
140 | 		if (this.isoType == null) {
141 | 			this.isoType = IsoType.valueOf(this.type);
142 | 		}
143 | 		switch (this.isoType) {
144 | 		case CHAR: {
145 | 			if (value.length() > length) {
146 | 				this.value = this.value.substring(0, length);
147 | 			} else if (value.length() < length) {
148 | 				//将缺少的部分补全空格
149 | 				this.value = EncodeUtil.addBlankRight(this.value, this.length
150 | 						- value.getBytes(SimpleConstants.ENCODING).length, " ");
151 | 			}
152 | 			break;
153 | 		}
154 | 		// LLVAR和LLLVAR类型的数据不格式化
155 | 		case LLVAR:
156 | 		case LLLVAR:
157 | 			break;
158 | 		case LLVAR_NUMERIC:
159 | 			if (this.value.length() % 2 == 1) {
160 | 				this.value = EncodeUtil.addBlankLeft(this.value, 1, "0");
161 | 			}
162 | 			break;
163 | 		case NUMERIC: {
164 | 			if (this.value.length() > length * 2) {
165 | 				throw new IllegalArgumentException("数据域 " + this.id
166 | 						+ "长度超出，值为:" + this.value + "，约定长度" + length);
167 | 			} else {
168 | 				this.value = EncodeUtil.addBlankLeft(this.value, length * 2
169 | 						- this.value.length(), "0");
170 | 			}
171 | 			break;
172 | 		}
173 | 		case BINARY: {
174 | 			int len = this.value.length();
175 | 			if (len < 8 * this.length) {
176 | 				this.value = EncodeUtil.addBlankLeft(this.value, 8 * length
177 | 						- len, "0");
178 | 			} else if (len > 8 * this.length) {
179 | 				this.value = this.value.substring(0, this.length * 8);
180 | 			}
181 | 			break;
182 | 		}
183 | 		default:
184 | 			throw new IllegalArgumentException("不支持的参数类型：" + this.isoType);
185 | 		}
186 | 	}
187 | 
188 | 	@Override
189 | 	public String toString() {
190 | 		StringBuilder accum = new StringBuilder();
191 | 		accum.append("id=").append(this.id ).append( ",type=" ).append( this.type ).append( ",value="
192 | 				).append( this.value);
193 | 		return accum.toString();
194 | 	}
195 | 
196 | 	//该域是否为1~64/1~128的数据域
197 | 	public boolean isAppData() {
198 | 		return SimpleUtil.isNumeric(this.id);
199 | 	}
200 | 
201 | }
202 | 


--------------------------------------------------------------------------------
/com/simple8583/model/IsoHeaderList.java:
--------------------------------------------------------------------------------
 1 | package com.simple8583.model;
 2 | 
 3 | import java.util.ArrayList;
 4 | import java.util.List;
 5 | 
 6 | import javax.xml.bind.annotation.XmlAccessType;
 7 | import javax.xml.bind.annotation.XmlAccessorType;
 8 | import javax.xml.bind.annotation.XmlElement;
 9 | import javax.xml.bind.annotation.XmlElementWrapper;
10 | import javax.xml.bind.annotation.XmlRootElement;
11 | 
12 | /**
13 |  * <p>报文域详情.</p>
14 |  *
15 |  * @author Magic Joey
16 |  * @version IsoContainer.java 1.0 Created@2014-06-06 13:57 $
17 |  */
18 | @XmlAccessorType(XmlAccessType.FIELD)
19 | @XmlRootElement(name="simple8583-config")
20 | public class IsoHeaderList  extends ArrayList<IsoField> implements Cloneable {
21 | 
22 | 	private static final long serialVersionUID = 264233287032969509L;
23 | 
24 | 	@XmlElementWrapper(name="header")
25 |     @XmlElement(name="field")
26 |     public List<IsoField> getHeaderList(){
27 |         return this;
28 |     }
29 | }
30 | 
31 | 
32 | 


--------------------------------------------------------------------------------
/com/simple8583/model/IsoPackage.java:
--------------------------------------------------------------------------------
  1 | package com.simple8583.model;
  2 | 
  3 | import com.simple8583.util.SimpleUtil;
  4 | 
  5 | import javax.xml.bind.annotation.XmlAccessType;
  6 | import javax.xml.bind.annotation.XmlAccessorType;
  7 | import javax.xml.bind.annotation.XmlAttribute;
  8 | import javax.xml.bind.annotation.XmlElement;
  9 | import java.io.*;
 10 | import java.util.LinkedList;
 11 | import java.util.List;
 12 | 
 13 | /**
 14 |  * <p>8583报文包.</p>
 15 |  *
 16 |  * @author Magic Joey
 17 |  * @version Simple8583Test.java 1.0 @2014-07-10 10:43 $
 18 |  */
 19 |  @XmlAccessorType(XmlAccessType.FIELD)
 20 |  public class IsoPackage extends LinkedList<IsoField> implements Cloneable{
 21 | 
 22 | 	private static final long serialVersionUID = 2715585287358366066L;
 23 | 	
 24 | 	@XmlAttribute(name="mti")
 25 |     private String mti;
 26 | 	
 27 |     @XmlElement(name="field")
 28 |     public List<IsoField> getFields(){
 29 |         return this;
 30 |     }
 31 | 
 32 |     //默认64位
 33 |     private boolean bit64 = true;
 34 | 
 35 |     /**
 36 |      * 根据key获取报文域
 37 |      * @param key
 38 |      * @return
 39 |      */
 40 |     public IsoField getIsoField(String key){
 41 |     	for(IsoField isoField:this){
 42 |     		if(isoField.getId().equalsIgnoreCase(key)){
 43 |     			return isoField;
 44 |     		}
 45 |     	}
 46 |     	return null;
 47 |     }
 48 | 
 49 |     /**
 50 |      * 是否为Mac位
 51 |      * @param key
 52 |      * @return
 53 |      */
 54 |     public boolean isMacPos(String key){
 55 |         return (this.isBit64()&&"64".equals(key))
 56 |                 ||(!this.isBit64()&&"128".equals(key));
 57 |     }
 58 | 
 59 |     /**
 60 |      * 深度拷贝方法
 61 |      * @return
 62 |      * @throws java.io.IOException
 63 |      * @throws ClassNotFoundException
 64 |      */
 65 |     public IsoPackage deepClone() throws IOException, ClassNotFoundException {
 66 |         ByteArrayOutputStream byteOut = null;
 67 |         ObjectOutputStream out = null;
 68 |         ByteArrayInputStream byteIn = null;
 69 |         ObjectInputStream in = null;
 70 |         IsoPackage isoPackage;
 71 |         try{
 72 |             byteOut = new ByteArrayOutputStream();
 73 |             out =  new ObjectOutputStream(byteOut);
 74 |             out.writeObject(this);
 75 | 
 76 |             byteIn = new ByteArrayInputStream(byteOut.toByteArray());
 77 |             in  =new ObjectInputStream(byteIn);
 78 |             isoPackage =  (IsoPackage)in.readObject();
 79 |         }finally{
 80 |             if(byteOut!=null){
 81 |                 byteOut.close();
 82 |             }
 83 |             if(out!=null){
 84 |                 out.close();
 85 |             }
 86 |             if(byteIn!=null){
 87 |                 byteIn.close();
 88 |             }
 89 |             if(in!=null){
 90 |                 in.close();
 91 |             }
 92 |         }
 93 |         return isoPackage;
 94 |     }
 95 | 
 96 |     public String getMti() {
 97 |         return mti;
 98 |     }
 99 | 
100 |     public void setMti(String mti) {
101 |         this.mti = mti;
102 |     }
103 | 
104 |     public boolean isBit64() {
105 |         return bit64;
106 |     }
107 | 
108 |     public void setBit64(boolean bit64) {
109 |         this.bit64 = bit64;
110 |     }
111 | 
112 |     @Override
113 |     public String toString(){
114 |     	StringBuffer accum = new StringBuffer("[");
115 |     	for(IsoField isoField:this){
116 |     		accum.append(isoField.getId()).append(":").append(isoField.getValue()).append(",");
117 |     	}
118 |     	accum.append("]");
119 |     	return accum.toString();
120 |     }
121 |     
122 |  }
123 | 
124 | 


--------------------------------------------------------------------------------
/com/simple8583/model/IsoType.java:
--------------------------------------------------------------------------------
 1 | package com.simple8583.model;
 2 | 
 3 | /**
 4 |  * <p>报文域类型,该类待修改，以使本框架更通用.</p>
 5 |  *  TODO
 6 |  * @author Magic Joey
 7 |  * @version Simple8583Test.java 1.0 @2014-07-10 13:59 $
 8 |  */
 9 | public enum IsoType {
10 | 
11 |     //定义了8583协议中的几种数据格式，注：时间类型以及金额都当做NUMERIC类型处理
12 |     //acs编码字符串为CHAR,
13 | 	//二进制类型为BINARY
14 | 	//,数字及bcd编码的格式为NUMERIC,
15 | 	//LLVAR为前置1字节长度字段,
16 | 	//LLLVAR为前置两字节长度字段
17 | 	//LLVAR_NUMERIC：一字节变长的数字类型(BCD编码)
18 |     BINARY,CHAR,NUMERIC,LLVAR,LLLVAR,LLVAR_NUMERIC;
19 | 
20 | }
21 | 
22 | 
23 | 
24 | 
25 | 


--------------------------------------------------------------------------------
/com/simple8583/server/AbstractServer.java:
--------------------------------------------------------------------------------
 1 | package com.simple8583.server;
 2 | 
 3 | import com.simple8583.exception.Simple8583Exception;
 4 | import com.simple8583.factory.IsoMsgFactory;
 5 | import com.simple8583.factory.XmlReader;
 6 | import com.simple8583.key.SimpleConstants;
 7 | import com.simple8583.model.IsoPackage;
 8 | import com.simple8583.util.EncodeUtil;
 9 | import java.io.InputStream;
10 | import java.io.OutputStream;
11 | import java.net.ServerSocket;
12 | import java.net.Socket;
13 | import java.util.Map;
14 | 
15 | /**
16 |  * <p>Server端抽象类.</p>
17 |  *
18 |  * @author Magic Joey
19 |  * @version AbstractServer.java 1.0 Created@2015-06-16 13:52 $
20 |  */
21 | public abstract class AbstractServer {
22 | 
23 |     private int port = 8999;
24 | 
25 |     public void init(final XmlReader xmlReader) throws Exception {
26 |         ServerSocket serverSocket = null;
27 |         Socket socket = null;
28 |         InputStream inputStream = null;
29 |         OutputStream outputStream = null;
30 |         serverSocket = new ServerSocket(port);
31 |         System.out.println("服务器已启动,监听端口:" + port);
32 | 
33 |         IsoMsgFactory factory = IsoMsgFactory.getInstance();
34 |         while (true) {
35 |             try {
36 |                 socket = serverSocket.accept();
37 |                 inputStream = socket.getInputStream();
38 |                 outputStream = socket.getOutputStream();
39 | 
40 |                 //存储长度字节
41 |                 byte[] lengthBytes = new byte[2];
42 |                 //读取输入
43 |                 if(inputStream.read(lengthBytes)==2){
44 |                     int length = msgLength(lengthBytes);
45 |                     byte[] byteBody = new byte[length];
46 |                     inputStream.read(byteBody);
47 |                     IsoPackage isoPackage = xmlReader.getIsoConfig().get(getMti(byteBody));
48 |                     Map<String,String> receiveMap = factory.unpack(byteBody,isoPackage);
49 |                     Map<String,String> responseMap = response(receiveMap);
50 |                     String responseMti = responseMap.get(SimpleConstants.MTI);
51 |                     IsoPackage responsePackage = xmlReader.getIsoConfig().get(responseMti);
52 |                     if(responsePackage==null){
53 |                         throw new Simple8583Exception("获取响应报文格式失败:"+responseMti+",报文内容:"+ EncodeUtil.hex(byteBody));
54 |                     }
55 |                     byte[] responseBytes = factory.pack(responseMap,responsePackage);
56 |                     System.out.println("响应报文:"+EncodeUtil.hex(responseBytes));
57 |                     //返回信息
58 |                     outputStream.write(responseBytes);
59 |                 }else{
60 |                     System.out.println("读取字节长度失败");
61 |                 }
62 |             }finally {
63 |                 if(socket!=null){
64 |                     socket.close();
65 |                 }
66 |                 if(inputStream!=null){
67 |                     inputStream.close();
68 |                 }
69 |                 if(outputStream!=null){
70 |                     outputStream.close();
71 |                 }
72 |             }
73 | 
74 |         }
75 |     }
76 | 
77 |     //响应用户请求
78 |     protected abstract Map<String,String> response(Map<String, String> receiveMap);
79 | 
80 |     private String getMti(byte[] byteBody){
81 |         return "0200";
82 |     }
83 | 
84 |     protected int msgLength(byte[] lenBts){
85 |         return  (lenBts[0] & 0xff) * 256
86 |                 + (lenBts[1] & 0xff);
87 |     }
88 | 
89 |     public int getPort() {
90 |         return port;
91 |     }
92 | 
93 |     public void setPort(int port) {
94 |         this.port = port;
95 |     }
96 | }
97 | 


--------------------------------------------------------------------------------
/com/simple8583/server/DefaultServer.java:
--------------------------------------------------------------------------------
 1 | package com.simple8583.server;
 2 | 
 3 | import com.simple8583.key.SimpleConstants;
 4 | 
 5 | import java.util.HashMap;
 6 | import java.util.Map;
 7 | 
 8 | /**
 9 |  * <p>默认服务类.</p>
10 |  *
11 |  * @author Magic Joey
12 |  * @version DefaultServer.java 1.0 Created@2015-06-16 17:14 $
13 |  */
14 | public class DefaultServer extends AbstractServer{
15 | 
16 | 
17 |     //此处实际可以用Decorate针对不同类型的MTI进行处理
18 |     @Override
19 |     protected Map<String, String> response(Map<String, String> receiveMap) {
20 |         Map<String,String> responseMap = new HashMap<String,String>(30);
21 |         responseMap.put(SimpleConstants.MTI,"0430");
22 |         responseMap.put("2","470000");
23 |         responseMap.put("3","12M01041");
24 |         responseMap.put("4","01041          ");
25 |         responseMap.put("5","04");
26 |         responseMap.put("6","6228210250013865710");
27 |         responseMap.put("7","000000492500");
28 |         responseMap.put("8","SP99515061500104387 ");
29 |         responseMap.put("9","000653");
30 |         responseMap.put("10","20150615");
31 |         responseMap.put("11","20150615");
32 |         responseMap.put("12","01030000041");
33 |         responseMap.put("13","04061415000000048098");
34 |         responseMap.put("14","156");
35 |         responseMap.put("15","00");
36 |         responseMap.put("16","01030000041              ");
37 |         return responseMap;
38 |     }
39 | 
40 | 
41 | 
42 | }
43 | 


--------------------------------------------------------------------------------
/com/simple8583/type/BINARY.java:
--------------------------------------------------------------------------------
 1 | package com.simple8583.type;
 2 | 
 3 | /**
 4 |  * <p>字节.</p>
 5 |  *
 6 |  * @author Magic Joey
 7 |  * @version BINARY.java 1.0 Created@2015-06-15 23:05 $
 8 |  */
 9 | public class BINARY implements IsoType {
10 | 
11 |     @Override
12 |     public boolean isLVar() {
13 |         return false;
14 |     }
15 | 
16 |     @Override
17 |     public String setByteValue(byte[] bts) {
18 |         return null;
19 |     }
20 | 
21 |     @Override
22 |     public byte[] setValue(String bts) {
23 |         return new byte[0];
24 |     }
25 | 
26 |     @Override
27 |     public int varLength(byte[] bytes) {
28 |         return 0;
29 |     }
30 | 
31 | }
32 | 


--------------------------------------------------------------------------------
/com/simple8583/type/CHAR.java:
--------------------------------------------------------------------------------
 1 | package com.simple8583.type;
 2 | 
 3 | /**
 4 |  * <p>.</p>
 5 |  *
 6 |  * @author Magic Joey
 7 |  * @version CHAR.java 1.0 Created@2015-06-15 23:03 $
 8 |  */
 9 | public class CHAR implements IsoType {
10 | 
11 |     @Override
12 |     public boolean isLVar() {
13 |         return false;
14 |     }
15 | 
16 |     @Override
17 |     public String setByteValue(byte[] bts) {
18 |         return null;
19 |     }
20 | 
21 |     @Override
22 |     public byte[] setValue(String bts) {
23 |         return new byte[0];
24 |     }
25 | 
26 |     @Override
27 |     public int varLength(byte[] bytes) {
28 |         return 0;
29 |     }
30 | 
31 | }
32 | 


--------------------------------------------------------------------------------
/com/simple8583/type/IsoType.java:
--------------------------------------------------------------------------------
 1 | package com.simple8583.type;
 2 | 
 3 | import java.io.Serializable;
 4 | 
 5 | /**
 6 |  * <p>报文域类型接口定义.</p>
 7 |  * <p>继承Serializable接口，实例需要被序列化</p>
 8 |  *
 9 |  * @author Magic Joey
10 |  * @version IsoType.java 1.0 Created@2015-06-15 22:42 $
11 |  */
12 | public interface IsoType extends Serializable{
13 | 
14 |     /**
15 |      * 是否为变长域
16 |      * @return
17 |      */
18 |     public boolean isLVar();
19 | 
20 |     /**
21 |      * 字节数组转换为字符串储存
22 |      * @param bts
23 |      * @return
24 |      */
25 |     public abstract String setByteValue(byte[] bts);
26 | 
27 |     /**
28 |      * 字符串转换为字节数组
29 |      * @param bts
30 |      * @return
31 |      */
32 |     public abstract byte[] setValue(String bts);
33 | 
34 | 
35 |     /**
36 |      * 变长长度
37 |      * @return
38 |      */
39 |     public abstract int varLength(byte[] bytes);
40 | 
41 | 
42 | }
43 | 


--------------------------------------------------------------------------------
/com/simple8583/type/LLLVAR.java:
--------------------------------------------------------------------------------
 1 | package com.simple8583.type;
 2 | 
 3 | /**
 4 |  * <p>.</p>
 5 |  *
 6 |  * @author Magic Joey
 7 |  * @version LLLVAR.java 1.0 Created@2015-06-15 23:05 $
 8 |  */
 9 | public class LLLVAR implements IsoType {
10 | 
11 |     @Override
12 |     public boolean isLVar() {
13 |         return false;
14 |     }
15 | 
16 |     @Override
17 |     public String setByteValue(byte[] bts) {
18 |         return null;
19 |     }
20 | 
21 |     @Override
22 |     public byte[] setValue(String bts) {
23 |         return new byte[0];
24 |     }
25 | 
26 |     @Override
27 |     public int varLength(byte[] bytes) {
28 |         return 0;
29 |     }
30 | 
31 | }
32 | 


--------------------------------------------------------------------------------
/com/simple8583/type/LLVAR.java:
--------------------------------------------------------------------------------
 1 | package com.simple8583.type;
 2 | 
 3 | /**
 4 |  * <p>.</p>
 5 |  *
 6 |  * @author Magic Joey
 7 |  * @version LLVAR.java 1.0 Created@2015-06-15 23:04 $
 8 |  */
 9 | public class LLVAR implements IsoType {
10 | 
11 |     @Override
12 |     public boolean isLVar() {
13 |         return false;
14 |     }
15 | 
16 |     @Override
17 |     public String setByteValue(byte[] bts) {
18 |         return null;
19 |     }
20 | 
21 |     @Override
22 |     public byte[] setValue(String bts) {
23 |         return new byte[0];
24 |     }
25 | 
26 |     @Override
27 |     public int varLength(byte[] bytes) {
28 |         return 0;
29 |     }
30 | 
31 | }
32 | 


--------------------------------------------------------------------------------
/com/simple8583/util/EncodeUtil.java:
--------------------------------------------------------------------------------
  1 | package com.simple8583.util;
  2 | 
  3 | /**
  4 |  * <p>编码转换工具类.如:BCD和HEX</p>
  5 |  *
  6 |  * @author Magic Joey
  7 |  * @version EncodeUtil.java 1.0 @2014-07-10 09:51 $
  8 |  */
  9 | public class EncodeUtil {
 10 | 
 11 |     protected static final char[] HEX = new char[]{'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
 12 | 
 13 |     protected static final char[] BINARY = new char[]{'0','1'};
 14 | 
 15 |     private EncodeUtil(){
 16 | 
 17 |     }
 18 | 
 19 |     //传入参数为只有01的字符串
 20 |     public static byte[] binary(String binaryStr){
 21 |         //长度不是8倍数的话，无法知道在左边或右边补零，会引起歧义，导致结果不正确
 22 |         if(binaryStr.length()%8!=0){
 23 |             throw new IllegalArgumentException("传入的参数长度必须是8的倍数");
 24 |         }
 25 |         StringBuffer accum = new StringBuffer();
 26 |         for(int i=0;i<binaryStr.length();i+=4){
 27 |             String temp = binaryStr.substring(i,i+4);
 28 |             int value=0;
 29 |             for(int j=0;j<4;j++){
 30 |                 if(temp.charAt(j)=='1'){
 31 |                     value+=Math.pow(2, 3 - j);//计算值
 32 |                 }
 33 |             }
 34 |             accum.append(HEX[value]);
 35 |         }
 36 |         return bcd(accum.toString());
 37 |     }
 38 | 
 39 |     public static String hex(byte[] bts,int offset,int length){//
 40 |         if(offset<0||length<0||bts.length<offset+length-1){
 41 |             throw new IllegalArgumentException("参数非法：offset:"+offset+",length:"+length+",字节长度："+bts.length);
 42 |         }
 43 |         byte[] returnBt = new byte[length];
 44 |         System.arraycopy(returnBt,0,bts,offset,length);
 45 |         return hex(returnBt);
 46 |     }
 47 | 
 48 | 
 49 |     /**
 50 |      * 将byte数组转化为String类型的十六进制编码格式
 51 |      * 本方法实现的思路是：
 52 |      * 1）每位byte数组转换为2位的十六进制数
 53 |      * 2）将字节左移4位取得高四位字节数值，获取对应的char类型数组编码
 54 |      * 3）将字节与0x0F按位与，从而获取第四位的字节，同样获取编码
 55 |      */
 56 |     public static String hex(byte[] bParam){
 57 |         StringBuilder accum = new StringBuilder();
 58 |         for(byte bt:bParam){
 59 |              accum.append(HEX[bt>>4&0x0F]);//&0x0F的目的是为了转换负数
 60 |              accum.append(HEX[bt&0x0F]);
 61 |         }
 62 |         return accum.toString();
 63 |     }
 64 | 
 65 |     public static byte[] bcd(int code,int len){
 66 |         return EncodeUtil.bcd(String.valueOf(code),len);
 67 |     }
 68 | 
 69 |     
 70 |     public static String binary(byte[] bts){
 71 |     	StringBuffer accum = new StringBuffer();
 72 |     	for(byte bt:bts){
 73 |     		accum.append(binary(bt));
 74 |     	}
 75 |     	return accum.toString();
 76 |     }
 77 |     
 78 |     //本方法修改于Integer.toBinaryString
 79 |     //参数的每个字节都会转化为8位2进制字符串，如1会转换为00000001
 80 |     private static String binary(byte bt){
 81 |     	int num = bt&0xFF;
 82 |     	char[] arrayOfChar = new char[8];
 83 | 		int i = 8;
 84 | 		for(int times=0;times<8;times++){
 85 | 			arrayOfChar[(--i)] = BINARY[(num & 0x01)];
 86 | 			num >>>= 1;
 87 | 		}
 88 | 		return new String(arrayOfChar);
 89 |     }
 90 | 
 91 |     /**BCD编码(8421码)为一个4位表示一个10进制数，即每个字节表示两个数
 92 |     *本方法中的code为10进制数（本方法支持16进制数编码，每两位编为1字节）
 93 |     */
 94 |     public static byte[] bcd(String code){
 95 |         //控制byte数组的大小
 96 |         int len = code.length()%2==0?code.length()/2:code.length()/2+1;
 97 |         return bcd(code,len);
 98 |     }
 99 |     
100 | 
101 |     /**
102 |      * @param code
103 |      * @param length
104 |      * @return
105 |      */
106 |     public static byte[] bcd(String code,int length){
107 |         if(length<0){
108 |             throw new IllegalArgumentException("参数length不能小于0,length:"+length);
109 |         }else if(length==0){
110 |             return new byte[0];
111 |         }
112 |         byte[] bt = new byte[length];
113 |         //指示当前位置
114 |         int point = 0;
115 |         if(code.length()<2*length){
116 |         	code = addBlankLeft(code,2*length-code.length(),"0");
117 |         }
118 |         
119 |         //每两位合并为一个字节
120 |         for(;point<code.length();point+=2){
121 |             //(point+1)/2计算当前指向的值
122 |             //Character.digit将对应的Char转为数字，如'8'-> 8
123 |             //<<4左移四位：即为→_→（右边）的数字让开位置
124 |             bt[(point+1)/2] = (byte)(Character.digit(code.charAt(point),16)<<4|Character.digit(code.charAt(point+1),16));
125 |         }
126 |         return bt;
127 |     }
128 |     
129 |     public static String addBlankLeft(String origStr,int length,String fill){
130 |     	if(length<=0){
131 |     		return origStr;
132 |     	}
133 |     	StringBuffer accum = new StringBuffer(); 	
134 |     	for(int i=0;i<length;i++){
135 |     	 		accum.append(fill);
136 |     	 	}
137 |     	accum.append(origStr);
138 |     	return accum.toString();
139 |     }
140 |     
141 |     public static String addBlankRight(String origStr,int length,String fill){
142 |     	if(length<=0){
143 |     		return origStr;
144 |     	}
145 |     	StringBuffer accum = new StringBuffer(origStr); 	
146 |     	for(int i=0;i<length;i++){
147 |     	 		accum.append(fill);
148 |     	 	}
149 |     	return accum.toString();
150 |     }
151 | }
152 | 


--------------------------------------------------------------------------------
/com/simple8583/util/SimpleUtil.java:
--------------------------------------------------------------------------------
 1 | package com.simple8583.util;
 2 | 
 3 | import java.text.SimpleDateFormat;
 4 | import java.util.Date;
 5 | import java.util.regex.Matcher;
 6 | import java.util.regex.Pattern;
 7 | 
 8 | /**
 9 |  * <p>编码转换工具类.如:BCD和HEX</p>
10 |  *
11 |  * @author Magic Joey
12 |  * @version EncodeUtil.java 1.0 @2014-07-10 09:51 $
13 |  */
14 | public class SimpleUtil {
15 | 
16 |     //不允许实例化
17 |     private SimpleUtil(){
18 | 
19 |     }
20 | 	
21 | 	//判断字符串是否都是由数字组成
22 | 	public static boolean isNumeric(String str){
23 | 		if(str==null){
24 | 			return false;
25 | 		}
26 | 	   Pattern pattern = Pattern.compile("[0-9]*"); 
27 | 	   Matcher isNum = pattern.matcher(str);
28 | 	   if( !isNum.matches() ){
29 | 	       return false; 
30 | 	   } 
31 | 	   return true; 
32 | 	}
33 | 	
34 | 	//用于处理tlv格式的数据,返回tag+length+flag格式
35 | 	public static String tlv(String tag,String flag){
36 | 		StringBuffer accum = new StringBuffer(tag);
37 | 		//将flag长度偶数化
38 | 		accum.append(evenLength(flag));
39 | 		accum.append(flag);
40 | 		return accum.toString();
41 | 	}
42 | 	
43 | 	public static String evenLength(String value){
44 | 		if(String.valueOf(value.length()).length()%2==1){
45 | 			return "0"+value.length();			
46 | 		}else{
47 | 			return String.valueOf(value.length());
48 | 		}
49 | 	}
50 | 	
51 | 	public static String date(){
52 | 		SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd");
53 | 		return format.format(new Date());
54 | 	}
55 | 	
56 | 	public static String time(){
57 | 		SimpleDateFormat format = new SimpleDateFormat("HHmmss");
58 | 		return format.format(new Date());
59 | 	}
60 | 
61 | }


--------------------------------------------------------------------------------
/com/simple8583/util/TraceGenerator.java:
--------------------------------------------------------------------------------
 1 | package com.simple8583.util;
 2 | 
 3 | /**
 4 |  * <p>本类用于标识终端交易流水号，每次会生成一个1~999999之间的字符串</p>
 5 |  * <p>使用方法TraceGenerator.getInstance().nextTrace();</p>
 6 |  *
 7 |  * @author Magic Joey
 8 |  * @version TraceGenerator.java 1.0 @2014-06-09 17:57$
 9 |  */
10 | public class TraceGenerator {
11 | 
12 |     private static  TraceGenerator tg;
13 |     private int traceValue;
14 |     //random为false，生成值每次+1，为true，生成值为随机
15 |     private boolean random=true;
16 |     
17 |     private TraceGenerator(int initValue){
18 |         this.traceValue = initValue;
19 |     }
20 | 
21 |     public static TraceGenerator getInstance(){
22 |         //双检查锁
23 |         if(tg==null){
24 |             synchronized (TraceGenerator.class){
25 |                 if(tg==null){
26 |                     tg = new TraceGenerator(1);
27 |                 }
28 |             }
29 |         }
30 |         return tg;
31 |     }
32 | 
33 |     public String nextTrace(){
34 |     	if(!random){
35 |         if(traceValue>=999999){
36 |             traceValue=1;
37 |         }
38 |         return String.valueOf(traceValue++);
39 |     	}else{
40 |     		return String.valueOf((int)(Math.random()*1000000));
41 |     	}
42 |     }
43 | 
44 | 
45 | }
46 | 


--------------------------------------------------------------------------------
/com/simple8583/util/encrypt/DES.java:
--------------------------------------------------------------------------------
   1 | package com.simple8583.util.encrypt;
   2 | 
   3 | import java.io.UnsupportedEncodingException;
   4 | 
   5 | /**
   6 |  * <p>DES加密类</p>
   7 |  *
   8 |  * @author Magic Joey
   9 |  * @version DES.java 1.0 @2014-06-09 17:57$
  10 |  */
  11 | public class DES {
  12 | 	/***************************** 压缩替换S-Box�? **************************************************/
  13 | 	protected static  final int[][] s1 = {
  14 | 			{ 14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7 },
  15 | 			{ 0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8 },
  16 | 			{ 4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0 },
  17 | 			{ 15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13 } };
  18 | 
  19 | 	protected static  final int[][] s2 = {
  20 | 			{ 15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10 },
  21 | 			{ 3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5 },
  22 | 			{ 0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15 },
  23 | 			{ 13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9 } };
  24 | 
  25 | 	protected static  final int[][] s3 = {
  26 | 			{ 10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8 },
  27 | 			{ 13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1 },
  28 | 			{ 13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7 },
  29 | 			{ 1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12 } };
  30 | 
  31 | 	protected static  final int[][] s4 = {
  32 | 			{ 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15 },
  33 | 			{ 13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9 },// erorr
  34 | 			{ 10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4 },
  35 | 			{ 3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14 } };
  36 | 
  37 | 	protected static  final int[][] s5 = {
  38 | 			{ 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9 },
  39 | 			{ 14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6 },
  40 | 			{ 4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14 },
  41 | 			{ 11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3 } };
  42 | 
  43 | 	protected static  final int[][] s6 = {
  44 | 			{ 12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11 },
  45 | 			{ 10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8 },
  46 | 			{ 9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6 },
  47 | 			{ 4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13 } };
  48 | 
  49 | 	protected static  final int[][] s7 = {
  50 | 			{ 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1 },
  51 | 			{ 13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6 },
  52 | 			{ 1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2 },
  53 | 			{ 6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12 } };
  54 | 
  55 | 	protected static  final int[][] s8 = {
  56 | 			{ 13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7 },
  57 | 			{ 1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2 },
  58 | 			{ 7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8 },
  59 | 			{ 2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11 } };
  60 | 
  61 | 	protected static  final int[] ip = { 58, 50, 42, 34, 26, 18, 10, 2,
  62 | 	60, 52, 44, 36, 28, 20, 12, 4,
  63 | 	62, 54, 46, 38, 30, 22, 14, 6,
  64 | 	64, 56, 48, 40, 32, 24, 16, 8,
  65 | 	57, 49, 41, 33, 25, 17, 9, 1,
  66 | 	59, 51, 43, 35, 27, 19, 11, 3,
  67 | 	61, 53, 45, 37, 29, 21, 13, 5,
  68 | 	63, 55, 47, 39, 31, 23, 15, 7 };
  69 | 
  70 | 	protected static  final int[] _ip = { 40, 8, 48, 16, 56, 24, 64, 32,
  71 | 	39, 7, 47, 15, 55, 23, 63, 31,
  72 | 	38, 6, 46, 14, 54, 22, 62, 30,
  73 | 	37, 5, 45, 13, 53, 21, 61, 29,
  74 | 	36, 4, 44, 12, 52, 20, 60, 28,
  75 | 	35, 3, 43, 11, 51, 19, 59, 27,
  76 | 	34, 2, 42, 10, 50, 18, 58, 26,
  77 | 	33, 1, 41, 9, 49, 17, 57, 25 };
  78 | 
  79 | 	// 每次密钥循环左移位数
  80 | 	protected static  final int[] LS = { 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2,
  81 | 			2, 1 };
  82 | 
  83 | 	protected static  int[][] subKey = new int[16][48];
  84 | 
  85 | 	protected static  int HEX = 0;
  86 | 
  87 | 	protected static  int ASC = 1;
  88 | 
  89 | 	/**
  90 | 	 * 
  91 | 	 * 将十六进制A--F转换成对应数�?
  92 | 	 * 
  93 | 	 * @param ch
  94 | 	 * 
  95 | 	 * @return
  96 | 	 * 
  97 | 	 * @throws Exception
  98 | 	 */
  99 | 	protected static  int getIntByChar(char ch) throws Exception {
 100 | 		char t = Character.toUpperCase(ch);
 101 | 		int i = 0;
 102 | 		switch (t) {
 103 | 		case '0':
 104 | 		case '1':
 105 | 		case '2':
 106 | 		case '3':
 107 | 		case '4':
 108 | 		case '5':
 109 | 		case '6':
 110 | 		case '7':
 111 | 		case '8':
 112 | 		case '9':
 113 | 			i = Integer.parseInt(Character.toString(t));
 114 | 			break;
 115 | 		case 'A':
 116 | 			i = 10;
 117 | 			break;
 118 | 		case 'B':
 119 | 			i = 11;
 120 | 			break;
 121 | 		case 'C':
 122 | 			i = 12;
 123 | 			break;
 124 | 		case 'D':
 125 | 			i = 13;
 126 | 			break;
 127 | 		case 'E':
 128 | 			i = 14;
 129 | 			break;
 130 | 		case 'F':
 131 | 			i = 15;
 132 | 			break;
 133 | 		default:
 134 | 			throw new Exception("getIntByChar was wrong");
 135 | 		}
 136 | 		return i;
 137 | 	}
 138 | 
 139 | 	/**
 140 | 	 * 
 141 | 	 * 将字符串转换成二进制数组
 142 | 	 * 
 143 | 	 * @param source
 144 | 	 *            : 16字节
 145 | 	 * 
 146 | 	 * @return
 147 | 	 */
 148 | 
 149 | 	protected static  int[] string2Binary(String source) {
 150 | 		int len = source.length();
 151 | 		int[] dest = new int[len * 4];
 152 | 		char[] arr = source.toCharArray();
 153 | 		for (int i = 0; i < len; i++) {
 154 | 			int t = 0;
 155 | 			try {
 156 | 				t = getIntByChar(arr[i]);
 157 | 				// System.out.println(arr[i]);
 158 | 			} catch (Exception e) {
 159 | 				e.printStackTrace();
 160 | 			}
 161 | 			String[] str = Integer.toBinaryString(t).split("");
 162 | 			int k = i * 4 + 3;
 163 | 			for (int j = str.length - 1; j > 0; j--) {
 164 | 				dest[k] = Integer.parseInt(str[j]);
 165 | 				k--;
 166 | 			}
 167 | 		}
 168 | 		return dest;
 169 | 	}
 170 | 
 171 | 	/**
 172 | 	 * 
 173 | 	 * 返回x的y次方
 174 | 	 * 
 175 | 	 * @param x
 176 | 	 * 
 177 | 	 * @param y
 178 | 	 * 
 179 | 	 * @return
 180 | 	 */
 181 | 
 182 | 	protected static  int getXY(int x, int y) {
 183 | 		int temp = x;
 184 | 		if (y == 0)
 185 | 			x = 1;
 186 | 		for (int i = 2; i <= y; i++) {
 187 | 			x *= temp;
 188 | 		}
 189 | 		return x;
 190 | 	}
 191 | 
 192 | 	/**
 193 | 	 * 
 194 | 	 * s�?位长度的二进制字符串
 195 | 	 * 
 196 | 	 * @param s
 197 | 	 * 
 198 | 	 * @return
 199 | 	 */
 200 | 
 201 | 	protected static  String binary2Hex(String s) {
 202 | 		int len = s.length();
 203 | 		int result = 0;
 204 | 		int k = 0;
 205 | 		if (len > 4)
 206 | 			return null;
 207 | 		for (int i = len; i > 0; i--) {
 208 | 			result += Integer.parseInt(s.substring(i - 1, i)) * getXY(2, k);
 209 | 			k++;
 210 | 		}
 211 | 		switch (result) {
 212 | 		case 0:
 213 | 		case 1:
 214 | 		case 2:
 215 | 		case 3:
 216 | 		case 4:
 217 | 		case 5:
 218 | 		case 6:
 219 | 		case 7:
 220 | 		case 8:
 221 | 		case 9:
 222 | 			return "" + result;
 223 | 		case 10:
 224 | 			return "A";
 225 | 		case 11:
 226 | 			return "B";
 227 | 		case 12:
 228 | 			return "C";
 229 | 		case 13:
 230 | 			return "D";
 231 | 		case 14:
 232 | 			return "E";
 233 | 		case 15:
 234 | 			return "F";
 235 | 		default:
 236 | 			return null;
 237 | 		}
 238 | 	}
 239 | 
 240 | 	/**
 241 | 	 * 
 242 | 	 * 将int转换成Hex
 243 | 	 * 
 244 | 	 * @param i
 245 | 	 * 
 246 | 	 * @return
 247 | 	 * 
 248 | 	 * @throws Exception
 249 | 	 */
 250 | 
 251 | 	protected static  String int2Hex(int i) {
 252 | 		switch (i) {
 253 | 		case 0:
 254 | 		case 1:
 255 | 		case 2:
 256 | 		case 3:
 257 | 		case 4:
 258 | 		case 5:
 259 | 		case 6:
 260 | 		case 7:
 261 | 		case 8:
 262 | 		case 9:
 263 | 			return "" + i;
 264 | 		case 10:
 265 | 			return "A";
 266 | 		case 11:
 267 | 			return "B";
 268 | 		case 12:
 269 | 			return "C";
 270 | 		case 13:
 271 | 			return "D";
 272 | 		case 14:
 273 | 			return "E";
 274 | 		case 15:
 275 | 			return "F";
 276 | 		default:
 277 | 			return null;
 278 | 		}
 279 | 	}
 280 | 
 281 | 	/**
 282 | 	 * 
 283 | 	 * 将二进制字符串转换成十六进制字符�?
 284 | 	 * 
 285 | 	 * @param s
 286 | 	 * 
 287 | 	 * @return
 288 | 	 */
 289 | 
 290 | 	protected static  String binary2ASC(String s) {
 291 | 		String str = "";
 292 | 		int ii = 0;
 293 | 		int len = s.length();
 294 | 		// 不够4bit左补0
 295 | 		if (len % 4 != 0) {
 296 | 			while (ii < 4 - len % 4) {
 297 | 				s = "0" + s;
 298 | 			}
 299 | 		}
 300 | 		for (int i = 0; i < len / 4; i++) {
 301 | 			str += binary2Hex(s.substring(i * 4, i * 4 + 4));
 302 | 		}
 303 | 		return str;
 304 | 	}
 305 | 
 306 | 	/**
 307 | 	 * 
 308 | 	 * IP初始置换
 309 | 	 * 
 310 | 	 * @param source
 311 | 	 * 
 312 | 	 * @return
 313 | 	 */
 314 | 	protected static  int[] changeIP(int[] source) {
 315 | 		int[] dest = new int[64];
 316 | 		for (int i = 0; i < 64; i++) {
 317 | 			dest[i] = source[ip[i] - 1];
 318 | 		}
 319 | 		return dest;
 320 | 	}
 321 | 
 322 | 	/**
 323 | 	 * 
 324 | 	 * IP-1逆置�?
 325 | 	 * 
 326 | 	 * @param source
 327 | 	 * 
 328 | 	 * @return
 329 | 	 */
 330 | 
 331 | 	protected static  int[] changeInverseIP(int[] source) {
 332 | 		int[] dest = new int[64];
 333 | 		for (int i = 0; i < 64; i++) {
 334 | 			dest[i] = source[_ip[i] - 1];
 335 | 		}
 336 | 		return dest;
 337 | 	}
 338 | 
 339 | 	/**
 340 | 	 * 
 341 | 	 * �?2bit扩展�?8bit
 342 | 	 * 
 343 | 	 * @param source
 344 | 	 * 
 345 | 	 * @return
 346 | 	 */
 347 | 
 348 | 	protected static  int[] expend(int[] source) {
 349 | 		int[] ret = new int[48];
 350 | 		int[] temp = { 32, 1, 2, 3, 4, 5,
 351 | 		4, 5, 6, 7, 8, 9,
 352 | 		8, 9, 10, 11, 12, 13,
 353 | 		12, 13, 14, 15, 16, 17,
 354 | 		16, 17, 18, 19, 20, 21,
 355 | 		20, 21, 22, 23, 24, 25,
 356 | 		24, 25, 26, 27, 28, 29,
 357 | 		28, 29, 30, 31, 32, 1 };
 358 | 		for (int i = 0; i < 48; i++) {
 359 | 			ret[i] = source[temp[i] - 1];
 360 | 		}
 361 | 		return ret;
 362 | 	}
 363 | 
 364 | 	/**
 365 | 	 * 
 366 | 	 * �?8bit压缩�?2bit
 367 | 	 * 
 368 | 	 * @param source
 369 | 	 *            (48bit)
 370 | 	 * 
 371 | 	 * @return R(32bit)
 372 | 	 * 
 373 | 	 *         B=E(R)⊕K，将48 位的B 分成8 个分组，B=B1B2B3B4B5B6B7B8
 374 | 	 */
 375 | 
 376 | 	protected static  int[] press(int[] source) {
 377 | 		int[] ret = new int[32];
 378 | 		int[][] temp = new int[8][6];
 379 | 		int[][][] s = { s1, s2, s3, s4, s5, s6, s7, s8 };
 380 | 		StringBuffer str = new StringBuffer();
 381 | 		for (int i = 0; i < 8; i++) {
 382 | 			for (int j = 0; j < 6; j++) {
 383 | 				temp[i][j] = source[i * 6 + j];
 384 | 			}
 385 | 		}
 386 | 		for (int i = 0; i < 8; i++) {
 387 | 			// (16)
 388 | 			int x = temp[i][0] * 2 + temp[i][5];
 389 | 			// (2345)
 390 | 			int y = temp[i][1] * 8 + temp[i][2] * 4 + temp[i][3] * 2
 391 | 					+ temp[i][4];
 392 | 			int val = s[i][x][y];
 393 | 			String ch = int2Hex(val);
 394 | 			// System.out.println("x=" + x + ",y=" + y + "-->" + ch);
 395 | 			// String ch = Integer.toBinaryString(val);
 396 | 			str.append(ch);
 397 | 		}
 398 | 		// System.out.println(str.toString());
 399 | 		ret = string2Binary(str.toString());
 400 | 		// printArr(ret);
 401 | 		// 置换P
 402 | 		ret = dataP(ret);
 403 | 		return ret;
 404 | 	}
 405 | 
 406 | 	/**
 407 | 	 * 
 408 | 	 * 置换P(32bit)
 409 | 	 * 
 410 | 	 * @param source
 411 | 	 * 
 412 | 	 * @return
 413 | 	 */
 414 | 
 415 | 	protected static  int[] dataP(int[] source) {
 416 | 		int[] dest = new int[32];
 417 | 		int[] temp = { 16, 7, 20, 21,
 418 | 		29, 12, 28, 17,
 419 | 		1, 15, 23, 26,
 420 | 		5, 18, 31, 10,
 421 | 		2, 8, 24, 14,
 422 | 		32, 27, 3, 9,
 423 | 		19, 13, 30, 6,
 424 | 		22, 11, 4, 25 };
 425 | 		int len = source.length;
 426 | 		for (int i = 0; i < len; i++) {
 427 | 			dest[i] = source[temp[i] - 1];
 428 | 		}
 429 | 		return dest;
 430 | 	}
 431 | 
 432 | 	/**
 433 | 	 * 
 434 | 	 * @param R
 435 | 	 *            (�?2bit)
 436 | 	 * 
 437 | 	 * @param K
 438 | 	 *            (48bit的轮子密�?
 439 | 	 * 
 440 | 	 * @return 32bit
 441 | 	 */
 442 | 
 443 | 	protected static  int[] f(int[] R, int[] K) {
 444 | 		int[] dest = new int[32];
 445 | 		int[] temp = new int[48];
 446 | 		// 先将输入32bit扩展�?8bit
 447 | 		int[] expendR = expend(R);// 48bit
 448 | 		// 与轮子密钥进行异或运�?
 449 | 		temp = diffOr(expendR, K);
 450 | 		// 压缩�?2bit
 451 | 		dest = press(temp);
 452 | 		// System.out.println("need press data----->");
 453 | 		// printArr(temp);
 454 | 		return dest;
 455 | 	}
 456 | 
 457 | 	/**
 458 | 	 * 
 459 | 	 * 两个等长的数组做异或
 460 | 	 * 
 461 | 	 * @param source1
 462 | 	 * 
 463 | 	 * @param source2
 464 | 	 * 
 465 | 	 * @return
 466 | 	 */
 467 | 
 468 | 	protected static  int[] diffOr(int[] source1, int[] source2) {
 469 | 		int len = source1.length;
 470 | 		int[] dest = new int[len];
 471 | 		for (int i = 0; i < len; i++) {
 472 | 			dest[i] = source1[i] ^ source2[i];
 473 | 		}
 474 | 		return dest;
 475 | 	}
 476 | 
 477 | 	/**
 478 | 	 * 
 479 | 	 * DES加密--->对称密钥
 480 | 	 * 
 481 | 	 * D = Ln(32bit)+Rn(32bit)
 482 | 	 * 
 483 | 	 * 经过16轮置�?
 484 | 	 * 
 485 | 	 * @param D
 486 | 	 *            (16byte)明文
 487 | 	 * 
 488 | 	 * @param K
 489 | 	 *            (16byte)轮子密钥
 490 | 	 * 
 491 | 	 * @return (16byte)密文
 492 | 	 */
 493 | 
 494 | 	protected static  String encryption(String D, String K) {
 495 | 		String str = "";
 496 | 		int[] temp = new int[64];
 497 | 		int[] data = string2Binary(D);
 498 | 		// printArr(data);
 499 | 		// 第一步初始置�?
 500 | 		data = changeIP(data);
 501 | 		// printArr(data);
 502 | 		int[][] left = new int[17][32];
 503 | 		int[][] right = new int[17][32];
 504 | 		for (int j = 0; j < 32; j++) {
 505 | 			left[0][j] = data[j];
 506 | 			right[0][j] = data[j + 32];
 507 | 		}
 508 | 		// printArr(left[0]);
 509 | 		// printArr(right[0]);
 510 | 		setKey(K);// sub key ok
 511 | 		for (int i = 1; i < 17; i++) {
 512 | 			// 获取(48bit)的轮子密�?
 513 | 			int[] key = subKey[i - 1];
 514 | 			// L1 = R0
 515 | 			left[i] = right[i - 1];
 516 | 			// R1 = L0 ^ f(R0,K1)
 517 | 			int[] fTemp = f(right[i - 1], key);// 32bit
 518 | 			right[i] = diffOr(left[i - 1], fTemp);
 519 | 		}
 520 | 		// �?��组合的时候，左右调换**************************************************
 521 | 		for (int i = 0; i < 32; i++) {
 522 | 			temp[i] = right[16][i];
 523 | 			temp[32 + i] = left[16][i];
 524 | 		}
 525 | 		temp = changeInverseIP(temp);
 526 | 		str = binary2ASC(intArr2Str(temp));
 527 | 		return str;
 528 | 	}
 529 | 
 530 | 	/**
 531 | 	 * 
 532 | 	 * DES解密--->对称密钥
 533 | 	 * 
 534 | 	 * 解密算法与加密算法基本相同，不同之处仅在于轮子密钥的使用顺序逆序，即解密的第1
 535 | 	 * 
 536 | 	 * 轮子密钥为加密的�?6 轮子密钥，解密的�? 轮子密钥为加密的�?5 轮子密钥，�?…，
 537 | 	 * 
 538 | 	 * 解密的第16 轮子密钥为加密的�? 轮子密钥�?
 539 | 	 * 
 540 | 	 * @param source密文
 541 | 	 * 
 542 | 	 * @param key密钥
 543 | 	 * 
 544 | 	 * @return
 545 | 	 */
 546 | 
 547 | 	protected static  String discryption(String source, String key) {
 548 | 		String str = "";
 549 | 		int[] data = string2Binary(source);// 64bit
 550 | 		// 第一步初始置�?
 551 | 		data = changeIP(data);
 552 | 		int[] left = new int[32];
 553 | 		int[] right = new int[32];
 554 | 		int[] tmp = new int[32];
 555 | 		for (int j = 0; j < 32; j++) {
 556 | 			left[j] = data[j];
 557 | 			right[j] = data[j + 32];
 558 | 		}
 559 | 		setKey(key);// sub key ok
 560 | 		for (int i = 16; i > 0; i--) {
 561 | 			// 获取(48bit)的轮子密�?
 562 | 			/********* 不同之处 **********/
 563 | 			int[] sKey = subKey[i - 1];
 564 | 			tmp = left;
 565 | 			// R1 = L0
 566 | 			left = right;
 567 | 			// L1 = R0 ^ f(L0,K1)
 568 | 			int[] fTemp = f(right, sKey);// 32bit
 569 | 			right = diffOr(tmp, fTemp);
 570 | 		}
 571 | 		// �?��组合的时候，左右调换**************************************************
 572 | 		for (int i = 0; i < 32; i++) {
 573 | 			data[i] = right[i];
 574 | 			data[32 + i] = left[i];
 575 | 		}
 576 | 		data = changeInverseIP(data);
 577 | 		for (int i = 0; i < data.length; i++) {
 578 | 			str += data[i];
 579 | 		}
 580 | 		str = binary2ASC(str);
 581 | 		return str;
 582 | 	}
 583 | 
 584 | 	/**
 585 | 	 * 
 586 | 	 * 单�?长密钥DES(16byte)
 587 | 	 * 
 588 | 	 * @param source
 589 | 	 * 
 590 | 	 * @param key
 591 | 	 * 
 592 | 	 * @param type
 593 | 	 *            0:encrypt 1:discrypt
 594 | 	 * 
 595 | 	 * @return
 596 | 	 */
 597 | 
 598 | 	protected static  String DES_1(String source, String key, int type) {
 599 | 		if (source.length() != 16 || key.length() != 16)
 600 | 			return null;
 601 | 		if (type == 0) {
 602 | 			return encryption(source, key);
 603 | 		}
 604 | 		if (type == 1) {
 605 | 			return discryption(source, key);
 606 | 		}
 607 | 		return null;
 608 | 	}
 609 | 
 610 | 	/**
 611 | 	 * 
 612 | 	 * 
 613 | 	 * 
 614 | 	 * @param source
 615 | 	 * 
 616 | 	 * @param key
 617 | 	 * 两重des加密
 618 | 	 * 
 619 | 	 * @param type
 620 | 	 *            0:encrypt 1:discrypt
 621 | 	 * 
 622 | 	 * @return
 623 | 	 */
 624 | 
 625 | 	protected static  String DES_2(String source, String key, int type) {
 626 | //		if (key.length() != 32 || source.length() != 16)
 627 | //			return null;
 628 | 		String temp = null;
 629 | 		String K1 = key.substring(0, key.length() / 2);
 630 | 		String K2 = key.substring(key.length() / 2);
 631 | 		System.out.println("K1--->" + K1);
 632 | 		System.out.println("K2--->" + K2);
 633 | 		if (type == 0) {
 634 | 			temp = encryption(source, K1);
 635 | 			System.out.println("step1--->" + temp);
 636 | 			temp = discryption(temp, K2);
 637 | 			System.out.println("step2--->" + temp);
 638 | 			return encryption(temp, K1);
 639 | 		}
 640 | 		if (type == 1) {
 641 | 			temp = discryption(source, K1);
 642 | 			System.out.println("step1--->" + temp);
 643 | 			temp = encryption(temp, K2);
 644 | 			System.out.println("step2--->" + temp);
 645 | 			return discryption(temp, K1);
 646 | 		}
 647 | 		return null;
 648 | 	}
 649 | 
 650 | 	/**
 651 | 	 * 
 652 | 	 * 三重DES算法(双�?长密�?32byte))
 653 | 	 * 
 654 | 	 * 密钥K1和K2
 655 | 	 * 
 656 | 	 * 1、先用K1加密明文
 657 | 	 * 
 658 | 	 * 2、接�?��K2对上�?��的结果进行解�?
 659 | 	 * 
 660 | 	 * 3、然后用K1对上�?��的结果进行加�?
 661 | 	 * 
 662 | 	 * @param source
 663 | 	 * 
 664 | 	 * @param key
 665 | 	 * 
 666 | 	 * @param type
 667 | 	 *            0:encrypt 1:discrypt
 668 | 	 * 
 669 | 	 * @return
 670 | 	 */
 671 | 	protected static  String DES_3(String source, String key, int type) {
 672 | 		if (key.length() != 32 || source.length() != 16)
 673 | 			return null;
 674 | 		String temp = null;
 675 | 		String K1 = key.substring(0, key.length() / 2);
 676 | 		String K2 = key.substring(key.length() / 2);
 677 | 		System.out.println("K1--->" + K1);
 678 | 		System.out.println("K2--->" + K2);
 679 | 		if (type == 0) {
 680 | 			temp = encryption(source, K1);
 681 | 			System.out.println("step1--->" + temp);
 682 | 			temp = discryption(temp, K2);
 683 | 			System.out.println("step2--->" + temp);
 684 | 			return encryption(temp, K1);
 685 | 		}
 686 | 		if (type == 1) {
 687 | 			temp = discryption(source, K1);
 688 | 			temp = encryption(temp, K2);
 689 | 			return discryption(temp, K1);
 690 | 		}
 691 | 		return null;
 692 | 	}
 693 | 
 694 | 	/************************************ 48bit的轮子密钥的生成 **********************************************************/
 695 | 
 696 | 	/**
 697 | 	 * 
 698 | 	 * �?4bit的密钥转换成56bit
 699 | 	 * 
 700 | 	 * @param source
 701 | 	 * 
 702 | 	 * @return
 703 | 	 */
 704 | 
 705 | 	protected static  int[] keyPC_1(int[] source) {
 706 | 		int[] dest = new int[56];
 707 | 		int[] temp = { 57, 49, 41, 33, 25, 17, 9,
 708 | 		1, 58, 50, 42, 34, 26, 18,
 709 | 		10, 2, 59, 51, 43, 35, 27,
 710 | 		19, 11, 3, 60, 52, 44, 36,
 711 | 		63, 55, 47, 39, 31, 23, 15,
 712 | 		7, 62, 54, 46, 38, 30, 22,
 713 | 		14, 6, 61, 53, 45, 37, 29,
 714 | 		21, 13, 5, 28, 20, 12, 4 };
 715 | 		for (int i = 0; i < 56; i++) {
 716 | 			dest[i] = source[temp[i] - 1];
 717 | 		}
 718 | 		return dest;
 719 | 	}
 720 | 
 721 | 	/**
 722 | 	 * 
 723 | 	 * 将密钥循环左移i�?
 724 | 	 * 
 725 | 	 * @param source
 726 | 	 *            二进制密钥数�?
 727 | 	 * 
 728 | 	 * @param i
 729 | 	 *            循环左移位数
 730 | 	 * 
 731 | 	 * @return
 732 | 	 */
 733 | 
 734 | 	protected static  int[] keyLeftMove(int[] source, int i) {
 735 | 		int temp = 0;
 736 | 		int len = source.length;
 737 | 		int ls = LS[i];
 738 | 		// System.out.println("len" + len + ",LS[" + i + "]=" + ls);
 739 | 		for (int k = 0; k < ls; k++) {
 740 | 			temp = source[0];
 741 | 			for (int j = 0; j < len - 1; j++) {
 742 | 				source[j] = source[j + 1];
 743 | 			}
 744 | 			source[len - 1] = temp;
 745 | 		}
 746 | 		return source;
 747 | 	}
 748 | 
 749 | 	/**
 750 | 	 * 
 751 | 	 * �?6bit的密钥转换成48bit
 752 | 	 * 
 753 | 	 * @param source
 754 | 	 * 
 755 | 	 * @return
 756 | 	 */
 757 | 
 758 | 	protected static  int[] keyPC_2(int[] source) {
 759 | 		int[] dest = new int[48];
 760 | 		int[] temp = { 14, 17, 11, 24, 1, 5,
 761 | 		3, 28, 15, 6, 21, 10,
 762 | 		23, 19, 12, 4, 26, 8,
 763 | 		16, 7, 27, 20, 13, 2,
 764 | 		41, 52, 31, 37, 47, 55,
 765 | 		30, 40, 51, 45, 33, 48,
 766 | 		44, 49, 39, 56, 34, 53,
 767 | 		46, 42, 50, 36, 29, 32 };
 768 | 		for (int i = 0; i < 48; i++) {
 769 | 			dest[i] = source[temp[i] - 1];
 770 | 		}
 771 | 		return dest;
 772 | 	}
 773 | 
 774 | 	/**
 775 | 	 * 
 776 | 	 * 获取轮子密钥(48bit)
 777 | 	 * 
 778 | 	 * @param source
 779 | 	 * 
 780 | 	 * @return
 781 | 	 */
 782 | 
 783 | 	protected static  void setKey(String source) {
 784 | 		if (subKey.length > 0)
 785 | 			subKey = new int[16][48];
 786 | 		// 装换�?4bit
 787 | 		int[] temp = string2Binary(source);
 788 | 		// �?6bit均分成两部分
 789 | 		int[] left = new int[28];
 790 | 		int[] right = new int[28];
 791 | 		// 经过PC-1�?4bit转换�?6bit
 792 | 		int[] temp1 = new int[56];
 793 | 		temp1 = keyPC_1(temp);
 794 | 		// printArr(temp1);
 795 | 		// 将经过转换的temp1均分成两部分
 796 | 		for (int i = 0; i < 28; i++) {
 797 | 			left[i] = temp1[i];
 798 | 			right[i] = temp1[i + 28];
 799 | 		}
 800 | 
 801 | 		// 经过16次循环左移，然后PC-2置换
 802 | 		for (int i = 0; i < 16; i++) {
 803 | 			left = keyLeftMove(left, LS[i]);
 804 | 			right = keyLeftMove(right, LS[i]);
 805 | 			for (int j = 0; j < 28; j++) {
 806 | 				temp1[j] = left[j];
 807 | 				temp1[j + 28] = right[j];
 808 | 			}
 809 | 			// printArr(temp1);
 810 | 			subKey[i] = keyPC_2(temp1);
 811 | 		}
 812 | 	}
 813 | 
 814 | 	protected static  void printArr(int[] source) {
 815 | 		int len = source.length;
 816 | 		for (int i = 0; i < len; i++) {
 817 | 			System.out.print(source[i]);
 818 | 		}
 819 | 		System.out.println();
 820 | 	}
 821 | 
 822 | 	/**
 823 | 	 * 
 824 | 	 * 将ASC字符串转�?6进制字符�?
 825 | 	 * 
 826 | 	 * @param asc
 827 | 	 * 
 828 | 	 * @return
 829 | 	 */
 830 | 
 831 | 	protected static  String ASC_2_HEX(String asc) {
 832 | 		StringBuffer hex = new StringBuffer();
 833 | 		try {
 834 | 			byte[] bs = asc.toUpperCase().getBytes("UTF-8");
 835 | 			for (byte b : bs) {
 836 | 				hex.append(Integer.toHexString(new Byte(b).intValue()));
 837 | 			}
 838 | 		} catch (UnsupportedEncodingException e) {
 839 | 			e.printStackTrace();
 840 | 		}
 841 | 		return hex.toString();
 842 | 	}
 843 | 
 844 | 	/**
 845 | 	 * 
 846 | 	 * �?6进制的字符串转换成ASC的字符串
 847 | 	 * 
 848 | 	 * �?6进制的字符串压缩成BCD�?30313233343536373839414243444546)-->(0123456789ABCDEF)
 849 | 	 * 
 850 | 	 * @param hex
 851 | 	 * 
 852 | 	 * @return
 853 | 	 */
 854 | 
 855 | 	protected static  String HEX_2_ASC(String hex) {
 856 | 		String asc = null;
 857 | 		int len = hex.length();
 858 | 		byte[] bs = new byte[len / 2];
 859 | 		for (int i = 0; i < len / 2; i++) {
 860 | 			bs[i] = Byte.parseByte(hex.substring(i * 2, i * 2 + 2), 16);
 861 | 		}
 862 | 		try {
 863 | 			asc = new String(bs, "UTF-8");
 864 | 		} catch (UnsupportedEncodingException e) {
 865 | 			e.printStackTrace();
 866 | 		}
 867 | 		return asc;
 868 | 	}
 869 | 
 870 | 	/**
 871 | 	 * 
 872 | 	 * 计算MAC(hex)
 873 | 	 * 
 874 | 	 * ANSI-X9.9-MAC(16的整数�?不补)
 875 | 	 * 
 876 | 	 * PBOC-DES-MAC(16的整数�?�?000000000000000)
 877 | 	 * 
 878 | 	 * 使用单�?长密钥DES算法
 879 | 	 * 
 880 | 	 * @param key密钥
 881 | 	 *            (16byte)
 882 | 	 * 
 883 | 	 * @param vector初始向量0000000000000000
 884 | 	 * 
 885 | 	 * @param data数据
 886 | 	 * 
 887 | 	 * @return mac
 888 | 	 */
 889 | 
 890 | 	protected static  String MAC(String key, String vector, String data, int type) {
 891 | 		if (type == ASC) {
 892 | 			data = ASC_2_HEX(data);
 893 | 		}
 894 | 		int len = data.length();
 895 | 		int arrLen = len / 16 + 1;
 896 | 		String[] D = new String[arrLen];
 897 | 		if (vector == null)
 898 | 			vector = "0000000000000000";
 899 | 		if (len % 16 == 0) {
 900 | 			data += "8000000000000000";
 901 | 		} else {
 902 | 			data += "80";
 903 | 			for (int i = 0; i < 15 - len % 16; i++) {
 904 | 				data += "00";
 905 | 			}
 906 | 		}
 907 | 		for (int i = 0; i < arrLen; i++) {
 908 | 			D[i] = data.substring(i * 16, i * 16 + 16);
 909 | 			System.out.println("D[" + i + "]=" + D[i]);
 910 | 		}
 911 | 		// D0 Xor Vector
 912 | 		String I = xOr(D[0], vector);
 913 | 		String O = null;
 914 | 		for (int i = 1; i < arrLen; i++) {
 915 | 			// System.out.println(i + "**************");
 916 | 			// System.out.println("I=" + I);
 917 | 			O = DES_1(I, key, 0);
 918 | 			// System.out.println("O=" + O);
 919 | 			I = xOr(D[i], O);
 920 | 		// System.out.println("I=" + I);
 921 | 		}
 922 | 		I = DES_1(I, key, 0);
 923 | 		return I;
 924 | 	}
 925 | 
 926 | 	/**
 927 | 	 * 
 928 | 	 * 将s1和s2做异或，然后返回
 929 | 	 * 
 930 | 	 * @param s1
 931 | 	 * 
 932 | 	 * @param s2
 933 | 	 * 
 934 | 	 * @return
 935 | 	 */
 936 | 
 937 | 	protected static  String xOr(String s1, String s2) {
 938 | 		int[] iArr = diffOr(string2Binary(s1), string2Binary(s2));
 939 | 		return binary2ASC(intArr2Str(iArr));
 940 | 	}
 941 | 
 942 | 	/**
 943 | 	 * 
 944 | 	 * 将int类型数组拼接成字符串
 945 | 	 * 
 946 | 	 * @param arr
 947 | 	 * 
 948 | 	 * @return
 949 | 	 */
 950 | 
 951 | 	protected static  String intArr2Str(int[] arr) {
 952 | 		StringBuffer sb = new StringBuffer();
 953 | 		for (int i = 0; i < arr.length; i++) {
 954 | 			sb.append(arr[i]);
 955 | 		}
 956 | 		return sb.toString();
 957 | 
 958 | 	}
 959 | 
 960 | 	/**
 961 | 	 * 
 962 | 	 * 将data分散
 963 | 	 * 
 964 | 	 * @param data
 965 | 	 * 
 966 | 	 * @param key
 967 | 	 * 
 968 | 	 * @param type
 969 | 	 * 
 970 | 	 * @return
 971 | 	 */
 972 | 
 973 | 	protected static  String divData(String data, String key, int type) {
 974 | 		String left = null;
 975 | 		String right = null;
 976 | 		if (type == HEX) {
 977 | 			left = key.substring(0, 16);
 978 | 			right = key.substring(16, 32);
 979 | 		}
 980 | 		if (type == ASC) {
 981 | 			left = ASC_2_HEX(key.substring(0, 8));
 982 | 			right = ASC_2_HEX(key.substring(8, 16));
 983 | 		}
 984 | 		// 加密
 985 | 		data = DES_1(data, left, 0);
 986 | 		// 解密
 987 | 		data = DES_1(data, right, 1);
 988 | 		// 加密
 989 | 		data = DES_1(data, left, 0);
 990 | 		return data;
 991 | 	}
 992 | 
 993 | 	/**
 994 | 	 * 
 995 | 	 * 取反(10001)--->(01110)
 996 | 	 * 
 997 | 	 * @param source
 998 | 	 * 
 999 | 	 * @return
1000 | 	 */
1001 | 
1002 | 	protected static  String reverse(String source) {
1003 | 		int[] data = string2Binary(source);
1004 | 		int j = 0;
1005 | 		for (int i : data) {
1006 | 			data[j++] = 1 - i;
1007 | 		}
1008 | 		return binary2ASC(intArr2Str(data));
1009 | 	}
1010 | 
1011 | 	/**
1012 | 	 * 
1013 | 	 * 主密钥需要经过两次分散获得IC卡中的子密钥
1014 | 	 * 
1015 | 	 * @param issuerFlag发卡方标识符
1016 | 	 * 
1017 | 	 * @param appNo应用序列号即卡号
1018 | 	 * 
1019 | 	 * @param mpk主密钥
1020 | 	 * 
1021 | 	 * @return
1022 | 	 */
1023 | 	protected static  String getDPK(String issuerFlag, String appNo, String mpk) {
1024 | 		// 第一次分散
1025 | 		StringBuffer issuerMPK = new StringBuffer();
1026 | 		// 获取Issuer MPK左半边
1027 | 		issuerMPK.append(divData(issuerFlag, mpk, 0));
1028 | 		// 获取Issuer MPK右半边
1029 | 		issuerMPK.append(divData(reverse(issuerFlag), mpk, 0));
1030 | 		// 第二次分散
1031 | 		StringBuffer dpk = new StringBuffer();
1032 | 		// 获取DPK左半边
1033 | 		dpk.append(divData(appNo, issuerMPK.toString(), 0));
1034 | 		// 获取DPK右半边
1035 | 		dpk.append(divData(reverse(appNo), issuerMPK.toString(), 0));
1036 | 		return dpk.toString();
1037 | 	}
1038 | 	
1039 | 
1040 | 
1041 | }


--------------------------------------------------------------------------------
/com/simple8583/util/encrypt/MacUtil.java:
--------------------------------------------------------------------------------
  1 | package com.simple8583.util.encrypt;
  2 | 
  3 | 
  4 | import java.io.UnsupportedEncodingException;
  5 | import java.util.Random;
  6 | 
  7 | import com.simple8583.util.EncodeUtil;
  8 | 
  9 | /**
 10 |  * <p>DES加密类</p>
 11 |  *
 12 |  * @author Magic Joey
 13 |  * @version MacUtil.java 1.0 @2014-06-09 17:57$
 14 |  */
 15 | public class MacUtil {
 16 | 	public static String ZPK = "46FE4CA7D38564DF1A86B962BF2F0291";
 17 | 	public static String ZAK = "A1D610A2D9E00B5D5446E6F43E293719";
 18 | 	
 19 | 	private static final int[][] s1 = 
 20 | 		{
 21 | 			{14,4, 13,1, 2, 15,11,8, 3, 10,6, 12,5, 9, 0, 7},
 22 | 			{0, 15,7, 4, 14,2, 13,1, 10,6, 12,11,9, 5, 3, 8},
 23 | 			{4, 1, 14,8, 13,6, 2, 11,15,12,9, 7, 3, 10,5, 0},
 24 | 			{15,12,8, 2, 4, 9, 1, 7, 5, 11,3, 14,10,0, 6, 13}
 25 | 		 };
 26 | 
 27 | 	private static final int[][] s2 = 
 28 | 		{
 29 | 			{15,1, 8, 14,6, 11,3, 4, 9, 7, 2, 13,12,0, 5, 10},
 30 | 			{3, 13,4, 7, 15,2, 8, 14,12,0, 1, 10,6, 9, 11,5},
 31 | 			{0, 14,7, 11,10,4, 13,1, 5, 8, 12,6, 9, 3, 2, 15},
 32 | 			{13,8, 10,1, 3, 15,4, 2, 11,6, 7, 12,0, 5, 14,9}
 33 | 		};
 34 | 	private static final int[][] s3 = 
 35 | 		{
 36 | 			{10,0, 9, 14,6, 3, 15,5, 1, 13,12,7, 11,4, 2, 8},
 37 | 		 	{13,7, 0, 9, 3, 4, 6, 10,2, 8, 5, 14,12,11,15,1},
 38 | 		    {13,6, 4, 9, 8, 15,3, 0, 11,1, 2, 12,5, 10,14,7},
 39 | 		    {1, 10,13,0, 6, 9, 8, 7, 4, 15,14,3, 11,5, 2, 12}
 40 | 		};
 41 | 	private static final int[][] s4 = 
 42 | 		{
 43 | 			{7, 13,14,3, 0, 6, 9, 10,1, 2, 8, 5, 11,12,4, 15},
 44 | 		    {13,8, 11,5, 6, 15,0, 3, 4, 7, 2, 12,1, 10,14,9},
 45 | 		    {10,6, 9, 0, 12,11,7, 13,15,1, 3, 14,5, 2, 8, 4},
 46 | 		    {3, 15,0, 6, 10,1, 13,8, 9, 4, 5, 11,12,7, 2, 14}
 47 | 		};
 48 | 	private static final int[][] s5 = 
 49 | 		{
 50 | 			{2, 12,4, 1, 7, 10,11,6, 8, 5, 3, 15,13,0, 14,9},
 51 | 		    {14,11,2, 12,4, 7, 13,1, 5, 0, 15,10,3, 9, 8, 6},
 52 | 		    {4, 2, 1, 11,10,13,7, 8, 15,9, 12,5, 6, 3, 0, 14},
 53 | 		    {11,8, 12,7, 1, 14,2, 13,6, 15,0, 9, 10,4, 5, 3}
 54 | 		};
 55 | 
 56 | 	private static final int[][] s6 = 
 57 | 		{
 58 | 			{12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11},
 59 | 		    {10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8},
 60 | 		    {9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6},
 61 | 		    {4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13}
 62 | 		};
 63 | 	private static final int[][] s7 =
 64 | 		{
 65 | 			{4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1},
 66 | 		    {13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6},
 67 | 		    {1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2},
 68 | 		    {6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12}
 69 | 		};
 70 | 
 71 | 	private static final int[][] s8 = 
 72 | 		{
 73 | 			{13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7},
 74 | 			{1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2},
 75 | 			{7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8},
 76 | 			{2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11}
 77 | 		};
 78 | 
 79 | 	private static final int[] ip = 
 80 | 		{58, 50, 42, 34, 26, 18, 10, 2,
 81 | 		60, 52, 44, 36, 28, 20, 12, 4,
 82 | 		62, 54, 46, 38, 30, 22, 14, 6,
 83 | 		64, 56, 48, 40, 32, 24, 16, 8,
 84 | 		57, 49, 41, 33, 25, 17, 9, 1,
 85 | 		59, 51, 43, 35, 27, 19, 11, 3,
 86 | 		61, 53, 45, 37, 29, 21, 13, 5,
 87 | 		63, 55, 47, 39, 31, 23, 15, 7};
 88 | 
 89 | 	private static final int[] _ip = 
 90 | 		{40, 8, 48, 16, 56, 24, 64, 32,
 91 | 		39, 7, 47, 15, 55, 23, 63, 31,
 92 | 		38, 6, 46, 14, 54, 22, 62, 30,
 93 | 		37, 5, 45, 13, 53, 21, 61, 29,
 94 | 		36, 4, 44, 12, 52, 20, 60, 28,
 95 | 		35, 3, 43, 11, 51, 19, 59, 27,
 96 | 		34, 2, 42, 10, 50, 18, 58, 26,
 97 | 		33, 1, 41, 9, 49, 17, 57, 25};
 98 | 
 99 | 	private static final int[] LS = {1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1}; 
100 | 	private static int[][] subKey = new int[16][48];
101 | 	private static int HEX = 0;
102 | 
103 | 	private static int ASC = 1;
104 | 	
105 | 	
106 | 	/**
107 | 	 * 将16进制字符转换成对应的int类型值:如字符'A'被转换后为10;'B'将被转换为11
108 | 	 * @param ch 需要被转换的目标字符
109 | 	 * @return	转换后的int类型值
110 | 	 * @throws Exception 如果传入字符为非16进制字符，将会报'getIntByChar was wrong'自定义异常
111 | 	 */
112 | 	public static int getIntByChar(char ch) throws Exception
113 | 	{
114 | 		char t = Character.toUpperCase(ch);
115 | 		int i = 0;
116 | 		switch(t){
117 | 			case '0':
118 | 			case '1':
119 | 			case '2':
120 | 			case '3':
121 | 			case '4':
122 | 			case '5':
123 | 			case '6':
124 | 			case '7':
125 | 			case '8':
126 | 			case '9':
127 | 				i = Integer.parseInt(Character.toString(t));
128 | 				break;
129 | 			case 'A':
130 | 				i = 10;
131 | 				break;
132 | 			case 'B':
133 | 				i = 11;
134 | 				break;
135 | 			case 'C':
136 | 				i = 12;
137 | 				break;
138 | 			case 'D':
139 | 				i = 13;
140 | 				break;
141 | 			case 'E':
142 | 				i = 14;
143 | 				break;
144 | 			case 'F':
145 | 				i = 15;
146 | 				break;
147 | 			default:
148 | 				throw new Exception("getIntByChar was wrong");
149 | 		}
150 | 		return i;
151 | 	}
152 | 
153 | 	/**
154 | 	 * 将16进制表示的字符串转换为0,1组成的int数组
155 | 	 * 列如："ABC" 被转换后的结果为{1,0,1,0,1,0,1,1,1,1,0,0}
156 | 	 * @param source 十六进制字符串
157 | 	 * @return 0,1组成的int数组
158 | 	 */
159 | 	public static int[] string2Binary(String source)
160 | 	{
161 | 		int len = source.length();
162 | 		int[] dest = new int[len*4];
163 | 		char[] arr = source.toCharArray();
164 | 		for(int i=0; i<len; i++)
165 | 		{
166 | 			int t = 0;
167 | 			try {
168 | 				t = getIntByChar(arr[i]);
169 | 			} catch (Exception e) 
170 | 			{
171 | 				e.printStackTrace();
172 | 			}
173 | 	
174 | 			String[] str = Integer.toBinaryString(t).split("");
175 | 			int k = i*4 + 3;
176 | 			for(int j=str.length-1; j>0; j--)
177 | 			{
178 | 				dest[k] = Integer.parseInt(str[j]);
179 | 				k--;
180 | 			}
181 | 		}
182 | 		return dest;
183 | 	}
184 | 
185 | 
186 | 	/**
187 | 	 * 完成对底数X的Y次方操作,如输入值分别为：2和4 返回值为16
188 | 	 * @param x 执行幂操作的底数
189 | 	 * @param y	执行幂操作的指数
190 | 	 * @return	幂操作的结果
191 | 	 */
192 | 	public static int getXY(int x,int y)
193 | 	{
194 | 		int temp = x;
195 | 		if(y == 0) x = 1;
196 | 		for(int i=2; i<=y; i++)
197 | 		{
198 | 			x *= temp;  
199 | 		}
200 | 		return x;
201 | 	}
202 | 
203 | 	/**
204 | 	 * 将由0,1组成的长度为4的字符串转化为对应的16进制字符串表示，例如输入字符串"1111",输出值为"F"
205 | 	 * 注意此方法输入的字符串长度最大为4，一次只能转换成为一个16进制字符
206 | 	 * @param s 0,1组成的字符串
207 | 	 * @return 转换后的16进制字符
208 | 	 */
209 | 	public static String binary2Hex(String s)
210 | 	{
211 | 		int len = s.length();
212 | 		int result = 0;
213 | 		int k = 0;
214 | 		if(len > 4)
215 | 			return null;
216 | 		for(int i=len; i>0; i--)
217 | 		{
218 | 			result += Integer.parseInt(s.substring(i-1, i))*getXY(2,k);
219 | 			k++;
220 | 		}
221 | 		switch(result){
222 | 			case 0:
223 | 			case 1:
224 | 			case 2:
225 | 			case 3:
226 | 			case 4:
227 | 			case 5:
228 | 			case 6:
229 | 			case 7:
230 | 			case 8:
231 | 			case 9:
232 | 				return ""+result;
233 | 			case 10:
234 | 				return "A";
235 | 			case 11:
236 | 				return "B";
237 | 			case 12:
238 | 				return "C";
239 | 			case 13:
240 | 				return "D";
241 | 			case 14:
242 | 				return "E";
243 | 			case 15:
244 | 				return "F";
245 | 			default :
246 | 				return null;
247 | 		}
248 | 	}
249 | 
250 | 	/**
251 | 	 * 将一个小于16的数转换为一个对应的十六进制字符
252 | 	 * @param i 小于16的整数
253 | 	 * @return 十六进制字符
254 | 	 */
255 | 	public static String int2Hex(int i)
256 | 	{
257 | 		switch(i){
258 | 			case 0:
259 | 			case 1:
260 | 			case 2:
261 | 			case 3:
262 | 			case 4:
263 | 			case 5:
264 | 			case 6:
265 | 			case 7:
266 | 			case 8:
267 | 			case 9:
268 | 				return ""+i;
269 | 			case 10:
270 | 				return "A";
271 | 			case 11:
272 | 				return "B";
273 | 			case 12:
274 | 				return "C";
275 | 			case 13:
276 | 				return "D";
277 | 			case 14:
278 | 				return "E";
279 | 			case 15:
280 | 				return "F";
281 | 			default :
282 | 				return null;
283 | 		}
284 | 	}
285 | 
286 | 	/**
287 | 	 * 将0,1组成的字符串转换为对应的十六进制字符串，例如输入字符串"111100001111"输出为"FOF"
288 | 	 * 此方法输入的字符串长度不限
289 | 	 * @param s 0,1组成的字符串
290 | 	 * @return	十六进制字符串
291 | 	 */
292 | 	public static String binary2ASC(String s)
293 | 	{
294 | 		String str = "";
295 | 		int ii = 0;
296 | 		int len = s.length();
297 | 		if(len%4 != 0)
298 | 		{
299 | 			while(ii<4-len%4)
300 | 			{
301 | 				s = "0" + s;
302 | 			}
303 | 		}
304 | 		for(int i=0; i<len/4; i++)
305 | 		{
306 | 			str += binary2Hex(s.substring(i*4, i*4+4));
307 | 		}
308 | 		return str;
309 | 	}
310 | 
311 | 	public static int[] changeIP(int[] source)
312 | 	{
313 | 		int[] dest = new int[64];
314 | 		for(int i=0; i<64; i++)
315 | 		{
316 | 			dest[i] = source[ip[i]-1];
317 | 		}
318 | 		return dest;
319 | 	}
320 | 
321 | 
322 | 	public static int[] changeInverseIP(int[] source)
323 | 	{
324 | 		int[] dest = new int[64];
325 | 		for(int i=0; i<64; i++)
326 | 		{
327 | 			dest[i] = source[_ip[i]-1];
328 | 		}
329 | 		return dest;
330 | 	}
331 | 
332 | 		 
333 | 	public static int[] expend(int[] source)
334 | 	{
335 | 		int[] ret = new int[48];
336 | 		int[] temp = {32, 1, 2, 3, 4, 5,
337 | 		4, 5, 6, 7, 8, 9,
338 | 		8, 9, 10, 11, 12, 13,
339 | 		12, 13, 14, 15, 16, 17,
340 | 		16, 17, 18, 19, 20, 21,
341 | 		20, 21, 22, 23, 24, 25,
342 | 		24, 25, 26, 27, 28, 29,
343 | 		28, 29, 30, 31, 32, 1};
344 | 		for(int i=0; i<48; i++)
345 | 		{
346 | 			ret[i] = source[temp[i]-1];
347 | 		}
348 | 		return ret;
349 | 	} 
350 | 
351 | 
352 | 	public static int[] press(int[] source)
353 | 	{
354 | 		int[] ret = new int[32];
355 | 		int[][] temp = new int[8][6];
356 | 		int[][][] s = {s1,s2,s3,s4,s5,s6,s7,s8};
357 | 		StringBuffer str = new StringBuffer();
358 | 		for(int i=0; i<8; i++)
359 | 		{
360 | 			for(int j=0; j<6; j++)
361 | 			{
362 | 				temp[i][j] = source[i*6+j];
363 | 			}
364 | 		}
365 | 
366 | 		for(int i=0; i<8; i++)
367 | 		{
368 | 			int x = temp[i][0]*2 + temp[i][5];
369 | 			int y = temp[i][1]*8 + temp[i][2]*4 + temp[i][3]*2 + temp[i][4];
370 | 			int val = s[i][x][y];
371 | 			String ch = int2Hex(val);
372 | 			str.append(ch);
373 | 		}
374 | 
375 | 		ret = string2Binary(str.toString());
376 | 		ret = dataP(ret);
377 | 		
378 | 		return ret;
379 | 	}
380 | 
381 | 	public static int[] dataP(int[] source)
382 | 	{
383 | 		int[] dest = new int[32];
384 | 		int[] temp = 
385 | 		{16, 7, 20, 21,
386 | 		 29, 12, 28, 17,
387 | 		 1, 15, 23, 26,
388 | 		 5, 18, 31, 10,
389 | 		 2, 8, 24, 14,
390 | 		 32, 27, 3, 9,
391 | 		 19, 13, 30, 6,
392 | 		 22, 11, 4, 25};
393 | 
394 | 		int len = source.length;
395 | 		for(int i=0; i<len; i++)
396 | 		{
397 | 			dest[i] = source[temp[i]-1];
398 | 		}
399 | 
400 | 		return dest;
401 | 	}
402 | 
403 | 	public static int[] f(int[] R,int[] K)
404 | 	{
405 | 		int[] dest = new int[32];
406 | 		int[] temp = new int[48]; 
407 | 		int[] expendR = expend(R);
408 | 
409 | 		temp = diffOr(expendR, K);
410 | 		dest = press(temp);
411 | 
412 | 		return dest;
413 | 	}
414 | 
415 | 
416 | 	/**
417 | 	 * 对两个int类型数组执行异或操作
418 | 	 * @param source1 操作数1
419 | 	 * @param source2 操作数2
420 | 	 * @return 异或结果
421 | 	 */
422 | 	public static int[] diffOr(int[] source1,int[] source2)
423 | 	{
424 | 		int len = source1.length;
425 | 		int[] dest = new int[len];
426 | 
427 | 		for(int i=0; i<len; i++)
428 | 		{
429 | 			dest[i] = source1[i] ^ source2[i];
430 | 		}
431 | 
432 | 		return dest;
433 | 	}
434 | 
435 | 	/**
436 | 	 * 数据加密
437 | 	 * @param D 被加密数据
438 | 	 * @param K 加密密钥
439 | 	 * @return 加密结果
440 | 	 */
441 | 	public static String encryption(String D, String K)
442 | 	{
443 | 		String str = "";
444 | 		int[] temp = new int[64];
445 | 		int[] data = string2Binary(D);
446 | 
447 | 		data = changeIP(data);
448 | 		int[][] left = new int[17][32];
449 | 		int[][] right = new int[17][32];
450 | 
451 | 		for(int j=0; j<32; j++)
452 | 		{
453 | 			left[0][j] = data[j];
454 | 			right[0][j] = data[j+32];
455 | 		}
456 | 
457 | 		setKey(K);
458 | 		for(int i=1; i<17; i++)
459 | 		{
460 | 			int[] key = subKey[i-1];
461 | 			left[i] = right[i-1];
462 | 			int[] fTemp = f(right[i-1],key);
463 | 			right[i] = diffOr(left[i-1],fTemp);
464 | 		}
465 | 
466 | 		for(int i=0; i<32; i++)
467 | 		{
468 | 			temp[i] = right[16][i];
469 | 			temp[32+i] = left[16][i];
470 | 		}
471 | 
472 | 		temp = changeInverseIP(temp);
473 | 		str = binary2ASC(intArr2Str(temp));
474 | 
475 | 		return str;
476 | 	}
477 | 
478 | 
479 | 	/**
480 | 	 * 解密
481 | 	 * @param source 解密目标
482 | 	 * @param key 解密密钥
483 | 	 * @return 解密结果
484 | 	 */
485 | 	public static String discryption(String source,String key){
486 | 		String str = "";
487 | 		int[] data = string2Binary(source);
488 | 		data = changeIP(data);
489 | 		int[] left = new int[32];
490 | 		int[] right = new int[32];
491 | 		int[] tmp = new int[32];
492 | 		for(int j=0; j<32; j++)
493 | 		{
494 | 			left[j] = data[j];
495 | 			right[j] = data[j+32];
496 | 		}
497 | 
498 | 		setKey(key);
499 | 		for(int i=16; i>0; i--)
500 | 		{
501 | 			int[] sKey = subKey[i-1];
502 | 			tmp = left;
503 | 			left = right;
504 | 			int[] fTemp = f(right,sKey);
505 | 			right = diffOr(tmp,fTemp);
506 | 		}
507 | 
508 | 		for(int i=0; i<32; i++)
509 | 		{
510 | 			data[i] = right[i];
511 | 			data[32+i] = left[i];
512 | 		}
513 | 
514 | 		data = changeInverseIP(data);
515 | 		for(int i=0; i<data.length; i++)
516 | 		{
517 | 			str += data[i];
518 | 		}
519 | 
520 | 		str = binary2ASC(str);
521 | 		
522 | 		return str;
523 | 	}
524 | 
525 | 	/**
526 | 	 * DES加解密 type 参数为0 表示加密，type 为1 表示解密
527 | 	 * @param source 目标数据
528 | 	 * @param key 密钥
529 | 	 * @param type 加解密类型
530 | 	 * @return 加加解密结果
531 | 	 */
532 | 	public static String DES_1(String source,String key,int type)
533 | 	{
534 | 		if(source.length() != 16 || key.length() != 16)
535 | 			return null;
536 | 		if(type==0)
537 | 		{
538 | 			return encryption(source, key);
539 | 		}
540 | 		if(type==1)
541 | 		{
542 | 			return discryption(source, key);
543 | 		}
544 | 
545 | 		return null;
546 | 	}
547 | 
548 | 
549 | 	/**
550 | 	 * 3DES加解密
551 | 	 * type参数为0表示加密，参数为1表示解密
552 | 	 * @param source 目标数据
553 | 	 * @param key 密钥
554 | 	 * @param type 加解密类型
555 | 	 * @return 加解密结果
556 | 	 */
557 | 	public static String DES_3(String source,String key,int type)
558 | 	{
559 | 		if(key.length() != 32 || source.length() != 16)
560 | 			return null;
561 | 		String temp = null;
562 | 		String K1 = key.substring(0, key.length()/2);
563 | 		String K2 = key.substring(key.length()/2);
564 | 
565 | 		if(type==0)
566 | 		{
567 | 			temp = encryption(source, K1);
568 | 			temp = discryption(temp, K2);
569 | 	
570 | 			return encryption(temp, K1);
571 | 		}
572 | 
573 | 		if(type==1)
574 | 		{
575 | 			temp = discryption(source, K1);
576 | 			temp = encryption(temp, K2);
577 | 			return discryption(temp, K1);
578 | 		}
579 | 
580 | 		return null;
581 | 	}
582 | 
583 | 	public static int[] keyPC_1(int[] source)
584 | 	{
585 | 		int[] dest = new int[56];
586 | 		int[] temp = 
587 | 		{57, 49, 41, 33, 25, 17, 9,
588 | 		 1, 58, 50, 42, 34, 26, 18,
589 | 		 10, 2, 59, 51, 43, 35, 27,
590 | 		 19, 11, 3, 60, 52, 44, 36,
591 | 		 63, 55, 47, 39, 31, 23, 15,
592 | 		 7, 62, 54, 46, 38, 30, 22,
593 | 		 14, 6, 61, 53, 45, 37, 29,
594 | 		 21, 13, 5, 28, 20, 12, 4};
595 | 
596 | 		for(int i=0; i<56; i++)
597 | 		{
598 | 			dest[i] = source[temp[i]-1];
599 | 		}
600 | 		
601 | 		return dest;
602 | 	}
603 | 
604 | 	public static int[] keyLeftMove(int[] source, int i){
605 | 		int temp = 0;
606 | 		int len = source.length;
607 | 		int ls = LS[i];
608 | 		for(int k=0; k<ls; k++)
609 | 		{
610 | 			temp = source[0];
611 | 			for(int j=0; j<len-1; j++)
612 | 			{
613 | 				source[j] = source[j+1];
614 | 			}
615 | 			source[len-1] = temp;
616 | 		}
617 | 		return source;
618 | 	}
619 | 
620 | 	public static int[] keyPC_2(int[] source)
621 | 	{
622 | 		int[] dest = new int[48];
623 | 		int[] temp = 
624 | 		{14, 17, 11, 24, 1, 5,
625 | 		 3, 28, 15, 6, 21, 10,
626 | 		 23, 19, 12, 4, 26, 8,
627 | 		 16, 7, 27, 20, 13, 2,
628 | 		 41, 52, 31, 37, 47, 55,
629 | 		 30, 40, 51, 45, 33, 48,
630 | 		 44, 49, 39, 56, 34, 53,
631 | 		 46, 42, 50, 36, 29, 32};
632 | 
633 | 		for(int i=0; i<48; i++)
634 | 		{
635 | 			dest[i] = source[temp[i]-1];
636 | 		}
637 | 
638 | 		return dest;
639 | 	}
640 | 
641 | 	public static void setKey(String source)
642 | 	{
643 | 		if(subKey.length > 0)
644 | 			subKey = new int[16][48];
645 | 
646 | 		int[] temp = string2Binary(source);
647 | 		int[] left = new int[28];
648 | 		int[] right = new int[28];
649 | 		int[] temp1 = new int[56];
650 | 		temp1 = keyPC_1(temp);
651 | 
652 | 		for(int i=0; i<28; i++)
653 | 		{
654 | 			left[i] = temp1[i];
655 | 			right[i] = temp1[i+28];
656 | 		}
657 | 
658 | 		for(int i=0; i<16; i++)
659 | 		{
660 | 			left = keyLeftMove(left, LS[i]);
661 | 			right = keyLeftMove(right, LS[i]);
662 | 	
663 | 			for(int j=0; j<28; j++)
664 | 			{
665 | 				temp1[j] = left[j];
666 | 				temp1[j+28] = right[j];
667 | 			}
668 | 			subKey[i] = keyPC_2(temp1);
669 | 		}
670 | 	}
671 | 
672 | 	/**
673 | 	 * 将字符串转换为16进制表示,首先调用getBytes方法获取字符串的字节表示方法
674 | 	 * 再将字节数组转换为16进制字符串表示
675 | 	 * @param asc 转换目标
676 | 	 * @return 转换结果
677 | 	 */
678 | 	public static String ASC_2_HEX(String asc)
679 | 	{
680 | 		StringBuffer hex = new StringBuffer();
681 | 		try 
682 | 		{
683 | 			byte[] bs = asc.toUpperCase().getBytes("UTF-8");
684 | 			for(byte b : bs)
685 | 			{
686 | 				hex.append(Integer.toHexString(new Byte(b).intValue()));
687 | 			}
688 | 		} 
689 | 		catch (UnsupportedEncodingException e) 
690 | 		{
691 | 			e.printStackTrace();
692 | 		}
693 | 		return hex.toString();
694 | 	}
695 | 
696 | 	public static String HEX_2_ASC(String hex)
697 | 	{
698 | 		String asc = null;
699 | 		int len = hex.length();
700 | 		byte[] bs = new byte[len/2];
701 | 		for(int i=0; i<len/2; i++)
702 | 		{
703 | 			bs[i] = Byte.parseByte(hex.substring(i*2, i*2+2), 16);
704 | 		}
705 | 		try 
706 | 		{
707 | 			asc = new String(bs,"UTF-8");
708 | 		} 
709 | 		catch (UnsupportedEncodingException e) 
710 | 		{
711 | 			e.printStackTrace();
712 | 		}
713 | 		
714 | 		return asc;
715 | 	}
716 | 
717 | 	public static String xOr(String s1,String s2)
718 | 	{
719 | 		int[] iArr = diffOr(string2Binary(s1), string2Binary(s2));
720 | 		return binary2ASC(intArr2Str(iArr));
721 | 	}
722 | 
723 | 
724 | 	public static String intArr2Str(int[] arr)
725 | 	{
726 | 		StringBuffer sb = new StringBuffer();
727 | 		for(int i=0; i<arr.length; i++)
728 | 		{
729 | 			sb.append(arr[i]);
730 | 		}
731 | 
732 | 		return sb.toString();
733 | 	}
734 | 
735 | 	public static String divData(String data,String key,int type){
736 | 		String left = null;
737 | 		String right = null;
738 | 		if(type == HEX)
739 | 		{
740 | 			left = key.substring(0, 16);
741 | 			right = key.substring(16,32);
742 | 		}
743 | 
744 | 		if(type == ASC)
745 | 		{
746 | 			left = ASC_2_HEX(key.substring(0, 8));
747 | 			right = ASC_2_HEX(key.substring(8,16));
748 | 		}
749 | 
750 | 		data = DES_1(data, left, 0);
751 | 		data = DES_1(data, right, 1);
752 | 		data = DES_1(data, left, 0);
753 | 
754 | 		return data;
755 | 	}	
756 | 
757 | 	public static String reverse(String source)
758 | 	{
759 | 		int[] data = string2Binary(source);
760 | 		int j = 0;
761 | 		for(int i : data)
762 | 		{
763 | 			data[j++] = 1 - i;
764 | 		}
765 | 		return binary2ASC(intArr2Str(data));
766 | 	}
767 | 	
768 | 	public static String getDPK(String issuerFlag,String appNo,String mpk)
769 | 	{
770 | 		StringBuffer issuerMPK = new StringBuffer();
771 | 		issuerMPK.append(divData(issuerFlag, mpk, 0));
772 | 		issuerMPK.append(divData(reverse(issuerFlag), mpk, 0));
773 | 		StringBuffer dpk = new StringBuffer();
774 | 		dpk.append(divData(appNo, issuerMPK.toString(), 0));
775 | 		dpk.append(divData(reverse(appNo), issuerMPK.toString(), 0));
776 | 		
777 | 		return dpk.toString();
778 | 	}
779 | 		
780 | 	public static String xOrString(String pan,String pin)
781 | 		{
782 | 			//TODO
783 | 			//System.out.println("参与异或的因子分别为：" + pan + "和" + pin);
784 | 			if(pan.length() != pin.length())
785 | 			{
786 | 				new Exception("异或因子长度不一致").printStackTrace();
787 | 				return null;
788 | 			}
789 | 			
790 | 			byte [] bytepan = EncodeUtil.bcd(pan);
791 | 			byte [] bytepin = EncodeUtil.bcd(pin);
792 | 			
793 | 			byte [] result = new byte[bytepan.length];
794 | 			
795 | 			for(int i = 0;i < result.length;i++)
796 | 			{
797 | 				result [i] = (byte)(bytepan[i] ^ bytepin[i]);
798 | 			}
799 | 			
800 | 			//TODO
801 | 			//System.out.println("异或后的结果为：" + ByteUtil.getHexStr(result));
802 | 			return EncodeUtil.hex(result);
803 | 		}
804 | 		
805 | 		public static String createPwd(String cardNo,String pwd,String key)
806 | 		{
807 | 			//TODO
808 | 			System.out.println("账号和密码分别为: " + cardNo + "和" + pwd);
809 | 			String last6 = cardNo.substring(cardNo.length() - 13,cardNo.length() - 1);
810 | 			String first2 = "0000";
811 | 			String pan = first2 + last6;
812 | 			
813 | 			String pin = "06" + pwd + "FFFFFFFF";
814 | 			
815 | 			String result = xOrString(pan,pin);
816 | 			
817 | 			String ret = DES_3(result,key,0);
818 | 			//TODO
819 | 			System.out.println("加密pin为:" + ret);
820 | 			return ret;
821 | 		}
822 | 		
823 | 		/**
824 | 		 * 生成ANSI-X9.9-MAC校验码
825 | 		 * 所有的输入输出数据必须是16进制字符串
826 | 		 * 密钥只能为16位长度的16进制字符串,否则将返回null
827 | 		 * 初始向量为16为长度的16进制字符串,如果不符合条件,自动设置为"0000000000000000"
828 | 		 * 原始数据,16进制表示的字符串
829 | 		 * @param key	密钥
830 | 		 * @param vector	初始向量
831 | 		 * @param data	加密数据
832 | 		 * @return	加密后的数据
833 | 		 */
834 | 		public static String MAC_ASC(String key,String vector,String data){
835 | 			return MAC(key,vector,EncodeUtil.hex(data.getBytes()));
836 | 		}
837 | 		
838 | 		public static String MAC(String key,String vector,String data)
839 | 		{
840 | 			if(key.length() != 16)
841 | 			{
842 | 				new Exception("key's length must be 16!").printStackTrace();
843 | 				return null;
844 | 			}
845 | 			
846 | 			if(vector == null || vector.length() != 16)
847 | 				vector = "0000000000000000";
848 | 			
849 | 			StringBuffer sb = new StringBuffer(data);
850 | 			int mod = data.length()%16;
851 | 			if(mod != 0)
852 | 			{
853 | 				for(int i = 0;i < 16 - mod;i++)
854 | 				{
855 | 					sb.append("0");
856 | 				}
857 | 			}
858 | 			String operator = sb.toString();
859 | 			//TODO
860 | 			System.out.println("补位后的操作数为：" + operator);
861 | 			int count = operator.length()/16;
862 | 			String [] blocks = new String[count];
863 | 			for(int i = 0;i < count;i++)
864 | 			{
865 | 				blocks[i] = operator.substring(i*16, i*16 + 16);
866 | 			}
867 | 			//循环进行异或,DES加密
868 | 			for(int i = 0;i < count;i++)
869 | 			{
870 | 				String xor = xOrString(vector,blocks[i]);
871 | 				vector = DES_1(xor,key,0);
872 | 			}
873 | 			return vector;
874 | 		}
875 | 		
876 | 		/**
877 | 		 * 按照ANSIX9.19算法标准，生成MAC
878 | 		 * @param key	加密密钥32位16进制字符串
879 | 		 * @param vector	初始向量16位16进制字符串
880 | 		 * @param data	生成mac的原始数据的16进制表示
881 | 		 * @return	最终生成mac的字符串
882 | 		 */
883 | 		public static String Mac_919(String key,String vector,String data)
884 | 		{
885 | 			if(key.length() != 32)
886 | 			{
887 | 				new Exception("key of ansix9.19 must be 32").printStackTrace();
888 | 				return null;
889 | 			}
890 | 			
891 | 			String left = key.substring(0, 16);
892 | 			String right = key.substring(16);
893 | 			
894 | 			String mac = MAC(left,null,data);
895 | 			String result1 = DES_1(mac,right,1);
896 | 			String result2 = DES_1(result1,left,0);
897 | 			
898 | 			String ret = result2.substring(0,8);
899 | 			return ret;
900 | 		}
901 | 		
902 | 		public static String createRandom(int length)
903 | 		{
904 | 			StringBuffer sb = new StringBuffer("");
905 | 			Random random = new Random();
906 | 			for(int i = 0;i < length;i++)
907 | 			{
908 | 				int abs = Math.abs(random.nextInt()%10);
909 | 				sb.append("" + abs);
910 | 			}
911 | 			return sb.toString();
912 | 		}
913 | 	
914 | 	public static void main(String [] args)
915 | 	{
916 | 		String mac = MAC_ASC("5883F8DA898A3149","0000000000000000",EncodeUtil.hex("409666552865948200000000000000000193322515631010000".getBytes()));
917 | 		System.out.println("生成mac为：" + mac);
918 | 		
919 | //		System.out.println("生成的随机数为：" + createRandom(6));
920 | 	}
921 | }
922 | 


--------------------------------------------------------------------------------
/com/simple8583/util/encrypt/TripleDES.java:
--------------------------------------------------------------------------------
 1 | package com.simple8583.util.encrypt;
 2 | 
 3 | import java.io.UnsupportedEncodingException;
 4 | 
 5 | 
 6 | /**
 7 |  * <p>三倍长DES</p>
 8 |  *
 9 |  * @author Magic Joey
10 |  * @version MacUtil.java 1.0 @2014-06-09 17:57$
11 |  */
12 | public class TripleDES extends DES {
13 | 
14 | 	// 双倍长计算密钥长度
15 | 	public static String DESDouble(String source, String key, int mode) {
16 | 		String first = DES_2(source.substring(0, 16), key, mode);
17 | 		String second = DES_2(source.substring(16), key, mode);
18 | 		return first + second;
19 | 	}
20 | 
21 | 	public static String getMacValue(String macKey) {
22 | 		//java中为什么不支持"0"*32这种写法？
23 | 		String data = DESDouble("00000000000000000000000000000000", macKey, 0);
24 | 		return data.substring(0, 6);
25 | 	}
26 | 
27 | 	public static String getMac(String macKey, String data) {
28 | 		String lk = macKey.substring(0, 16);
29 | 		String rk = macKey.substring(16);
30 | 		String second_result = MacUtil.MAC_ASC(lk, "0000000000000000", data);// ANSI-X9.9-MAC计算mac
31 | 		System.out.println("第一步结果:" + second_result);
32 | 		String triple_result = DES_1(second_result, rk, 1);// 1为解密，第三部结果
33 | 		System.out.println("第二步结果:" + triple_result);
34 | 		String fourth_result = DES_1(triple_result, lk, 0);// 0为加密，使用左16位密钥
35 | 		System.out.println("第三步结果:" + fourth_result);
36 | 		return fourth_result;
37 | 	}
38 | 
39 | 
40 | 	public static void main(String[] args) throws UnsupportedEncodingException {
41 | 
42 | 		// System.out.println(DESDouble("D1A1DA31D3221AD2345DA4A78DADA123",
43 | 		// "15656156165165165165156165102044", 1));
44 | 		// String key = "D59B49C2A78FF4E6";
45 | 		// String vector = "0000000000000000";
46 | 		// String value =
47 | 		// "343039363636353532383635393438323130303030303030303030313331303130303030";
48 | 		// int type=1;
49 | 		// String re = MAC(key,vector,value,type);
50 | 		// System.out.println(re);
51 | 		// String bocMac = "ACFB515645FAB4544FA454AB12649528";
52 | 		// String zmk_lmk = "123525964972ADB9913578025046931F";
53 | 		// String data =
54 | 		// "564561487446515618949848123615645645646515615615616516489498";
55 | 		//
56 | 		// String dd = getMac(bocMac,zmk_lmk,data);
57 | 		// System.out.println(dd);
58 | 
59 | 		//
60 | 		// String lmk = "CF8C6A404793D373CF8C6A404793D373";
61 | 		// String bocMac = "9E3C3C9F5127E4A285496DF46261346B";
62 | 		// String data =
63 | 		// "4096665528659482000000000000000001750206113521201407040156E331010000";
64 | 		// //
65 | 		// String result = getMac(lmk, bocMac, data);
66 | 		// System.out.println(result);
67 | 
68 | 		// // /8EF9089200D9720B
69 | 		// System.out.println("预期结果："+EncodeUtil.hex(EncodeUtil.binary("1000111011111001000010001001001000000000110110010111001000001011")));
70 | 		// System.out.println(new
71 | 		// String(EncodeUtil.bcd("4096665528659482"),"GBK"));
72 | 
73 | 		// String source = "7BC1B6CB52487E706FC36FD95B2DF040";
74 | 		// String key = "33333333333333333333333333333333";
75 | 		// int mode = 1;
76 | 		// String mac_key = DESDouble(source, key, mode);
77 | 		// String data =
78 | 		// DESDouble("00000000000000000000000000000000",mac_key,0);
79 | //		String data = "409666552865948200000000000000000193322515631010000";
80 | 		String macKey = "5883F8DA898A31495DF792A8DA15E013";
81 | 		String data = "409666552865948200000000000000000193322515631010000";//.getBytes());
82 | 		// System.out.println(data.substring(0,6));
83 | 		System.out.println(getMac(macKey, data));
84 | 		System.out.println("预期值：" + "AFC74C7A");
85 | 		// String encrypt = new
86 | 		// String(EncodeUtil.bcd("41E2E66D00D9ABF6"),"GBK");
87 | 		// System.out.println(encrypt);
88 | 	}
89 | 
90 | }
91 | 


--------------------------------------------------------------------------------
/simple8583.dtd:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <!ELEMENT simple8583-config (header+, package+ ) >
 3 | 
 4 | 
 5 | <!ELEMENT header ( field+ ) >
 6 | 
 7 | <!ELEMENT package ( field+ ) >
 8 | <!ATTLIST package mti NMTOKEN #REQUIRED >
 9 | 
10 | <!ELEMENT field ( #PCDATA ) >
11 | <!ATTLIST field id NMTOKEN #REQUIRED >
12 | <!ATTLIST field length NMTOKEN #IMPLIED >
13 | <!ATTLIST field type ( BINARY | NUMERIC | CHAR | LLVAR | LLLVAR | LLVAR_NUMERIC) #REQUIRED >


--------------------------------------------------------------------------------
/simple8583.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <simple8583-config>
  3 | 
  4 | 	<!-- 长度全部都是字节数（由自己换算,LLVAR,LLLVAR,LLVAR_NUMERIC等变长数据域定义的长度无效） -->
  5 | 	
  6 | 	<!-- 统一头，每次不管请求还是响应都包含的共同内容 -->
  7 |     <header>
  8 |         <field id="MsgLength" type="NUMERIC" length="2"/>
  9 |         <field id="tpdu" type="NUMERIC" length="5"/>
 10 |         <field id="VersionNo" type="NUMERIC" length="2"/>
 11 |         <field id="mti" type="NUMERIC" length="2"/>
 12 |         <field id="BitMap" type="BINARY" length="8"/>
 13 |     </header>
 14 | 
 15 |     <!-- 身份校验,手机验证码,交易查证 -->
 16 |     <package mti="0600">
 17 |         <field id="2" type="LLVAR_NUMERIC" />
 18 |         <field id="3" type="NUMERIC" length="3"/>
 19 |         <field id="4" type="NUMERIC" length="6" />
 20 |         <field id="8" type="CHAR" length="11" />
 21 |         <field id="11" type="NUMERIC" length="3" />
 22 |         <field id="12" type="NUMERIC" length="3" />
 23 |         <field id="13" type="NUMERIC" length="4" />
 24 |         <field id="32" type="LLVAR_NUMERIC"/>
 25 |         <field id="38" type="CHAR" length="6"/>
 26 |         <field id="39" type="CHAR" length="2" />
 27 |         <field id="40" type="LLVAR"/>
 28 |         <field id="41" type="CHAR" length="8" />
 29 |         <field id="42" type="CHAR" length="15" />
 30 |         <field id="44" type="LLVAR"/>
 31 |         <field id="57" type="LLLVAR"/>
 32 |         <field id="58" type="LLLVAR" />
 33 |         <field id="64" type="BINARY" length="8"/>
 34 |     </package>
 35 | 
 36 |     <!-- 机构签到 -->
 37 |     <package mti="0800">
 38 |         <field id="3" type="NUMERIC" length="3"/>
 39 |         <field id="12" type="NUMERIC" length="3" />
 40 |         <field id="13" type="NUMERIC" length="4" />
 41 |         <field id="32" type="LLVAR_NUMERIC"/>
 42 |         <field id="39" type="CHAR" length="2" />
 43 |         <field id="40" type="LLVAR"/>
 44 |         <field id="48" type="LLLVAR"/>
 45 |     </package>
 46 |     
 47 | 	<!-- 消费交易-->
 48 |     <package mti="0200">
 49 |         <field id="2" type="LLVAR_NUMERIC"/>
 50 |         <field id="3" type="NUMERIC" length="3"/>
 51 |         <field id="4" type="NUMERIC" length="6" />
 52 |         <field id="8" type="CHAR" length="11" />
 53 |         <field id="11" type="NUMERIC" length="3" />
 54 |         <field id="12" type="NUMERIC" length="3" />
 55 |         <field id="13" type="NUMERIC" length="4" />
 56 |         <field id="14" type="NUMERIC" length="2" />
 57 |         <field id="22" type="NUMERIC" length="2"/>
 58 |         <field id="24" type="NUMERIC" length="2"/>
 59 |         <field id="25" type="NUMERIC" length="1"/>
 60 |         <field id="32" type="LLVAR_NUMERIC"/>
 61 |         <field id="37" type="CHAR" length="12"/>
 62 |         <field id="38" type="CHAR" length="6"/>
 63 |         <field id="39" type="CHAR" length="2" />
 64 |         <field id="40" type="LLVAR"/>
 65 |         <field id="41" type="CHAR" length="8" />
 66 |         <field id="42" type="CHAR" length="15" />
 67 |         <field id="43" type="CHAR" length="40" />
 68 |         <field id="44" type="LLVAR"/>
 69 |         <field id="45" type="CHAR" length="40" />
 70 |         <field id="48" type="LLLVAR"/>
 71 |         <field id="49" type="NUMERIC" length="2" />
 72 |         <field id="54" type="LLLVAR"/>
 73 |         <field id="58" type="LLLVAR"/>
 74 |         <field id="64" type="BINARY" length="8" />
 75 |     </package>
 76 | 
 77 | 	<!-- 消费退货-->
 78 |     <package mti="0220">
 79 |             <field id="2" type="LLVAR_NUMERIC"/>
 80 |         <field id="3" type="NUMERIC" length="3"/>
 81 |         <field id="4" type="NUMERIC" length="6" />
 82 |         <field id="8" type="CHAR" length="11" />
 83 |         <field id="11" type="NUMERIC" length="3" />
 84 |         <field id="12" type="NUMERIC" length="3" />
 85 |         <field id="13" type="NUMERIC" length="4" />
 86 |         <field id="14" type="NUMERIC" length="2" />
 87 |         <field id="22" type="NUMERIC" length="2"/>
 88 |         <field id="24" type="NUMERIC" length="2"/>
 89 |         <field id="25" type="NUMERIC" length="1"/>
 90 |         <field id="32" type="LLVAR_NUMERIC"/>
 91 |         <field id="37" type="CHAR" length="12"/>
 92 |         <field id="38" type="CHAR" length="6"/>
 93 |         <field id="39" type="CHAR" length="2" />
 94 |         <field id="40" type="LLVAR"/>
 95 |         <field id="41" type="CHAR" length="8" />
 96 |         <field id="42" type="CHAR" length="15" />
 97 |         <field id="43" type="CHAR" length="40" />
 98 |         <field id="44" type="LLVAR"/>
 99 |         <field id="45" type="CHAR" length="40" />
100 |         <field id="48" type="LLLVAR"/>
101 |         <field id="49" type="NUMERIC" length="2" />
102 |         <field id="52" type="BINARY" length="8" />
103 |         <field id="58" type="LLLVAR"/>
104 |         <field id="62" type="LLLVAR"/>
105 |         <field id="64" type="BINARY" length="8" />
106 |     </package>
107 | 
108 |     <!--测试类型-->
109 |     <package mti="0420" ref="0430">
110 |         <field id="1" type="CHAR" length="4"/>
111 |         <field id="2" type="CHAR" length="6"/>
112 |         <field id="3" type="CHAR" length="8"/>
113 |         <field id="4" type="CHAR" length="15"/>
114 |         <field id="5" type="CHAR" length="2"/>
115 |         <field id="6" type="CHAR" length="19"/>
116 |         <field id="7" type="NUMERIC" length="12"/>
117 |         <field id="8" type="CHAR" length="20"/>
118 |         <field id="9" type="CHAR" length="3"/>
119 |         <field id="10" type="CHAR" length="20"/>
120 |         <field id="11" type="CHAR" length="6"/>
121 |         <field id="12" type="CHAR" length="10"/>
122 |         <field id="13" type="CHAR" length="70"/>
123 |         <field id="14" type="CHAR" length="3"/>
124 |         <field id="15" type="CHAR" length="20"/>
125 |         <field id="16" type="CHAR" length="22"/>
126 |         <field id="17" type="CHAR" length="15"/>
127 |         <field id="18" type="CHAR" length="32"/>
128 |     </package>
129 | 
130 | 
131 |     <!--测试类型 返回-->
132 |     <package mti="0430">
133 |         <field id="1" type="CHAR" length="4"/>
134 |         <field id="2" type="CHAR" length="6"/>
135 |         <field id="3" type="CHAR" length="8"/>
136 |         <field id="4" type="CHAR" length="15"/>
137 |         <field id="5" type="CHAR" length="2"/>
138 |         <field id="6" type="CHAR" length="19"/>
139 |         <field id="7" type="NUMERIC" length="12"/>
140 |         <field id="8" type="CHAR" length="20"/>
141 |         <field id="9" type="CHAR" length="6"/>
142 |         <field id="10" type="CHAR" length="8"/>
143 |         <field id="11" type="CHAR" length="8"/>
144 |         <field id="12" type="CHAR" length="11"/>
145 |         <field id="13" type="CHAR" length="20"/>
146 |         <field id="14" type="CHAR" length="3"/>
147 |         <field id="15" type="CHAR" length="2"/>
148 |         <field id="16" type="CHAR" length="25"/>
149 |         <field id="17" type="CHAR" length="32"/>
150 |     </package>
151 |     
152 | </simple8583-config>


--------------------------------------------------------------------------------