在 Android 上验证数字签名答案

【问题标题】：Verify Digital Signature on Android在 Android 上验证数字签名
【发布时间】：2015-12-03 13:11:05
【问题描述】：

我正在开发一个需要对 html 文档进行数字签名的 Android 应用程序。该文档以 JSON 形式驻留在数据库中。我正在使用我在其他一些 SO 问题上找到的 BASH 脚本在本地签署文档：

openssl dgst -sha1 someHTMLDoc.html > hash openssl rsautl -sign -inkey privateKey.pem -keyform PEM -in hash > signature.bin

私钥是使用生成的：

openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:2048 -pkeyopt rsa_keygen_pubexp:3 -out privateKey.pem

公钥是使用生成的：

openssl pkey -in privateKey.pem -out publicKey.pem -pubout

我想在应用程序中验证 Signature.bin 中创建的签名以及 someHTMLDoc.html 中的数据。

我将 html 和签名都作为 JSON 对象发送：

{ "data" : "<html><body></body></html>", "signature":"6598 13a9 b12b 21a9 ..... " }

android 应用程序将 PublicKey 保存在共享首选项中，如下所示：

-----BEGIN PUBLIC KEY----- MIIBIDANBgkqhkiG9w0AAAEFAAOCAQ0AvniCAKCAQEAvni/NSEX3Rhx91HkJl85 \nx1noyYET ......

注意其中的 "\n"（换行符）（在将字符串从 publicKey.pem 复制到 Android Gradle Config 时自动添加。

好的，经过所有准备，现在是问题所在。我正在尝试验证密钥，但没有成功。

我正在使用以下代码：

