De vérifier une signature avec château gonflable

J'ai hérité d'un code en utilisant le obsolète bouncycastle API. Avant de le mettre à jour vers la nouvelle API, je voulais écrire un test pour vérifier que je n'ai pas changer son comportement. Cependant, je ne peut pas travailler de la bonne façon de vérifier cette signature qui est généré. Le code à changé, c'est:

public static byte[] createSignedData(byte[] content, X509Certificate cert, PrivateKey key)
        throws NoSuchAlgorithmException, NoSuchProviderException, CMSException, IOException {

    //set up the generator
    CMSSignedDataGenerator gen = new CMSSignedDataGenerator();

    gen.addSigner(key, cert, CMSSignedGenerator.DIGEST_SHA1);

    //create the signed-data object
    CMSProcessable data = new CMSProcessableByteArray(content);
    CMSSignedData signed = gen.generate(data, BC_PROVIDER);

    return signed.getEncoded();
}

Ce qui est retournée à partir de ce code? Une signature détachée?
J'ai essayé de vérifier la signature avec un petit morceau de code comme ça, mais il renvoie toujours false:

Signature signer = Signature.getInstance(
                              "SHA1withRSA", 
                              BouncyCastleProvider.PROVIDER_NAME);
signer.initVerify(cert.getPublicKey());
signer.update(data);
return signer.verify(sig);
InformationsquelleAutor Gary Barker | 2014-06-27
  1. 2

    Il sera de retour une détaché signature si vous utilisez:

    gen.generate(data, false);

    Sinon il sera de retour signé les données encapsulées dans la signature. Donc, si votre signature est détachée (qui n'est pas votre cas) pour le vérifier, il vous sera nécessaire de créer un nouveau CMSSignedData objet à partir de votre signée octets de données ou Base64 enconded string et aussi une copie de l'original des données, aussi bien dans le constructeur.

    Je pense que vous n'êtes pas à la vérification de votre signature le droit chemin, aussi je ne sais pas qui bouncycastle version de bibliothèque sont que vous utilisez et que vous venez de fournir un extrait de code qui est trop vague pour analyser.

    C'est ce que j'ai fait pour signer et vérifier une signature à l'aide de bcmail-jdk16-1.46.jar, bcprov-jdk16-1.46.jar et jdk1.6.0_45 (je suis en supposant que vous utilisez Java depuis que vous avez jamais précisé, ce qui est également question tags - mais j'espère que .NET version est très similaire).

    Vous pouvez télécharger le keystore utilisé dans mon exemple à: https://dl.dropboxusercontent.com/u/15208254/keys/certificates.p12

    Aussi, si vous voulez vérifier si la vérification de la signature fonctionne bien, vous pouvez modifier le certificat (depuis que je suis la vérification par rapport à mon propre certificat qui n'a pas de sens) en changeant cette ligne dans le processus de vérification de signature, la ligne 84:

    if (signer.verify(new JcaSimpleSignerInfoVerifierBuilder().setProvider(BC_PROVIDER).build(certFromSignedData))) { ... }

    Et puis le chargement d'un autre keystore pour obtenir un autre certificat d'elle. Juste pour savoir, le certificats.p12 dossier, je suis en utilisant, contient deux certificats avec alias Key1 et Key2 de sorte que vous pouvez jouer avec eux par la signature de votre contenu avec Key1 et la vérification de votre signature avec Key2 par exemple.

    e.g:

    //Load 'Key2' certificate from 'certificates.p12' at any place on this class after 'ks' declaration
X509Certificate certFromKeystore2 = (X509Certificate) ks.getCertificate("Key2");

    Puis remplacer la ligne 84 avec ceci:

    if (signer.verify(new JcaSimpleSignerInfoVerifierBuilder().setProvider(BC_PROVIDER).build(certFromKeystore2))) { ... }

    Avis que certFromSignedData changé à certFromKeystore2 et votre signature vérification échoue parce que votre contenu a été signé avec Key1.

    De code Java:

    Ne pas oublier de changer le keystore chemin d'accès dans l'une des constantes!

    package com.example.main;
import java.io.FileInputStream;
import java.security.Key;
import java.security.KeyStore;
import java.security.PrivateKey;
import java.security.Security;
import java.security.Signature;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import org.bouncycastle.cert.X509CertificateHolder;
import org.bouncycastle.cert.jcajce.JcaCertStore;
import org.bouncycastle.cert.jcajce.JcaX509CertificateConverter;
import org.bouncycastle.cms.CMSProcessableByteArray;
import org.bouncycastle.cms.CMSSignedData;
import org.bouncycastle.cms.CMSSignedDataGenerator;
import org.bouncycastle.cms.CMSTypedData;
import org.bouncycastle.cms.SignerInformation;
import org.bouncycastle.cms.SignerInformationStore;
import org.bouncycastle.cms.jcajce.JcaSignerInfoGeneratorBuilder;
import org.bouncycastle.cms.jcajce.JcaSimpleSignerInfoVerifierBuilder;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.operator.ContentSigner;
import org.bouncycastle.operator.jcajce.JcaContentSignerBuilder;
import org.bouncycastle.operator.jcajce.JcaDigestCalculatorProviderBuilder;
import org.bouncycastle.util.Store;
public class VerifySignature {
static final String KEYSTORE_FILE = "keys/certificates.p12";
static final String KEYSTORE_INSTANCE = "PKCS12";
static final String KEYSTORE_PWD = "test";
static final String KEYSTORE_ALIAS = "Key1";
static final String DIGEST_SHA1 = "SHA1withRSA";
static final String BC_PROVIDER = "BC";
@SuppressWarnings({ "rawtypes", "unchecked" })
public static void main(String[] args) throws Exception {
//Content to be signed
String text = "My name is Oscar";
Security.addProvider(new BouncyCastleProvider());
//Get keystore
KeyStore ks = KeyStore.getInstance(KEYSTORE_INSTANCE);
ks.load(new FileInputStream(KEYSTORE_FILE), KEYSTORE_PWD.toCharArray());
Key key = ks.getKey(KEYSTORE_ALIAS, KEYSTORE_PWD.toCharArray());
//Get private key and sign
PrivateKey privKey = (PrivateKey) key;
Signature signature = Signature.getInstance(DIGEST_SHA1, BC_PROVIDER);
signature.initSign(privKey);
signature.update(text.getBytes());
//Build CMS
X509Certificate certFromKeystore = (X509Certificate) ks.getCertificate(KEYSTORE_ALIAS);
List certList = new ArrayList();
CMSTypedData data = new CMSProcessableByteArray(signature.sign());
certList.add(certFromKeystore);
Store certs = new JcaCertStore(certList);
CMSSignedDataGenerator gen = new CMSSignedDataGenerator();
ContentSigner sha1Signer = new JcaContentSignerBuilder(DIGEST_SHA1).setProvider(BC_PROVIDER).build(privKey);
gen.addSignerInfoGenerator(new JcaSignerInfoGeneratorBuilder(new JcaDigestCalculatorProviderBuilder().setProvider(BC_PROVIDER).build()).build(sha1Signer, certFromKeystore));
gen.addCertificates(certs);
CMSSignedData signedData = gen.generate(data, true);
//Verify signature
Store store = signedData.getCertificates(); 
SignerInformationStore signers = signedData.getSignerInfos(); 
Collection c = signers.getSigners(); 
Iterator it = c.iterator();
while (it.hasNext()) { 
SignerInformation signer = (SignerInformation) it.next(); 
Collection certCollection = store.getMatches(signer.getSID()); 
Iterator certIt = certCollection.iterator();
X509CertificateHolder certHolder = (X509CertificateHolder) certIt.next();
X509Certificate certFromSignedData = new JcaX509CertificateConverter().setProvider(BC_PROVIDER).getCertificate(certHolder);
if (signer.verify(new JcaSimpleSignerInfoVerifierBuilder().setProvider(BC_PROVIDER).build(certFromSignedData))) {
System.out.println("Signature verified");
} else {
System.out.println("Signature verification failed");
}
}
}
}
    InformationsquelleAutor Oscar