保护您的 J2ME/MIDP 应用程序

基于 Java 的 Web 服务和无线 Java 开发是 JavaOne 2002 的两个最突出的主题。它们代表普及计算领域中未来的后端和前端 Java 技术。

Web 服务是基于标准 XML 通信协议的松耦合的可互操作的软件组件。Web 服务的使用使供应商能够在其核心竞争力所在的特定市场中提供服务。然后，客户可以根据其不同需要，从多个供应商选择采购服务。这种便利意味着 Web 服务完全适合于为无线前端提供服务。无线信息设备的便利和动态本质允许移动用户利用模块化的且动态可重新配置的后端服务。

Java 平台可以在无线 Web 服务应用程序开发中扮演几个重要角色。在无线端，Java 2 Micro Edition（J2ME）为所有无线设备（从蜂窝电话到复杂的家用无线信息家电）提供了跨设备的兼容性、高级语言功能和大量库。J2ME 的一个关键组件是移动信息设备框架（Mobile Information Device Profile(MIDP)），它在蜂窝电话和低端 PDA 上定义 Java API 和运行时环境。由于庞大数量的低端设备，期望在将来能够广泛部署 MIDP。

从 Web 服务端，Java 2 企业版（J2EE）已经具有所有必需的 API 和库来处理 Web 服务 XML 消息。通过 Web 服务接口或网关，可以方便地将用 EJB 技术实现的核心 J2EE 功能、JDBC API 和 RMI API 用于外部世界。为了将这些特性集合起来并启用无线 Web 服务应用程序，还提出了 J2ME Web 服务规范，目前它在 Java Community Process（JSR 172）中。

无线 Web 服务中的安全性
虽然基于 Java 的无线 Web 服务在普及移动商业世界中有一个光明的前途，但当前技术仍不成熟。安全性仍是剩下待解决的问题之一。无线通信是无线电波拦截容易获取的目标，而无线设备几 乎没有任何计算能力来支持所有通信数据的强加密。此外，在后端，Web 服务运行在企业防火墙之外并使用开放消息传递协议来彼此交互。无线 Web 服务同样是易招受各种破解攻击的目标。已开发得很好的点对点安全性技术（如 SSL/TLS 和 HTTPS）不适合于多供应商、多中间 Web 服务网络拓扑图 — 重点必需集中在保护内容本身而不是传递内容的连接上。尽管面临新挑战，然而 Web 服务本身还是能用来增强移动商业安全性。新兴的 Web 服务安全性规范的出现使您能够将 Web 服务用作安全性实用程序。

在下面的段落中，我将讨论一种常用的安全性技术：数字签名。我将向您演示如何在 XML 消息中使用数字签名来保证端对端的数据完整性。我将应用一些示例来说明如何通过在无线端上使用流行的 J2ME/MIDP 平台并在后端上使用 JavaServer Pages（JSP）技术来实现 XML 数字签名。最后，我将讨论性能问题以及在当前 MIDP 设备上使用数字签名的可行性。MIDP 编程细节不在本文范围内；如果您需要复习一下，请参阅参考资料 一节。

使用数字签名保证数据完整性
让我们假设一 下，您是一位股票交易者，当您不在交易大厅时，使用蜂窝电话来跟踪股票价格变化。在上下班途中，您的电话提醒您正在监视的一只股票的价格已经跌入您的心理 最低价。现在，您应根据此提示买进它并利用此低价来赚一笔吗？在您采取任何行动之前，您必须绝对确保提示本身是可信的。如果竞争者可能拦截并更改消息（例 如，更改股票代码），那么他就可能引诱您买进弄错的股票，并将他的高价位股票抛给您。您如何知道消息在从监视服务到您电话的途中没有被篡改呢？

数据完整性确实是通信安全性的最重要方面之一。物理上安全的网络十分昂贵，而且并不覆盖范围很广的地理区域。如果您的业务必须依靠因特网才能通信， 那么您必须面对因特网本身几乎不提供安全性这一事实。因特网数据包在到达其目的地之前必须途经由非对话双方控制的多个路由器和主机。数据通信在无线因特网 上特别容易受到攻击。