private boolean verifySignature(String data, String signature) {
    InputStream is = null;
    try {
        is = new ByteArrayInputStream(Config.getDogbarPublic().getBytes("UTF-8")); //Read DogBar Public key

        BufferedReader br = new BufferedReader(new InputStreamReader(is));
        List<String> lines = new ArrayList<String>();
        String line;
        while ((line = br.readLine()) != null)
            lines.add(line);

        // removes the first and last lines of the file (comments)
        if (lines.size() > 1 && lines.get(0).startsWith("-----") && lines.get(lines.size() - 1).startsWith("-----")) {
            lines.remove(0);
            lines.remove(lines.size() - 1);
        }

        // concats the remaining lines to a single String
        StringBuilder sb = new StringBuilder();
        for (String aLine : lines)
            sb.append(aLine);
        String key = sb.toString();

        byte[] keyBytes = Base64.decode(key.getBytes("utf-8"), Base64.DEFAULT);
        X509EncodedKeySpec spec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey = keyFactory.generatePublic(spec);

        Signature signCheck = Signature.getInstance("SHA1withRSA"); //Instantiate signature checker object.
        signCheck.initVerify(publicKey);
        signCheck.update(data.getBytes());
        return signCheck.verify(signature.getBytes()); //verify signature with public key
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

谁能帮忙？我究竟做错了什么？

我错过了一些字节转换吗？也许 JSON 对象正在影响签名？

签名应该包含原始文件包含的 \n（换行符）还是 JSON 文件中不应该包含？

提前感谢所有帮助，非常感谢。

【问题讨论】：

我一直在尝试不同的方法，但没有成功，尝试从 JSON 对象中删除换行符，尝试 getBytes("ASCII") 和 getBytes("UTF-8")。
你有什么异常吗？哪一个？
我没有收到任何异常，它只是为signCheck.verify()返回False

标签： java android json digital-signature

【解决方案1】：

数字签名是计算数据（C）的摘要（函数H）并用非对称加密算法（函数E）对其进行加密以产生密文（S）的过程：

S = E(H(C))

签名验证将签名解密给定的签名（函数 D）——仅当解密中使用的公钥与加密中使用的私钥配对时才会产生 H(C)，并计算数据摘要以检查是否两个摘要匹配：

H(C) == D(E(H(C)))

从这里可以清楚地看出，给哈希函数 (C) 的字节必须完全相同才能使签名生效。

在您的情况下，它们不是，因为当您使用 openssl dgst 计算摘要时，输出（右侧的 H(C)）实际上类似于：

SHA1(someHTMLDoc.html)= 22596363b3de40b06f981fb85d82312e8c0ed511

这是 RSA 加密的输入。

当您验证签名时，摘要的输出（左侧的 H(C)）是原始字节，例如十六进制：

22596363b3de40b06f981fb85d82312e8c0ed511

所以你最终会加密字节以产生（右侧的 H(C)）：

0000000: 5348 4131 2873 6f6d 6548 746d 6c44 6f63  SHA1(someHtmlDoc
0000010: 2e68 746d 6c29 3d20 3232 3539 3633 3633  .html)= 22596363
0000020: 6233 6465 3430 6230 3666 3938 3166 6238  b3de40b06f981fb8
0000030: 3564 3832 3331 3265 3863 3065 6435 3131  5d82312e8c0ed511
0000040: 0a                                       .

并与字节比较（左侧的 H(C)）：

0000000: 2259 6363 b3de 40b0 6f98 1fb8 5d82 312e  "Ycc..@.o...].1.
0000010: 8c0e d511                                ....

您还需要将-sign 与openssl dgst 一起使用才能获得正确的输出格式（请参阅Difference between openSSL rsautl and dgst）。

所以在 OpenSSL 方面做：

openssl dgst -sha1 -sign privateKey.pem someHTMLDoc.html > signature.bin

在 Java 方面做：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.security.KeyFactory;
import java.security.Signature;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.X509EncodedKeySpec;

import org.spongycastle.util.io.pem.PemObject;
import org.spongycastle.util.io.pem.PemReader;

public class VerifySignature {
    public static void main(final String[] args) throws Exception {
        try (PemReader reader = publicKeyReader(); InputStream data = data(); InputStream signatureData = signature()) {
            final PemObject publicKeyPem = reader.readPemObject();
            final byte[] publicKeyBytes = publicKeyPem.getContent();
            final KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            final X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(publicKeyBytes);
            final RSAPublicKey publicKey = (RSAPublicKey) keyFactory.generatePublic(publicKeySpec);

            final Signature signature = Signature.getInstance("SHA1withRSA");
            signature.initVerify(publicKey);

            final byte[] buffy = new byte[16 * 1024];
            int read = -1;
            while ((read = data.read(buffy)) != -1) {
                signature.update(buffy, 0, read);
            }

            final byte[] signatureBytes = new byte[publicKey.getModulus().bitLength() / 8];
            signatureData.read(signatureBytes);

            System.out.println(signature.verify(signatureBytes));
        }
    }

    private static InputStream data() throws FileNotFoundException {
        return new FileInputStream("someHTMLDoc.html");
    }

    private static PemReader publicKeyReader() throws FileNotFoundException {
        return new PemReader(new InputStreamReader(new FileInputStream("publicKey.pem")));
    }

    private static InputStream signature() throws FileNotFoundException {
        return new FileInputStream("signature.bin");
    }
}

我已使用Spongy Castle 对公钥进行 PEM 解码，以使内容更具可读性和更易于使用。

【讨论】：

我不确定我是否完全理解......你应该如何进行加密？我应该只使用 dgst 函数的22596363b3de40b06f981fb85d82312e8c0ed511 部分并用它签名吗？你能解释一下我应该做什么而不是我犯了什么错误吗？我很难理解如何处理所写的内容。
查看我编辑的答案，您应该使用 openssl dgst 和 -sign 选项来生成 JCE 中的签名实现所需的二进制输出。
给这个人一块饼干！你先生是个天才！非常感谢。
将在 19 小时内奖励您。再次非常感谢。

【解决方案2】：

如果您有一个数字签名的 XML 文件（从 Web 下载）和一个证书（.cer 文件），并且您想在 Android 应用程序中验证数字签名，那么代码如下：

你需要两个东西 xmlFilePath 和 certificateFilePath

boolean verifySignature() {
        boolean valid = false;
        try {

            File file = new File("xmlFilePath");
            DocumentBuilderFactory f = DocumentBuilderFactory.newInstance();
            f.setNamespaceAware(true);
            Document doc = f.newDocumentBuilder().parse(file);

            NodeList nodes = doc.getElementsByTagNameNS(Constants.SignatureSpecNS, "Signature");
            if (nodes.getLength() == 0) {
                throw new Exception("Signature NOT found!");
            }

            Element sigElement = (Element) nodes.item(0);
            XMLSignature signature = new XMLSignature(sigElement, "");


            CertificateFactory cf = CertificateFactory.getInstance("X.509");
            InputStream ims = new InputStream("certificateFilePath");
            X509Certificate cert = (X509Certificate) cf.generateCertificate(ims);

            if (cert == null) {
                PublicKey pk = signature.getKeyInfo().getPublicKey();
                if (pk == null) {
                    throw new Exception("Did not find Certificate or Public Key");
                }
                valid = signature.checkSignatureValue(pk);
            } else {
                valid = signature.checkSignatureValue(cert);
            }
        } catch (Exception e) {
            e.printStackTrace();
            Toast.makeText(this, "Failed signature " + e.getMessage(), Toast.LENGTH_SHORT).show();
        }

        return valid;
    }

如果您想在 java 中而不是在 android studio 中进行。代码如下：

public static boolean isXmlDigitalSignatureValid(String signedXmlFilePath,
                                                     String pubicKeyFilePath) throws Exception {

        boolean validFlag;
        File file = new File(signedXmlFilePath);
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        dbf.setNamespaceAware(true);
        DocumentBuilder db = dbf.newDocumentBuilder();
        Document doc = db.parse(file);
        doc.getDocumentElement().normalize();
        NodeList nl = doc.getElementsByTagNameNS(XMLSignature.XMLNS, "Signature");
        if (nl.getLength() == 0) {
            throw new Exception("No XML Digital Signature Found, document is discarded");
        }
        FileInputStream fileInputStream = new FileInputStream(pubicKeyFilePath);
        CertificateFactory cf = CertificateFactory.getInstance("X.509");
        X509Certificate cert = (X509Certificate) cf.generateCertificate(fileInputStream);
        PublicKey publicKey = cert.getPublicKey();
        DOMValidateContext valContext = new DOMValidateContext(publicKey, nl.item(0));
        XMLSignatureFactory fac = XMLSignatureFactory.getInstance("DOM");
        XMLSignature signature = fac.unmarshalXMLSignature(valContext);
        validFlag = signature.validate(valContext);
        return validFlag;

    }

原因是如果你在android studio中使用相同的代码，你需要添加依赖，有时也会混淆。

如果您对阅读数字签名文档感兴趣，可以阅读www.xml.com/post，这是一份有趣的文档，可以帮助您了解数字签名的必要性。

【讨论】：