在Android上验证数字签名

我正在开发一个需要数字签名html文档的Android应用程序.该文档以JSON格式驻留在DB中.我正在使用我在其他一些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对象ex:

{ "data" : "", "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 lines = new ArrayList();
        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文件中是否包含？

在此先感谢所有的帮助,非常感谢.

数字签名是计算数据（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                                ....

另外，您还需要使用-signwith openssl dgst以获得正确的输出格式（请参阅openSSL rsautl和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解码，以使事情更具可读性和易用性。