及时出现的援救工具是公钥基础设施（PKI）和数字签名。（和 MIDP 编程一样，数字签名不在本文范围内；感兴趣的读者可以参考参考资料 一 节来获取更多信息。）概括地说，在 PKI 数字签名模式中，每一方都有两个密码术密钥：公钥，任何人都可以使用它，而私钥，是保密的，只有某个人本身可以使用。用私钥加密的消息只能由相应的公钥正 确解密。当发送方发送消息时，他可以将相同消息的私钥加密版以及他的公钥与该消息一起发送。接收方使用发送方的公钥来解密加密版本。如果它与明文消息匹 配，那么接收方可以知道该消息确实可信。该消息的私钥加密版用作完整性验证记号，我们将它称为“数字签名”。

因为原始消息可能相当长，而且生成和验证数字签名的公钥算法是资源密集的，所以发送方通常计算称为“摘要”的原始消息的短版本并且仅对该版本进行数 字形式的签署。摘要具有固定长度，它是任何长度的输入消息的单向散列；其计算速度非常快。接收方首先验证接收的消息是否产生正确摘要。如果该摘要不匹配， 则在执行任何公钥算法之前拒绝该消息。这可以有助于防止攻击造成堵塞，在这种攻击中，攻击者通过用伪造的公钥请求填斥服务器，以耗尽它的计算资源。

在大多数实际应用程序中，公钥本身由可信的权威部门进行数字签名，并成为“数字证书”来验证发送方的标识。不过，数字证书的处理不在本文范围内，所以在下列示例中，我将假设发送方是可信的并使用未签署的公钥来说明方法。

定义的 XML 数字签名
正如我早先提到的 那样，XML 正成为 Web 服务世界中一个主要的数据交换协议。驱动 Web 服务的 XML 消息在到达目的地之前，通常需要经过多个中间环节。因此，我们保护从端到端的通信内容是重要的。完成这一任务的最好方法是，将 XML 文档及其安全性信息（如签名、摘要和密钥等等）都装运在一起，作为单个文档。

XML 数字签名是将数字签名添加到 XML 文档的 W3C 规范。发送方可以选择对整个文档或者仅它的一部分进行数字签名。数字签名、摘要和公钥被格式化成 XML 元素。那些安全性信息的额外元素可以封装整个原始 XML 消息，或者可以将它们嵌入原始消息。为了方便起见，我将在本文中使用封装格式。

为了清晰起见，我在本文中使用的 XML 数字签名示例并不完全与 W3C 相符。例如，我省去了标准（XML 标记的标准化）部分，因为它仅确保 XML 文档的一致性而与安全性本身无关。另外，我将密钥分成几个参数并将那些参数传递到公钥元素 KeyInfo 下的单独 XML 元素中，以代替使用编码的公钥证书。这在密钥和处理它们的 Java 代码之间建立了更明显的连接。

处理 MIDP 应用程序中的 XML 数字签名
IBM alphaWorks 开发了一种称为 XML Security Suite 的 Java 包，它支持最新的 XML 数字签名规范。JSR 105 是标准化一组 Java API 以处理 XML 数字签名的一项社区成果。然而，它们仅作用于 Java 2 标准版（J2SE），这意味着可以在服务器端上使用 XML Security Suite 或 JSR 105 Java XML 数字签名 API，但不能在 MIDP 无线设备端上使用它们。

要处理 XML 数字签名，正在使用的无线设备需要支持下列功能：

• 对 XML 文档读写数据 。在示例 MIDP 应用程序中，kXML 解析器将 XML 文档和元素解析成 Java 对象（请参阅参考资料 ）。除了 kXML 外，还有几个可在不同许可证条款下使用的其它 MIDP XML 解析器。
  
  
• 签署消息并验证签名 。这些功能需要一个不属于当前 MIDP 1.0 规范的密码术 API。

