在有卡片的应用系统中,很多数据都是进行加密处理的.如有的系统是采用密文传输数据,有的采用明文+MAC方式,也有的是密文+MAC.但不管采用那种方式,都是与加密/解密息息相关的.
在我开发的系统中,为保证系统的安全,卡片有效和数据完整,做了一个软加密机.就是一个java程序实现对数据的加密,解密和MAC运算.采用3DES算法,它提供密钥经分散后的加/解功能.关于java实现DES的程序,在网上可以找到,这里不在赘述.本文介绍对软加密机访问的例程.
我还是定义了3个类:
接口类:IHSM.JAVA,说明对外提供的行为.
实现类:HSM.JAVA,对加密机的访问具体实现.
异常类:HSMException.java,继承系统Exception类.
package com.microapp.business.hsm;
/**
*
Title: System
*
*
Description:
*
*
Copyright: Copyright (c) 2005
*
*
Company: my
*
* @author microapp
* @version 1.0
*/
public interface IHSM
{
/**
* 加密数据
* @param interspersed
* @param data String
* @param index int
* @return String
* @throws HSMException
*/
public String getEncryption(String interspersed, String data, int index) throws HSMException;
/**
* getKey
*
* @param inInterspersed String
* @param outInterspersed String
* @param index int
*/
public String getKey(String inInterspersed, String outInterspersed, int index) throws HSMException;
/**
* 解密数据
* @param interspersed
* @param data String
* @param index int
* @return String
* @throws HSMException
*/
public String getDecryption(String interspersed, String data, int index) throws HSMException;
/**
* 取得MAC
* @param interspersed
* @param challenge String
* @param data String
* @return String
* @throws HSMException
*/
public String getMAC(String interspersed, String data, int index) throws HSMException;
}
异常类:
ackage com.microapp.business.hsm;
/**
*
Title:
*
*
Description:
*
*
Copyright: Copyright (c) 2005
*
*
Company:
*
* @author microapp
* @version 1.0
*/
public class HSMException extends Exception
{
String message;
public HSMException()
{
}
public HSMException(String errmsg)
{
super(errmsg);
}
public HSMException(int errCode)
{
switch(errCode)
{
case 80:
message - "命令不可识别!";
break;
case 81:
message - "报文长度错误!";
break;
default:
message - "其他错误!";
}
}
}
实现文件
package com.microapp.business.hsm;
/**
*
Title:
*
*
Description:
*
*
Copyright: Copyright (c) 2005
*
*
Company:
*
* @author me
* @version 1.0
*/
import java.io.*;
import java.net.*;
public class HSM implements IHSM
{
private String address = "192.168.1.88";
private int port = 8888;
public HSM()
{
}
public HSM(String addr, int port)
{
this.address = addr;
this.port = port;
}
public void setAddress(String addr)
{
this.address = addr;
}
public String getAddress()
{
return address;
}
public void setPort(int port)
{
this.port = port;
}
public int getPort()
{
return port;
}
/**
* 加密
* @param interspersed String
* @param data String
* @param index int
* @return String
* @throws HSMException
*/
public String getEncryption(String interspersed, String data, int index) throws HSMException
{
System.out.println("Hava the data request at HSMe " + data);
int l = data.length();
if(l != 16)
{
throw new HSMException("Data length error!");
}
Socket Client;
DataInputStream InputS;
DataInputStream KeyS;
PrintStream OutputS;
byte[] sendbuf = new byte[45];
byte[] recvbuf = new byte[64];
int i = 0;
byte b1 = 0;
byte b2 = 0;
try
{
Client = new Socket(address, port);
InputS = new DataInputStream(Client.getInputStream());
OutputS = new PrintStream(Client.getOutputStream());
KeyS = new DataInputStream(System.in);
sendbuf[0] = 0; //长度(高)
sendbuf[1] = 45; //长度(低)
sendbuf[2] = (byte)0xB0; //命令代码
sendbuf[3] = 1; //密钥索引
sendbuf[4] = 24; //密钥长度
sendbuf[5] = 0; //密钥
for(i = 0; i < 24; i++)
{
sendbuf[5 + i] =(byte)(Integer.parseInt(interspersed.substring((i * 2), (i * 2) +2), 16));
}
sendbuf[6] = 0x80; //计算方式:80-加密
sendbuf[7] = 0x00; //计算数据长度(高)
sendbuf[8] = 8; //计算数据长度(低)
sendbuf[9] = 0; //计算数据
for(i = 0; i < 8; i++)
{
sendbuf[9 + i] =(byte)(Integer.parseInt(data.substring((i * 2), (i * 2) +2), 16));
}
OutputS.write(sendbuf);
l = InputS.read(recvbuf);
Client.close();
if (l < 6)
{
throw new HSMException("Return data length error." + Integer.toHexString(l));
}
if((recvbuf[3] != 0))
{
throw new HSMException("Return data error." + Integer.toHexString(recvbuf[3]).toUpperCase());
}
l = (recvbuf[4] * 256 + recvbuf[5]);
StringBuffer sb = new StringBuffer();
String s = new String();
for(i = 0; i < l; i++)
{
s = Integer.toHexString(recvbuf[i + 6]).toUpperCase();
if(s.length() == 1)
{
sb.append("0" + s);
}
else if(s.length() > 2)
{
sb.append(s.substring(s.length() - 2, s.length()));
}
else
{
sb.append(s);
}
}
return sb.toString();
}
catch(IOException e)
{
throw new HSMException("IOException Happened" + e.getMessage());
}
}
/**
* 解密
* @param interspersed String
* @param data String
* @return String
* @throws HSMException
*/
public String getDecryption(String interspersed, String data, int index) throws HSMException
{
System.out.println("Hava the data request at HSMd " + data);
int l = data.length();
if((l % 2) != 0)
{
throw new HSMException("Data length error!");
}
Socket Client;
DataInputStream InputS;
DataInputStream KeyS;
PrintStream OutputS;
byte[] sendbuf = new byte[45];
byte[] recvbuf = new byte[64];
int i = 0;
byte b1 = 0;
byte b2 = 0;
try
{
Client = new Socket(address, port);
InputS = new DataInputStream(Client.getInputStream());
OutputS = new PrintStream(Client.getOutputStream());
KeyS = new DataInputStream(System.in);
sendbuf[0] = 0; //长度(高)
sendbuf[1] = 45; //长度(低)
sendbuf[2] = (byte)0xB0; //命令代码
sendbuf[3] = 1; //密钥索引
sendbuf[4] = 24; //密钥长度
sendbuf[5] = 0; //密钥
for(i = 0; i < 24; i++)
{
sendbuf[5 + i] =(byte)(Integer.parseInt(interspersed.substring((i * 2), (i * 2) +2), 16));
}
sendbuf[6] = 0x81; //计算方式:81-解密
sendbuf[7] = 0x00; //计算数据长度(高)
sendbuf[8] = (byte)(l / 2); //计算数据长度(低)
sendbuf[9] = 0; //计算数据
for(i = 0; i < (l / 2); i++)
{
sendbuf[9 + i] =(byte)(Integer.parseInt(data.substring((i * 2), (i * 2) +2), 16));
}
OutputS.write(sendbuf);
i = InputS.read(recvbuf);
Client.close();
if(i < 6)
{
throw new HSMException("Return data length error." + Integer.toHexString(i));
}
if((recvbuf[3] != 0))
{
throw new HSMException("Return data error." + Integer.toHexString(recvbuf[3]).toUpperCase());
}
l = (recvbuf[4] * 256 + recvbuf[5]);
StringBuffer sb = new StringBuffer();
String s = new String();
for(i = 0; i < l; i++)
{
s = Integer.toHexString(recvbuf[i + 6]).toUpperCase();
if(s.length() == 1)
{
sb.append("0" + s);
}
else if(s.length() > 2)
{
sb.append(s.substring(s.length() - 2, s.length()));
}
else
{
sb.append(s);
}
}
return sb.toString();
}
catch(IOException e)
{
throw new HSMException("IOException Happened" + e.getMessage());
}
}
/**
* 获取MAC
* @param interspersed String
* @param challenge String :随机数
* @param data String :加密数据
* @return String
* @throws HSMException
*/
public String getMAC(String interspersed, String data, int index) throws HSMException
{
Socket Client;
DataInputStream InputS;
DataInputStream KeyS;
PrintStream OutputS;
byte[] sendbuf = new byte[64];
byte[] recvbuf = new byte[64];
int i = 0;
byte b1 = 0;
byte b2 = 0;
try
{
int l = data.length();
if ((l % 2) != 0)
{
throw new HSMException("Data length must be 2 times.");
}
Client = new Socket(address, port);
InputS = new DataInputStream(Client.getInputStream());
OutputS = new PrintStream(Client.getOutputStream());
KeyS = new DataInputStream(System.in);
sendbuf[0] = 0x00; //长度
sendbuf[1] = (byte) (l + 12); //长度
sendbuf[2] = (byte) 0xB0; //命令代码
sendbuf[3] = 1; //密钥索引
sendbuf[4] = 24; //密钥长度
sendbuf[5] = 0; //密钥
for(i = 0; i < 24; i++)
{
sendbuf[5 + i] =(byte)(Integer.parseInt(interspersed.substring((i * 2), (i * 2) +2), 16));
}
sendbuf[6] = 0x82; //计算方式:82-计算MAC
sendbuf[7] = 0; //计算数据长度
sendbuf[8] = (byte) i; //计算数据长度
sendbuf[9] = 0; //计算数据
for (i = 0; i < (l / 2); i++)
{
sendbuf[37 + i] =(byte)(Integer.parseInt(data.substring((i * 2), (i * 2) +2), 16));
}
OutputS.write(sendbuf);
i = InputS.read(recvbuf);
Client.close();
if (i < 6)
{
throw new HSMException("Return data length error." + Integer.toHexString(i));
}
if ( (recvbuf[3] != 0))
{
throw new HSMException("Return data error." + Integer.toHexString(recvbuf[3]).toUpperCase());
}
l = (recvbuf[4] * 256 + recvbuf[5]);
StringBuffer sb = new StringBuffer();
String s = new String();
for (i = 0; i < l; i++)
{
s = Integer.toHexString(recvbuf[i + 6]).toUpperCase();
if(s.length() == 1)
{
sb.append("0" + s);
}
else if(s.length() > 2)
{
sb.append(s.substring(s.length() - 2, s.length()));
}
else
{
sb.append(s);
}
}
return sb.toString();
}
catch (IOException e)
{
throw new HSMException("IOException Happened" + e.getMessage());
}
}
}
为在应用服务器中能够实现逻辑数据组合,我建立了一个无状态session bean.在bean主要是实现数据的打包和转换.
package com.microapp.business;
import javax.ejb.SessionBean;
import javax.ejb.SessionContext;
import javax.ejb.CreateException;
import com.vsc.ets.business.hsm.*;
import java.util.Random;
public class HSMModuleBean implements SessionBean
{
public static final int EXTERNAL_AUTHEN_KEY = 0x46;
public static final int INTERNAL_AUTHEN_KEY = 0x45;
public static final int MAC_KEY = 0x44;
public static final int GENERAL_KEY = 0x41;
SessionContext sessionContext;
IHSM hsm = new HSM("192.168.1.88", 8888);
Random rd = new Random();
String challenge;
public void ejbCreate() throws CreateException
{
}
public void ejbRemove()
{
}
public void ejbActivate()
{
}
public void ejbPassivate()
{
}
public void setSessionContext(SessionContext sessionContext)
{
this.sessionContext = sessionContext;
}
public String getMAC(String s1, String s2, String s3, String challenge,
String data)
{
try
{
String interspersed = s1 + s2 + s3;
return hsm.getMAC(interspersed, challenge, MAC_KEY);
}
catch (Exception ex)
{
return null;
}
}
public boolean internalAuthentication(String s1, String s2, String s3, String data)
{
String interspersed = s1 + s2 + s3;
try
{
String s = hsm.getDecryption(interspersed, data, INTERNAL_AUTHEN_KEY);
System.out.println("HSM internal authentication: " + s + " challenge: " + challenge);
if(s.equals(challenge))
{
return true;
}
else
{
return false;
}
}
catch(HSMException ex)
{
return false;
}
}
public String[] externalAuthentication(String s1, String s2, String s3, String data)
{
String interspersed = s1 + s2 + s3;
String[] s = new String[2];
this.challenge = "1234567887654321";
try
{
s[0] = hsm.getEncryption(interspersed, data, EXTERNAL_AUTHEN_KEY);
s[1] = this.challenge;
System.out.println("Ext: Encryption : " + s[0] + " Challenge: " + s[1]);
return s;
}
catch(HSMException ex)
{
return null;
}
}
public String provideEncryption(String interspersed, String data)
{
try
{
return hsm.getEncryption(interspersed, data, GENERAL_KEY);
}
catch (Exception ex)
{
return null;
}
}
public String provideDecryption(String interspersed, String data)
{
try
{
return hsm.getDecryption(interspersed, data, GENERAL_KEY);
}
catch (Exception ex)
{
return null;
}
}
}
该过程在实践中应用,完全与硬加密机HSM相同.
<淘宝热门商品：
来源：
程序员网
Figure1: Generic Class Association When the Counting Proxy Pattern Is Applied
下面的例子说明了如何在应用程序中利用计数代理。
例子：
让我们设计一个Order类，类层次如图2，OrderIF接口声明了getAllOrders读取数据库中所有订单的简单方法。
Figure2: Order Class Hierarchy
public interface OrderIF {
public Vector getAllOrders();
}
作为getAllOrders方法实现的一部分，Order类实用了FileUtil工具类从order.txt文件中读取订单项。
public class Order implements OrderIF {
public Vector getAllOrders() {
FileUtil fileUtil = new FileUtil();
Vector v = fileUtil.fileToVector("orders.txt");
return v;
}
}
让我们假定在调用getAllOrders()时，需要把取数据文件所花费的时间和记录条数要记录的log日志文件中。
这个附加的功能可以设计一个单独的OrderProxy类来实现，它与真实对象Order一样实现OrderIF接口。这样保证了OrderProxy对象提供给客户与真实对象Order一样的接口。如图3
Figure3: Order Class Hierarchy with the Counting Proxy
public class OrderProxy implements OrderIF {
private int counter = 0;
public Vector getAllOrders() {
Order order = new Order();
counter++;
long t1 = System.currentTimeMillis ();
Vector v = order.getAllOrders();
long t2 = System.currentTimeMillis();
long timeDiff = t2 ? t1;
String msg = "Iteration=" + counter + "::Time=" + timeDiff + "ms";
//log the message
FileUtil fileUtil = new FileUtil();
fileUtil.writeToFile("log.txt”,msg, true, true);
return v;
}
}
客户对象MainApp就想调用真实对象Order一样调用OrderProxy对象上的getAllOrders()方法，OrderProxy对象传递这个调用给真实对象Order,计算读取所有订单所花费的时间并使用FileUtil帮助类将其纪录的log日志文件中。在这个过程中，OrderProxy扮演者计数代理的角色。
public class MainApp {
public static void main(String[] args) {
OrderIF order = new OrderProxy();
Vector v = order.getAllOrders();
v = order.getAllOrders();
v = order.getAllOrders();
v = order.getAllOrders();
}
}
<淘宝热门商品：
从结构上可以看出，迭代器模式在客户与容器之间加入了迭代器角色。迭代器角色的加入，就可以很好的避免容器内部细节的暴露，而且也使得设计符号“单一职责原则”。
注意，在迭代器模式中，具体迭代器角色和具体容器角色是耦合在一起的——遍历算法是与容器的内部细节紧密相关的。为了使客户程序从与具体迭代器角色耦合的困境中脱离出来，避免具体迭代器角色的更换给客户程序带来的修改，迭代器模式抽象了具体迭代器角色，使得客户程序更具一般性和重用性。这被称为多态迭代。
三、 举例
由于迭代器模式本身的规定比较松散，所以具体实现也就五花八门。我们在此仅举一例，根本不能将实现方式一一呈现。因此在举例前，我们先来列举下迭代器模式的实现方式。
1．迭代器角色定义了遍历的接口，但是没有规定由谁来控制迭代。在Java collection的应用中，是由客户程序来控制遍历的进程，被称为外部迭代器；还有一种实现方式便是由迭代器自身来控制迭代，被称为内部迭代器。外部迭代器要比内部迭代器灵活、强大，而且内部迭代器在java语言环境中，可用性很弱。
2．在迭代器模式中没有规定谁来实现遍历算法。好像理所当然的要在迭代器角色中实现。因为既便于一个容器上使用不同的遍历算法，也便于将一种遍历算法应用于不同的容器。但是这样就破坏掉了容器的封装——容器角色就要公开自己的私有属性，在java中便意味着向其他类公开了自己的私有属性。
那我们把它放到容器角色里来实现好了。这样迭代器角色就被架空为仅仅存放一个遍历当前位置的功能。但是遍历算法便和特定的容器紧紧绑在一起了。
而在Java Collection的应用中，提供的具体迭代器角色是定义在容器角色中的内部类。这样便保护了容器的封装。但是同时容器也提供了遍历算法接口，你可以扩展自己的迭代器。
好了，我们来看下Java Collection中的迭代器是怎么实现的吧。
//迭代器角色，仅仅定义了遍历接口
public interface Iterator {
boolean hasNext();
Object next();
void remove();
}
//容器角色，这里以List为例。它也仅仅是一个接口，就不罗列出来了
//具体容器角色，便是实现了List接口的ArrayList等类。为了突出重点这里指罗列和迭代器相关的内容
//具体迭代器角色，它是以内部类的形式出来的。AbstractList是为了将各个具体容器角色的公共部分提取出来而存在的。
public abstract class AbstractList extends AbstractCollection implements List {
……
//这个便是负责创建具体迭代器角色的工厂方法
public Iterator iterator() {
return new Itr();
}
//作为内部类的具体迭代器角色
private class Itr implements Iterator {
int cursor = 0;
int lastRet = -1;
int expectedModCount = modCount;
public boolean hasNext() {
return cursor != size();
}
public Object next() {
checkForComodification();
try {
Object next = get(cursor);
lastRet = cursor++;
return next;
} catch(IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}
public void remove() {
if (lastRet == -1)
throw new IllegalStateException();
checkForComodification();
try {
AbstractList.this.remove(lastRet);
if (lastRet < cursor)
cursor--;
lastRet = -1;
expectedModCount = modCount;
} catch(IndexOutOfBoundsException e) {
throw new ConcurrentModificationException();
}
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
至于迭代器模式的使用。正如引言中所列那样，客户程序要先得到具体容器角色，然后再通过具体容器角色得到具体迭代器角色。这样便可以使用具体迭代器角色来遍历容器了……
四、 实现自己的迭代器
在实现自己的迭代器的时候，一般要操作的容器有支持的接口才可以。而且我们还要注意以下问题：
在迭代器遍历的过程中，通过该迭代器进行容器元素的增减操作是否安全呢？
在容器中存在复合对象的情况，迭代器怎样才能支持深层遍历和多种遍历呢？
以上两个问题对于不同结构的容器角色，各不相同，值得考虑。
五、 适用情况
由上面的讲述，我们可以看出迭代器模式给容器的应用带来以下好处：
1) 支持以不同的方式遍历一个容器角色。根据实现方式的不同，效果上会有差别。
2) 简化了容器的接口。但是在java Collection中为了提高可扩展性，容器还是提供了遍历的接口。
3) 对同一个容器对象，可以同时进行多个遍历。因为遍历状态是保存在每一个迭代器对象中的。
由此也能得出迭代器模式的适用范围：
1) 访问一个容器对象的内容而无需暴露它的内部表示。
2) 支持对容器对象的多种遍历。
3) 为遍历不同的容器结构提供一个统一的接口（多态迭代）。
六、 总结
迭代器模式在我们的应用中很广泛，希望本文能帮助你理解它。如有不对之处，还请不吝指正。
<淘宝热门商品：