在下一节中，我将讨论一种轻量级 Java 密码术包，您可以在服务器端和无线 MIDP 设备端上使用它来生成并验证 XML 数字签名。

Bouncy Castle Crypto API
Bouncy Castle 是一种用于 Java 平台的开放源码的轻量级密码术包。它支持大量的密码术算法，并提供 JCE 1.2.1 的实现。因为 Bouncy Castle 被设计成轻量级的，所以从 J2SE 1.4 到 J2ME（包括 MIDP）平台，它都可以运行。它是在 MIDP 上运行的唯一完整的密码术包。

不管 Bouncy Castle 包的功能有多强大，它有一个主要问题：缺少文档。不存在在线文档，其 JavaDoc 写得并不好。与许多其它高级密码术包相似，Bouncy Castle 包广泛使用类型多态性来将常规概念与实现算法分开。对于初学者来说，辨认类之间的关系以及方法参数和返回值的正确类型是很困难的。通常，开发人员必须浏览 一下源代码和测试用例来研究做事的正确方法。显然，Bouncy Castle 包的指南非常合适。

在本文的其余部分，我们将简略地论述 XML 数字签名规范以及几个不同 Bouncy Castle 密钥生成器、编码引擎、数字签名签名引擎和摘要引擎的用法。

合在一起
到目前为止，我们已经讨论了许多技术和概念。下面，我将说明完整过程：密钥生成、在服务器端签署文档、以安全的 XML 格式编码和传送文档以及在客户机端验证文档。

1. 服务器使用一组密钥模型参数生成由一个随机公钥和一个私钥组成的密钥对。在实际生产系统中，这个步骤通常不是必需的，因为密钥对通常是预先生成的并存储在服务器密钥库中。
   
   
2. 访问 JSP 页时，服务器计算响应消息的摘要。
   
   
3. 然后，JSP 页以“签署”方式调用签名引擎，并使用私钥为摘要生成数字签名。
   
   
4. 服务器将签名信息（包括摘要、数字签名本身和公钥参数）嵌入 XML 响应消息中。
   
   
5. 客户机接收 XML 文档并将摘要、数字签名和公钥参数解析成 Java 应用程序数据。
   
   
6. 客户机计算来自明文消息的摘要并将它与服务器的摘要进行比较。如果两个摘要不匹配，则文档验证失败；如果它们匹配，则转至下一步。
   
   
7. 客户机使用嵌入的密钥参数重新构造公钥。
   
   
8. 客户机以“验证”方式调用签名引擎，并传递摘要、签名和公钥来验证签名。

在接下来的几节中，我们将遵循这些步骤来实现几个示例。因为我们的示例在服务器端和客户机端使用相同的 Bouncy Castle Crypto API，所以很容易更改它们以在无线设备上签署消息并在服务器端验证它。

处理摘要
正如我早先提到的那样，为了改进性能并避免攻击造成堵塞，您实际上签署的是消息摘要而不是消息本身。清单 1 说明了如何使用 SHA1Digest 摘要引擎来计算来自一段文本消息的已编码的摘要。

清单 1. 创建已编码的摘要

static public String getDigest( String mesg ) throws Exception {
 
  SHA1Digest digEng = new SHA1Digest();
  byte [] mesgBytes = mesg.getBytes();
  digEng.update( mesgBytes, 0, mesgBytes.length );
  byte [] digest = new byte[digEng.getDigestSize()];
  digEng.doFinal(digest, 0);
  // Encode the digest into ASCII format for XML
  return (new String(Base64.encode(digest)));
}

在下几节中，我们将了解如何使用 Bouncy Castle 的 DSA、ECC 和 RSA 签名引擎来签署并验证数字签名。那些签名引擎使用不同的算法和不同的密钥，并且需要不同的参数。我们还将讨论如何将安全性信息（签名、摘要和公钥）嵌入 XML 文档。最后，我将比较三个签名引擎并提出今后的改进建议。

DSA 签名示例
方法 DSASigUtil.generateKeys() 生成密钥对。正如我讨论过的那样，这个步骤通常由中央认证中心在脱机状态下完成，如清单 2 所示：

清单 2. 生成密钥对

// Get a secure random source.
SecureRandom sr = new SecureRandom();
 
// Generate DSA parameters.
DSAParametersGenerator DSAParaGen = new DSAParametersGenerator();
DSAParaGen.init(1024, 80, sr);
 
DSAPara = DSAParaGen.generateParameters();
 
// Get DSA key generation parameters.
DSAKeyGenerationParameters DSAKeyGenPara = 
          new DSAKeyGenerationParameters(sr, DSAPara);
 
// Generate keys.
DSAKeyPairGenerator DSAKeyPairGen = new DSAKeyPairGenerator();
DSAKeyPairGen.init( DSAKeyGenPara );
AsymmetricCipherKeyPair keyPair = DSAKeyPairGen.generateKeyPair();
 
privKey = (DSAPrivateKeyParameters) keyPair.getPrivate();
pubKey = (DSAPublicKeyParameters) keyPair.getPublic();

生成的公钥以参数 Y 来描述，并且用 pubKey.getY() 方法来检索它。参数 G 、P 和 Q 描述模型。类 DSAUtil 中的下列方法检索模型和密钥参数，它们是重新构造公钥对象所必需的：

清单 3. 检索模型和密钥参数

public static String getG() throws Exception {
  return (new String(Base64.encode(DSAPara.getG().toByteArray())));
}
public static String getP() throws Exception {
  return (new String(Base64.encode(DSAPara.getP().toByteArray())));
}
public static String getQ() throws Exception {
  return (new String(Base64.encode(DSAPara.getQ().toByteArray())));
}
public static String getY() throws Exception {
  return (new String(Base64.encode(pubKey.getY().toByteArray())));
}

通过使用生成的私钥，实用程序类 DSASigUtil 可以从摘要获取两部分 DSA 签名 R 和 S ：

清单 4. 检索 DSA 签名

static public String [] getSignature (String digest) throws Exception {
  // Sign
  DSASigner signer = new DSASigner();
  signer.init( true, privKey );
  BigInteger [] sigArray = signer.generateSignature( digest.getBytes());
 
  String [] result = new String [2];
  // Signature R
  result[0] = new String(Base64.encode(sigArray[0].toByteArray()));
  // Signature S
  result[1] = new String(Base64.encode(sigArray[1].toByteArray()));
 
  return result;
}

服务器将摘要、签名和密钥参数编码成 ASCII 文本格式并以 XML 数字签名格式嵌入该文本，如清单 5 所示：

清单 5. 编码并以数字签名格式嵌入

<SignedMesg>
  <mesg>Hello World</mesg>
  <Signature>
    <SignedInfo>
      <SignatureMethod 
        Algorithm="http://www.w3.org/2000/09/xmldsig#dsa-sha1" />
      <DigestValue>Ck1VqNd45QIvq3AZd8XYQLvEhtA=</DigestValue>
    </SignedInfo>
    <SignatureValue>
      <R>AMfVKyIUyPGdeUCtJxU+N9kQJc2x</R>
      <S>RwGahqpopPx//bMYXzH8dtY0lhA=</S>
    </SignatureValue>
    <KeyInfo>
      <KeyValue>
        <DSAKeyValue>
          <G>
            FgLTXVdxKAmDQtQHkDdFF5zthKSpQhUCzRgXxz7yzxM
            OLYrRoj5D8AXdGLS+5CzT4gu55MbO62dBfyEWKbWTIO
            6E+CuOfa53wvqjMl67tGxc8szgWWA6ZvRwVVVmJ6wqB
            m5hNLr7q1X2eJKQ+u3XYpFflJktOjV8O3zeEPOtsTQ=
          </G>
          <P>
            AOAu2WqVEKGTF8Zcxgde4vxc8f/Z+hk8A10M0AtY2lU
            8CX54dz2MuD6hOmhqGXJxIVlV9085d9D0yHcMv2wl9V
            Vt0/ww+aqFukCKZj9fHgZzq26nOBXMqibDo67J2vfQw
            EZMvCnyBXdS665whjzl5i7ubXu2Su+AqsodnvG9pyYB
          </P>
          <Q>AMjJUZy1RnQRqe/22BS83k2Hk8VR</Q>
          <Y>
            AM/9leouAW7nyON24xeqibMUpVOW8RyzcdNjp9NiPdfm
            HT42BvB4JL/cXx0tCbyHtcR5G+vALoOo7Mh3JJ+/gjx7
            sS8uHNngqx6O6dADrc9VdPvyllNDR0szLja1RTRCIy9M
            8p0dKe/U8iotAj2zctjfbrroMu/fTOBhkvb2gVvR
        </Y>
        </DSAKeyValue>
      </KeyValue>
    </KeyInfo>
  </Signature>
</SignedMesg>

验证 MIDP 应用程序从 XML 文档解析出摘要、密钥参数和签名，重新构造公钥并使用下列方法来验证签名：

清单 6. 验证签名

static public boolean verify (String digest,
                              String sig_r, String sig_s,
                              String key_g, String key_p,
                              String key_q, String key_y ) {
 
  BigInteger g = new BigInteger( Base64.decode(key_g) );
  BigInteger p = new BigInteger( Base64.decode(key_p) );
  BigInteger q = new BigInteger( Base64.decode(key_q) );
  BigInteger y = new BigInteger( Base64.decode(key_y) );
  BigInteger r = new BigInteger( Base64.decode(sig_r) );
  BigInteger s = new BigInteger( Base64.decode(sig_s) );
 
  DSAParameters DSAPara = new DSAParameters(p, q, g);
  DSAPublicKeyParameters DSAPubKeyPara = new DSAPublicKeyParameters(y,
                                             DSAPara);
 
  // Verify
  DSASigner signer = new DSASigner();
  signer.init( false, DSAPubKeyPara );
  boolean result = signer.verifySignature( digest.getBytes(), r, s );
  return result;
}

椭圆曲线 DSA 签名示例
在 ECDSASigUtil 类中，首先定义您计划使用的椭圆曲线模型，如清单 7 所示：

清单 7. 定义椭圆曲线模型

  private static BigInteger q = new
BigInteger("6277101735386680763835789423207666416083908700390324961279");
  private static BigInteger a = new
BigInteger("fffffffffffffffffffffffffffffffefffffffffffffffc", 16);
  private static BigInteger b = new
BigInteger("64210519e59c80e70fa7e9ab72243049feb8deecc146b9b1", 16);
  private static BigInteger n = new
BigInteger("6277101735386680763835789423176059013767194773182842284081");
  private static byte [] G =
Hex.decode("03188da80eb03090f67cbf20eb43a18800f4ff0afd82ff1012");

ECDSASigUtil.generateKeys() 方法使用清单 7 中的模型生成随机的密钥对。正如前面提到的那样，这个步骤通常由中央认证中心在脱机状态下完成。

清单 8. 使用清单 7 中的模型生成随机的密钥对

// Get a secure random source.
SecureRandom sr = new SecureRandom();
 
ECCurve.Fp curve = new ECCurve.Fp(q, a, b);
ECDomainParameters ECDomPara = new ECDomainParameters(curve,
                                                      curve.decodePoint(G),
                                                      n );
ECKeyGenerationParameters ECKeyGenPara = 
                new ECKeyGenerationParameters(ECDomPara, sr);
ECKeyPairGenerator ECKeyPairGen = new ECKeyPairGenerator();
ECKeyPairGen.init( ECKeyGenPara );
AsymmetricCipherKeyPair keyPair = ECKeyPairGen.generateKeyPair();
 
privKey = (ECPrivateKeyParameters) keyPair.getPrivate();
pubKey = (ECPublicKeyParameters) keyPair.getPublic();

公钥以参数 Q 来描述，并且用 pubKey.getQ() 方法来检索它。为了避免与模型参数 q 产生混淆，在方法中使用 QQ ，XML 元素名使用大写的 Q 。清单 9 显示了 ECDSAUtil 类中的方法。这些方法检索模型和密钥参数，它们是重新构造公钥对象所必需的。

清单 9. 用于检索模型和密钥参数的 ECDSAUtil 方法

// public key specific field
public static String getQQ() throws Exception {
  return (new String(Base64.encode(pubKey.getQ().getEncoded())));
}
// Key parameter fields. Could also be retrieved from pubKey.
public static String getQ() throws Exception {
  return (new String(Base64.encode(q.toByteArray())));
}
public static String getA() throws Exception {
  return (new String(Base64.encode(a.toByteArray())));
}
public static String getB() throws Exception {
  return (new String(Base64.encode(b.toByteArray())));
}
public static String getN() throws Exception {
  return (new String(Base64.encode(n.toByteArray())));
}
public static String getG() throws Exception {
  return (new String(Base64.encode(G)));
}

通过使用生成的私钥，实用程序类 ECDSASigUtil 可以从摘要获取两部分 DSA 签名 R 和 S ：

清单 10. 检索 DSA 签名

static public String [] getSignature (String digest) throws Exception {
  // Sign
  ECDSASigner signer = new ECDSASigner();
  signer.init( true, privKey );
  BigInteger [] sigArray = signer.generateSignature( digest.getBytes());
 
  String [] result = new String [2];
  // Signature R
  result[0] = new String(Base64.encode(sigArray[0].toByteArray()));
  // Signature S
  result[1] = new String(Base64.encode(sigArray[1].toByteArray()));
 
  return result;
}

服务器将摘要、签名和密钥参数编码成 ASCII 文本格式并以 XML 数字签名格式嵌入该文本。和检索方法名中一样，公钥参数 Q 被记录为 QQ ，以将它与相应 XML 元素中的密钥参数 q 区分开来，如清单 11 所示：

清单 11. 编码并以数字签名格式嵌入

<SignedMesg>
  <mesg>Hello World</mesg>
  <Signature>
    <SignedInfo>
      <SignatureMethod 
        Algorithm="http://www.w3.org/2000/09/xmldsig#dsa-sha1" />
      <DigestValue>Ck1VqNd45QIvq3AZd8XYQLvEhtA=</DigestValue>
    </SignedInfo>
    <SignatureValue>
      <R>NK/EIL2lrbFFCThnEuYlUWzh6IEfMsts</R>
      <S>AMeJDecKWrQO6Eeehl3het+FlDDL4IedCA==</S>
    </SignatureValue>
    <KeyInfo>
      <KeyValue>
        <ECKeyValue>
          <QQ>AwCiF5uG+DII/x1XTq84fLm4eGN2fED1PYc=</QQ>
          <Q>AP////////////////////7//////////w==</Q>
          <A>AP////////////////////7//////////A==</A>
          <B>ZCEFGeWcgOcPp+mrciQwSf643uzBRrmx</B>
          <N>AP///////////////5ne+DYUa8mxtNIoMQ==</N>
          <G>AxiNqA6wMJD2fL8g60OhiAD0/wr9gv8QEg==</G>
        </ECKeyValue>
      </KeyValue>
    </KeyInfo>
  </Signature>
</SignedMesg>

验证 MIDP 应用程序从 XML 文档解析出摘要、密钥参数和签名，重新构造公钥并使用清单 12 中显示的方法来验证签名：

清单 12. 验证签名

static public boolean verify (String digest,
                              String sig_r, String sig_s,
                              String key_q, String key_a,
                              String key_b, String key_n,
                              String key_G, String key_Q ) {
 
  BigInteger q = new BigInteger( Base64.decode(key_q) );
  BigInteger a = new BigInteger( Base64.decode(key_a) );
  BigInteger b = new BigInteger( Base64.decode(key_b) );
  BigInteger n = new BigInteger( Base64.decode(key_n) );
 
  byte [] G = Base64.decode(key_G);
  byte [] Q = Base64.decode(key_Q);
 
  BigInteger r = new BigInteger( Base64.decode(sig_r) );
  BigInteger s = new BigInteger( Base64.decode(sig_s) );
 
  ECCurve.Fp curve = new ECCurve.Fp(q, a, b);
  ECDomainParameters ECDomPara = new ECDomainParameters(
                 curve, curve.decodePoint(G), n );
  ECPublicKeyParameters pubKey = new ECPublicKeyParameters(
                 curve.decodePoint(Q), ECDomPara );

  // Verify
  ECDSASigner signer = new ECDSASigner();
  signer.init( false, pubKey );
  boolean result = signer.verifySignature( digest.getBytes(), r, s );
  return result;
}

RSA 签名示例
RSA 算法只有一个模型参数 Exponent ：

private static BigInteger pubExp = new BigInteger("11", 16);

RSASigUtil.generateKeys() 方法使用 Exponent 生成随机的密钥对。同样，这个步骤通常由中央认证中心在脱机状态下完成。

清单 13. 生成随机的密钥对

SecureRandom sr = new SecureRandom();
RSAKeyGenerationParameters RSAKeyGenPara = 
       new RSAKeyGenerationParameters(pubExp, sr, 1024, 80);
RSAKeyPairGenerator RSAKeyPairGen = new RSAKeyPairGenerator();
RSAKeyPairGen.init(RSAKeyGenPara);
AsymmetricCipherKeyPair keyPair = RSAKeyPairGen.generateKeyPair();
 
privKey = (RSAPrivateCrtKeyParameters) keyPair.getPrivate();
pubKey = (RSAKeyParameters) keyPair.getPublic();

公钥以参数 Modulus 来描述，并且用 pubKey.getModulus() 方法来检索它。清单 14 显示了 RSAUtil 类中的方法。这些方法检索 Exponent 和 Modulus 、模型以及密钥参数，它们是重新构造公钥对象所必需的。

清单 14. 用于检索模型和密钥参数的 RSAUtil 方法

// Public key specific parameter.
public static String getMod() throws Exception {
  return (new String(Base64.encode(pubKey.getModulus().toByteArray())));
}
// General key parameter. pubExp is the same as pubKey.getExponent()
public static String getPubExp() throws Exception {
  return (new String(Base64.encode(pubExp.toByteArray())));
}

通过使用生成的私钥，实用程序类 RSASigUtil 可以从摘要获取一个字节数组 RSA 签名：

清单 15. 获取字节数组 RSA 签名

static public String getSignature (String mesg) throws Exception {
  SHA1Digest digEng = new SHA1Digest();
  RSAEngine rsaEng = new RSAEngine();
 
  PSSSigner signer = new PSSSigner(rsaEng, digEng, 64);
  signer.init(true, privKey);
 
  byte [] sig = signer.generateSignature( mesg.getBytes() );
  String result = new String( Base64.encode(sig) );
  return result;
}

服务器将摘要、签名和密钥参数编码成 ASCII 文本格式并以 XML 数字签名格式嵌入该文本：

清单 16. 编码并以数字签名格式嵌入

<SignedMesg>
  <mesg>Hello World</mesg>
  <Signature>
    <SignedInfo>
      <SignatureMethod Algorithm="rsa-sha1" />
      <DigestValue>Ck1VqNd45QIvq3AZd8XYQLvEhtA=</DigestValue>
    </SignedInfo>
    <SignatureValue>
      IhJ/UMitJX7sWbzhnG8UKIdDYiZ0mfOUoAwemGiG08C
      WcQ3cUszgJXoIclHW/LN7w54w2FQyLStB+hPKASEC6r
      OjjgTBs6pwhjHCh2XxWx7hS7fdi9/Qk/ybH6xYGaeaZ
      3oHDBjFz3hEDtrvBYcHn3keCavncE22idRX7kBl8Do=
    </SignatureValue>
    <KeyInfo>
      <KeyValue>
        <RSAKeyValue>
          <Modulus>
            AKT1SyxSm4uT1zYWEPY9IaFY7vDhpkIM7FZeIQ
            OGnKeSEE5d3sPfONkCiHfO2oe4x6jNCXg/ngRi
            tmixBkjfKgHzF4trZZtNQZjfzAgcXGljzp9MD2
            ZEWQbHKvMZvZyJVrT2SlxLzusxWLwXdacprIDG
            bqDAmldBOBpkmrUdPpF9
          </Modulus>
          <Exponent>EQ==</Exponent>
        </RSAKeyValue>
      </KeyValue>
    </KeyInfo>
  </Signature>
</SignedMesg>

验证 MIDP 应用程序从 XML 文档解析出摘要、密钥参数和签名，重新构造公钥并使用下列方法来验证签名：

清单 17. 验证签名

static public boolean verify (String mesg, String signature,
                              String mod, String pubExp) {
 
  BigInteger modulus = new BigInteger( Base64.decode(mod) );
  BigInteger exponent = new BigInteger( Base64.decode(pubExp) );
 
  SHA1Digest digEng = new SHA1Digest();
  RSAEngine rsaEng = new RSAEngine();
 
  RSAKeyParameters pubKey = new RSAKeyParameters(false, modulus, exponent);
 
  PSSSigner signer = new PSSSigner(rsaEng, digEng, 64);
  signer.init(false, pubKey);

  boolean res = signer.verifySignature( mesg.getBytes(),
                                        Base64.decode(signature) );
  return res;
}

性能问题
我的测试说明了无线设备上的 XML 解析和摘要生成都非常快。正如预料的那样，主要的性能瓶颈是公钥算法的速度很慢。

Bouncy Castle Crypto 包提供几个使用 DSA、RSA 和 ECC 算法的签名引擎类来签署和验证消息。但在实际设备中，它们并不都是实用的。因为 Bouncy Castle Crypto 包完全基于Java 语言，所以它在没有特殊优化的情况下依靠很慢的 JVM 来执行甚至是最密集的大整数数学运算。

结果，只有 RSA 算法提供了一个合理的性能，而且是勉强接受的。它只要花一分多钟就可以在 16MHz Palm VII 设备上验证具有 1024 位公钥的简单数字签名。通过选择较弱的密钥可以改进性能。但虽然如此，验证进程在任何实际的应用程序中还是必须作为后台线程运行，以避免用户界面锁定。

DSA 和 ECC 算法性能在其当前实现中是完全不可接受的。具有 1024 位密钥的 DSA 签名和具有 192 位密钥的 ECC 签名要花一个多小时在标准的 Palm VII MIDP 上进行验证。

性能问题强烈暗示我们需要为大整数数学运算和公钥算法对 JVM 进行优化。JVM 还必须利用可用的特殊硬件和底层的 OS 功能来促进与安全性相关的数学运算。公钥算法用于安全连接（如 HTTPS）中的信息交换。许多当前的 MIDP VM 可以用合理的性能来支持 HTTPS 协议。MIDP4Palm VM 可以利用 Palm OS 的底层的 inethttps 协议来建立安全连接。可以想象未来的 VM 和核心语言库不仅优化与安全连接相关的公钥操作，而且还使优化可用于一般安全性功能（如数字签名）。

结束语

在本文中，您学习了安全性 在无线 Web 服务中的重要性并说明了在无线和 Web 服务端处理 XML 数字签名的技巧。我使用了 Bouncy Castle Java 密码术包的纯 Java 实现来处理数字签名。在 Bouncy Castle 提供的所有算法中，只有 RSA 算法提供了无线设备上可勉强接受的性能。然而，未来在 MIDP 运行时环境上的进步可以使数字签名更易于移动用户使用。

<!---->

<noscript src="http://media.yesky.com/adjs/column/yesky-inner-js-1.js"></noscript>