0001: package org.bouncycastle.mail.smime.test;
0002:
0003: import junit.framework.Test;
0004: import junit.framework.TestCase;
0005: import junit.framework.TestSuite;
0006: import org.bouncycastle.asn1.ASN1EncodableVector;
0007: import org.bouncycastle.asn1.ASN1OctetString;
0008: import org.bouncycastle.asn1.DERSet;
0009: import org.bouncycastle.asn1.cms.Attribute;
0010: import org.bouncycastle.asn1.cms.AttributeTable;
0011: import org.bouncycastle.asn1.cms.CMSAttributes;
0012: import org.bouncycastle.asn1.cms.Time;
0013: import org.bouncycastle.asn1.cryptopro.CryptoProObjectIdentifiers;
0014: import org.bouncycastle.asn1.nist.NISTObjectIdentifiers;
0015: import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;
0016: import org.bouncycastle.asn1.smime.SMIMECapabilitiesAttribute;
0017: import org.bouncycastle.asn1.smime.SMIMECapability;
0018: import org.bouncycastle.asn1.smime.SMIMECapabilityVector;
0019: import org.bouncycastle.asn1.teletrust.TeleTrusTObjectIdentifiers;
0020: import org.bouncycastle.cms.SignerInformation;
0021: import org.bouncycastle.cms.SignerInformationStore;
0022: import org.bouncycastle.cms.test.CMSTestUtil;
0023: import org.bouncycastle.mail.smime.SMIMESigned;
0024: import org.bouncycastle.mail.smime.SMIMESignedGenerator;
0025: import org.bouncycastle.mail.smime.SMIMESignedParser;
0026: import org.bouncycastle.mail.smime.util.CRLFOutputStream;
0027: import org.bouncycastle.mail.smime.util.FileBackedMimeBodyPart;
0028: import org.bouncycastle.x509.X509AttributeCertificate;
0029: import org.bouncycastle.x509.X509CollectionStoreParameters;
0030: import org.bouncycastle.x509.X509Store;
0031:
0032: import javax.mail.BodyPart;
0033: import javax.mail.MessagingException;
0034: import javax.mail.Session;
0035: import javax.mail.internet.ContentType;
0036: import javax.mail.internet.InternetHeaders;
0037: import javax.mail.internet.MimeBodyPart;
0038: import javax.mail.internet.MimeMessage;
0039: import javax.mail.internet.MimeMultipart;
0040: import java.io.ByteArrayOutputStream;
0041: import java.io.File;
0042: import java.io.FileNotFoundException;
0043: import java.io.FilterOutputStream;
0044: import java.io.IOException;
0045: import java.io.OutputStream;
0046: import java.io.UnsupportedEncodingException;
0047: import java.security.KeyPair;
0048: import java.security.MessageDigest;
0049: import java.security.cert.CertStore;
0050: import java.security.cert.CollectionCertStoreParameters;
0051: import java.security.cert.X509Certificate;
0052: import java.util.ArrayList;
0053: import java.util.Arrays;
0054: import java.util.Collection;
0055: import java.util.Collections;
0056: import java.util.Date;
0057: import java.util.Enumeration;
0058: import java.util.Iterator;
0059: import java.util.List;
0060:
0061: public class SMIMESignedTest extends TestCase {
0062: static MimeBodyPart msg;
0063:
0064: static MimeBodyPart msgR;
0065: static MimeBodyPart msgRN;
0066:
0067: static String _origDN;
0068: static KeyPair _origKP;
0069: static X509Certificate _origCert;
0070:
0071: static String _signDN;
0072: static KeyPair _signKP;
0073: static X509Certificate _signCert;
0074:
0075: static String reciDN;
0076: static KeyPair reciKP;
0077: static X509Certificate reciCert;
0078:
0079: private static KeyPair _signGostKP;
0080: private static X509Certificate _signGostCert;
0081:
0082: private static KeyPair _signEcDsaKP;
0083: private static X509Certificate _signEcDsaCert;
0084:
0085: private static KeyPair _signEcGostKP;
0086: private static X509Certificate _signEcGostCert;
0087:
0088: KeyPair dsaSignKP;
0089: X509Certificate dsaSignCert;
0090:
0091: KeyPair dsaOrigKP;
0092: X509Certificate dsaOrigCert;
0093:
0094: static {
0095: try {
0096: msg = SMIMETestUtil.makeMimeBodyPart("Hello world!\n");
0097:
0098: msgR = SMIMETestUtil.makeMimeBodyPart("Hello world!\r");
0099: msgRN = SMIMETestUtil.makeMimeBodyPart("Hello world!\r\n");
0100:
0101: _origDN = "O=Bouncy Castle, C=AU";
0102: _origKP = CMSTestUtil.makeKeyPair();
0103: _origCert = CMSTestUtil.makeCertificate(_origKP, _origDN,
0104: _origKP, _origDN);
0105:
0106: _signDN = "CN=Eric H. Echidna, E=eric@bouncycastle.org, O=Bouncy Castle, C=AU";
0107: _signKP = CMSTestUtil.makeKeyPair();
0108: _signCert = CMSTestUtil.makeCertificate(_signKP, _signDN,
0109: _origKP, _origDN);
0110:
0111: _signGostKP = CMSTestUtil.makeGostKeyPair();
0112: _signGostCert = CMSTestUtil.makeCertificate(_signGostKP,
0113: _signDN, _origKP, _origDN);
0114:
0115: _signEcDsaKP = CMSTestUtil.makeEcDsaKeyPair();
0116: _signEcDsaCert = CMSTestUtil.makeCertificate(_signEcDsaKP,
0117: _signDN, _origKP, _origDN);
0118:
0119: _signEcGostKP = CMSTestUtil.makeEcGostKeyPair();
0120: _signEcGostCert = CMSTestUtil.makeCertificate(
0121: _signEcGostKP, _signDN, _origKP, _origDN);
0122:
0123: } catch (Exception e) {
0124: throw new RuntimeException(
0125: "problem setting up signed test class: " + e);
0126: }
0127: }
0128:
0129: private static class LineOutputStream extends FilterOutputStream {
0130: private static byte newline[];
0131:
0132: public LineOutputStream(OutputStream outputstream) {
0133: super (outputstream);
0134: }
0135:
0136: public void writeln(String s) throws MessagingException {
0137: try {
0138: byte abyte0[] = getBytes(s);
0139: super .out.write(abyte0);
0140: super .out.write(newline);
0141: } catch (Exception exception) {
0142: throw new MessagingException("IOException", exception);
0143: }
0144: }
0145:
0146: public void writeln() throws MessagingException {
0147: try {
0148: super .out.write(newline);
0149: } catch (Exception exception) {
0150: throw new MessagingException("IOException", exception);
0151: }
0152: }
0153:
0154: static {
0155: newline = new byte[2];
0156: newline[0] = 13;
0157: newline[1] = 10;
0158: }
0159:
0160: private static byte[] getBytes(String s) {
0161: char ac[] = s.toCharArray();
0162: int i = ac.length;
0163: byte abyte0[] = new byte[i];
0164: int j = 0;
0165:
0166: while (j < i) {
0167: abyte0[j] = (byte) ac[j++];
0168: }
0169:
0170: return abyte0;
0171: }
0172: }
0173:
0174: /*
0175: *
0176: * INFRASTRUCTURE
0177: *
0178: */
0179:
0180: public SMIMESignedTest(String name) {
0181: super (name);
0182: }
0183:
0184: public static void main(String args[]) {
0185: junit.textui.TestRunner.run(SMIMESignedTest.class);
0186: }
0187:
0188: public static Test suite() {
0189: return new SMIMETestSetup(new TestSuite(SMIMESignedTest.class));
0190: }
0191:
0192: public void testHeaders() throws Exception {
0193: MimeMultipart smm = generateMultiPartRsa(
0194: SMIMESignedGenerator.DIGEST_SHA1, msg);
0195: BodyPart bp = smm.getBodyPart(1);
0196:
0197: assertEquals(
0198: "application/pkcs7-signature; name=smime.p7s; smime-type=signed-data",
0199: bp.getHeader("Content-Type")[0]);
0200: assertEquals("attachment; filename=\"smime.p7s\"", bp
0201: .getHeader("Content-Disposition")[0]);
0202: assertEquals("S/MIME Cryptographic Signature", bp
0203: .getHeader("Content-Description")[0]);
0204: }
0205:
0206: public void testHeadersEncapsulated() throws Exception {
0207: List certList = new ArrayList();
0208:
0209: certList.add(_signCert);
0210: certList.add(_origCert);
0211:
0212: CertStore certs = CertStore.getInstance("Collection",
0213: new CollectionCertStoreParameters(certList), "BC");
0214:
0215: ASN1EncodableVector signedAttrs = generateSignedAttributes();
0216:
0217: SMIMESignedGenerator gen = new SMIMESignedGenerator();
0218:
0219: gen.addSigner(_signKP.getPrivate(), _signCert,
0220: SMIMESignedGenerator.DIGEST_SHA1, new AttributeTable(
0221: signedAttrs), null);
0222:
0223: gen.addCertificatesAndCRLs(certs);
0224:
0225: MimeBodyPart res = gen.generateEncapsulated(msg, "BC");
0226:
0227: assertEquals(
0228: "application/pkcs7-mime; name=smime.p7m; smime-type=signed-data",
0229: res.getHeader("Content-Type")[0]);
0230: assertEquals("attachment; filename=\"smime.p7m\"", res
0231: .getHeader("Content-Disposition")[0]);
0232: assertEquals("S/MIME Cryptographic Signed Data", res
0233: .getHeader("Content-Description")[0]);
0234: }
0235:
0236: public void testMultipartTextText() throws Exception {
0237: MimeBodyPart part1 = createTemplate("text/html", "7bit");
0238: MimeBodyPart part2 = createTemplate("text/xml", "7bit");
0239:
0240: multipartMixedTest(part1, part2);
0241: }
0242:
0243: public void testMultipartTextBinary() throws Exception {
0244: MimeBodyPart part1 = createTemplate("text/html", "7bit");
0245: MimeBodyPart part2 = createTemplate("text/xml", "binary");
0246:
0247: multipartMixedTest(part1, part2);
0248: }
0249:
0250: public void testMultipartBinaryText() throws Exception {
0251: MimeBodyPart part1 = createTemplate("text/xml", "binary");
0252: MimeBodyPart part2 = createTemplate("text/html", "7bit");
0253:
0254: multipartMixedTest(part1, part2);
0255: }
0256:
0257: public void testMultipartBinaryBinary() throws Exception {
0258: MimeBodyPart part1 = createTemplate("text/xml", "binary");
0259: MimeBodyPart part2 = createTemplate("text/html", "binary");
0260:
0261: multipartMixedTest(part1, part2);
0262: }
0263:
0264: public void multipartMixedTest(MimeBodyPart part1,
0265: MimeBodyPart part2) throws Exception {
0266: MimeMultipart mp = new MimeMultipart();
0267:
0268: mp.addBodyPart(part1);
0269: mp.addBodyPart(part2);
0270:
0271: MimeBodyPart m = new MimeBodyPart();
0272:
0273: m.setContent(mp);
0274:
0275: MimeMultipart smm = generateMultiPartRsa(
0276: SMIMESignedGenerator.DIGEST_SHA1, m);
0277: SMIMESigned s = new SMIMESigned(smm);
0278:
0279: verifySigners(s.getCertificatesAndCRLs("Collection", "BC"), s
0280: .getSignerInfos());
0281:
0282: AttributeTable attr = ((SignerInformation) s.getSignerInfos()
0283: .getSigners().iterator().next()).getSignedAttributes();
0284:
0285: Attribute a = attr.get(CMSAttributes.messageDigest);
0286: byte[] contentDigest = ASN1OctetString.getInstance(
0287: a.getAttrValues().getObjectAt(0)).getOctets();
0288:
0289: mp = (MimeMultipart) m.getContent();
0290: ContentType contentType = new ContentType(mp.getContentType());
0291: String boundary = "--" + contentType.getParameter("boundary");
0292:
0293: ByteArrayOutputStream bOut = new ByteArrayOutputStream();
0294: LineOutputStream lOut = new LineOutputStream(bOut);
0295:
0296: Enumeration headers = m.getAllHeaderLines();
0297: while (headers.hasMoreElements()) {
0298: lOut.writeln((String) headers.nextElement());
0299: }
0300:
0301: lOut.writeln(); // CRLF separator
0302:
0303: lOut.writeln(boundary);
0304: writePart(mp.getBodyPart(0), bOut);
0305: lOut.writeln(); // CRLF terminator
0306:
0307: lOut.writeln(boundary);
0308: writePart(mp.getBodyPart(1), bOut);
0309: lOut.writeln();
0310:
0311: lOut.writeln(boundary + "--");
0312:
0313: MessageDigest dig = MessageDigest.getInstance("SHA1", "BC");
0314:
0315: assertTrue(Arrays.equals(contentDigest, dig.digest(bOut
0316: .toByteArray())));
0317: }
0318:
0319: private void writePart(BodyPart part, ByteArrayOutputStream bOut)
0320: throws MessagingException, IOException {
0321: if (part.getHeader("Content-Transfer-Encoding")[0]
0322: .equals("binary")) {
0323: part.writeTo(bOut);
0324: } else {
0325: part.writeTo(new CRLFOutputStream(bOut));
0326: }
0327: }
0328:
0329: public void testSHA1WithRSA() throws Exception {
0330: MimeMultipart smm = generateMultiPartRsa(
0331: SMIMESignedGenerator.DIGEST_SHA1, msg);
0332: SMIMESigned s = new SMIMESigned(smm);
0333:
0334: verifyMessageBytes(msg, s.getContent());
0335:
0336: verifySigners(s.getCertificatesAndCRLs("Collection", "BC"), s
0337: .getSignerInfos());
0338: }
0339:
0340: public void testSHA1WithRSACanonicalization() throws Exception {
0341: Date testTime = new Date();
0342: MimeMultipart smm = generateMultiPartRsa(
0343: SMIMESignedGenerator.DIGEST_SHA1, msg, testTime);
0344:
0345: byte[] sig1 = getEncodedStream(smm);
0346:
0347: smm = generateMultiPartRsa(SMIMESignedGenerator.DIGEST_SHA1,
0348: msgR, testTime);
0349:
0350: byte[] sig2 = getEncodedStream(smm);
0351:
0352: assertTrue(Arrays.equals(sig1, sig2));
0353:
0354: smm = generateMultiPartRsa(SMIMESignedGenerator.DIGEST_SHA1,
0355: msgRN, testTime);
0356:
0357: byte[] sig3 = getEncodedStream(smm);
0358:
0359: assertTrue(Arrays.equals(sig1, sig3));
0360: }
0361:
0362: private byte[] getEncodedStream(MimeMultipart smm)
0363: throws IOException, MessagingException {
0364: ByteArrayOutputStream bOut = new ByteArrayOutputStream();
0365:
0366: smm.getBodyPart(1).writeTo(bOut);
0367:
0368: return bOut.toByteArray();
0369: }
0370:
0371: public void testSHA1WithRSAEncapsulated() throws Exception {
0372: MimeBodyPart res = generateEncapsulatedRsa(
0373: SMIMESignedGenerator.DIGEST_SHA1, msg);
0374: SMIMESigned s = new SMIMESigned(res);
0375:
0376: verifyMessageBytes(msg, s.getContent());
0377:
0378: verifySigners(s.getCertificatesAndCRLs("Collection", "BC"), s
0379: .getSignerInfos());
0380: }
0381:
0382: public void testSHA1WithRSAEncapsulatedParser() throws Exception {
0383: MimeBodyPart res = generateEncapsulatedRsa(
0384: SMIMESignedGenerator.DIGEST_SHA1, msg);
0385: SMIMESignedParser s = new SMIMESignedParser(res);
0386:
0387: FileBackedMimeBodyPart content = (FileBackedMimeBodyPart) s
0388: .getContent();
0389:
0390: verifyMessageBytes(msg, content);
0391:
0392: content.dispose();
0393:
0394: verifySigners(s.getCertificatesAndCRLs("Collection", "BC"), s
0395: .getSignerInfos());
0396:
0397: s.close();
0398: }
0399:
0400: public void testSHA1WithRSAEncapsulatedParserAndFile()
0401: throws Exception {
0402: File tmp = File.createTempFile("bcTest", ".mime");
0403: MimeBodyPart res = generateEncapsulatedRsa(
0404: SMIMESignedGenerator.DIGEST_SHA1, msg);
0405: SMIMESignedParser s = new SMIMESignedParser(res, tmp);
0406: FileBackedMimeBodyPart content = (FileBackedMimeBodyPart) s
0407: .getContent();
0408:
0409: verifyMessageBytes(msg, s.getContent());
0410:
0411: verifySigners(s.getCertificatesAndCRLs("Collection", "BC"), s
0412: .getSignerInfos());
0413:
0414: assertTrue(tmp.exists());
0415:
0416: s.close();
0417:
0418: content.dispose();
0419:
0420: assertFalse(tmp.exists());
0421: }
0422:
0423: public void testMD5WithRSA() throws Exception {
0424: MimeMultipart smm = generateMultiPartRsa(
0425: SMIMESignedGenerator.DIGEST_MD5, msg);
0426: SMIMESigned s = new SMIMESigned(smm);
0427:
0428: assertEquals("md5", getMicAlg(smm));
0429: assertEquals(getDigestOid(s.getSignerInfos()),
0430: PKCSObjectIdentifiers.md5.toString());
0431:
0432: verifyMessageBytes(msg, s.getContent());
0433:
0434: verifySigners(s.getCertificatesAndCRLs("Collection", "BC"), s
0435: .getSignerInfos());
0436: }
0437:
0438: public void testSHA224WithRSA() throws Exception {
0439: MimeMultipart smm = generateMultiPartRsa(
0440: SMIMESignedGenerator.DIGEST_SHA224, msg);
0441: SMIMESigned s = new SMIMESigned(smm);
0442:
0443: assertEquals("sha224", getMicAlg(smm));
0444: assertEquals(getDigestOid(s.getSignerInfos()),
0445: NISTObjectIdentifiers.id_sha224.toString());
0446:
0447: verifyMessageBytes(msg, s.getContent());
0448:
0449: verifySigners(s.getCertificatesAndCRLs("Collection", "BC"), s
0450: .getSignerInfos());
0451: }
0452:
0453: public void testSHA256WithRSA() throws Exception {
0454: MimeMultipart smm = generateMultiPartRsa(
0455: SMIMESignedGenerator.DIGEST_SHA256, msg);
0456: SMIMESigned s = new SMIMESigned(smm);
0457:
0458: assertEquals("sha256", getMicAlg(smm));
0459: assertEquals(getDigestOid(s.getSignerInfos()),
0460: NISTObjectIdentifiers.id_sha256.toString());
0461:
0462: verifyMessageBytes(msg, s.getContent());
0463:
0464: verifySigners(s.getCertificatesAndCRLs("Collection", "BC"), s
0465: .getSignerInfos());
0466: }
0467:
0468: public void testSHA384WithRSA() throws Exception {
0469: MimeMultipart smm = generateMultiPartRsa(
0470: SMIMESignedGenerator.DIGEST_SHA384, msg);
0471: SMIMESigned s = new SMIMESigned(smm);
0472:
0473: assertEquals("sha384", getMicAlg(smm));
0474: assertEquals(getDigestOid(s.getSignerInfos()),
0475: NISTObjectIdentifiers.id_sha384.toString());
0476:
0477: verifyMessageBytes(msg, s.getContent());
0478:
0479: verifySigners(s.getCertificatesAndCRLs("Collection", "BC"), s
0480: .getSignerInfos());
0481: }
0482:
0483: public void testSHA512WithRSA() throws Exception {
0484: MimeMultipart smm = generateMultiPartRsa(
0485: SMIMESignedGenerator.DIGEST_SHA512, msg);
0486: SMIMESigned s = new SMIMESigned(smm);
0487:
0488: assertEquals("sha512", getMicAlg(smm));
0489: assertEquals(getDigestOid(s.getSignerInfos()),
0490: NISTObjectIdentifiers.id_sha512.toString());
0491:
0492: verifyMessageBytes(msg, s.getContent());
0493:
0494: verifySigners(s.getCertificatesAndCRLs("Collection", "BC"), s
0495: .getSignerInfos());
0496: }
0497:
0498: public void testRIPEMD160WithRSA() throws Exception {
0499: MimeMultipart smm = generateMultiPartRsa(
0500: SMIMESignedGenerator.DIGEST_RIPEMD160, msg);
0501: SMIMESigned s = new SMIMESigned(smm);
0502:
0503: assertEquals("unknown", getMicAlg(smm));
0504: assertEquals(getDigestOid(s.getSignerInfos()),
0505: TeleTrusTObjectIdentifiers.ripemd160.toString());
0506:
0507: verifyMessageBytes(msg, s.getContent());
0508:
0509: verifySigners(s.getCertificatesAndCRLs("Collection", "BC"), s
0510: .getSignerInfos());
0511: }
0512:
0513: public void testGOST3411WithGOST3410() throws Exception {
0514: MimeMultipart smm = generateMultiPartGost(msg);
0515: SMIMESigned s = new SMIMESigned(smm);
0516:
0517: assertEquals("gostr3411-94", getMicAlg(smm));
0518: assertEquals(getDigestOid(s.getSignerInfos()),
0519: CryptoProObjectIdentifiers.gostR3411.getId());
0520:
0521: verifyMessageBytes(msg, s.getContent());
0522:
0523: verifySigners(s.getCertificatesAndCRLs("Collection", "BC"), s
0524: .getSignerInfos());
0525: }
0526:
0527: public void testGOST3411WithECGOST3410() throws Exception {
0528: MimeMultipart smm = generateMultiPartECGost(msg);
0529: SMIMESigned s = new SMIMESigned(smm);
0530:
0531: assertEquals("gostr3411-94", getMicAlg(smm));
0532: assertEquals(getDigestOid(s.getSignerInfos()),
0533: CryptoProObjectIdentifiers.gostR3411.getId());
0534:
0535: verifyMessageBytes(msg, s.getContent());
0536:
0537: verifySigners(s.getCertificatesAndCRLs("Collection", "BC"), s
0538: .getSignerInfos());
0539: }
0540:
0541: public void testSHA224WithRSAParser() throws Exception {
0542: MimeMultipart smm = generateMultiPartRsa(
0543: SMIMESignedGenerator.DIGEST_SHA224, msg);
0544: SMIMESignedParser s = new SMIMESignedParser(smm);
0545: CertStore certs = s.getCertificatesAndCRLs("Collection", "BC");
0546:
0547: assertEquals(getDigestOid(s.getSignerInfos()),
0548: NISTObjectIdentifiers.id_sha224.toString());
0549:
0550: verifyMessageBytes(msg, s.getContent());
0551:
0552: verifySigners(certs, s.getSignerInfos());
0553: }
0554:
0555: public void testSHA224WithRSAParserEncryptedWithDES()
0556: throws Exception {
0557: List certList = new ArrayList();
0558:
0559: certList.add(_signCert);
0560: certList.add(_origCert);
0561:
0562: CertStore certs = CertStore.getInstance("Collection",
0563: new CollectionCertStoreParameters(certList), "BC");
0564:
0565: ASN1EncodableVector signedAttrs = generateSignedAttributes();
0566:
0567: SMIMESignedGenerator gen = new SMIMESignedGenerator();
0568:
0569: gen.addSigner(_signKP.getPrivate(), _signCert,
0570: SMIMESignedGenerator.DIGEST_SHA224, new AttributeTable(
0571: signedAttrs), null);
0572: gen.addCertificatesAndCRLs(certs);
0573:
0574: MimeMultipart smm = gen.generate(msg, "BC");
0575: SMIMESignedParser s = new SMIMESignedParser(smm);
0576:
0577: certs = s.getCertificatesAndCRLs("Collection", "BC");
0578:
0579: assertEquals(getDigestOid(s.getSignerInfos()),
0580: NISTObjectIdentifiers.id_sha224.toString());
0581:
0582: verifyMessageBytes(msg, s.getContent());
0583:
0584: verifySigners(certs, s.getSignerInfos());
0585: }
0586:
0587: public void testSHA1withDSA() throws Exception {
0588: dsaSignKP = CMSTestUtil.makeDsaKeyPair();
0589: dsaSignCert = CMSTestUtil.makeCertificate(dsaSignKP, _origDN,
0590: dsaSignKP, _origDN);
0591:
0592: dsaOrigKP = CMSTestUtil.makeDsaKeyPair();
0593: dsaOrigCert = CMSTestUtil.makeCertificate(dsaOrigKP, _signDN,
0594: dsaSignKP, _origDN);
0595:
0596: List certList = new ArrayList();
0597:
0598: certList.add(dsaOrigCert);
0599: certList.add(dsaSignCert);
0600:
0601: CertStore certs = CertStore.getInstance("Collection",
0602: new CollectionCertStoreParameters(certList), "BC");
0603:
0604: SMIMESignedGenerator gen = new SMIMESignedGenerator();
0605:
0606: gen.addSigner(dsaOrigKP.getPrivate(), dsaOrigCert,
0607: SMIMESignedGenerator.DIGEST_SHA1);
0608: gen.addCertificatesAndCRLs(certs);
0609:
0610: MimeMultipart smm = gen.generate(msg, "BC");
0611: SMIMESigned s = new SMIMESigned(smm);
0612:
0613: verifyMessageBytes(msg, s.getContent());
0614:
0615: verifySigners(s.getCertificatesAndCRLs("Collection", "BC"), s
0616: .getSignerInfos());
0617: }
0618:
0619: public void testSHA256WithRSABinary() throws Exception {
0620: MimeBodyPart msg = generateBinaryPart();
0621: MimeMultipart smm = generateMultiPartRsa(
0622: SMIMESignedGenerator.DIGEST_SHA256, msg);
0623: SMIMESigned s = new SMIMESigned(smm);
0624:
0625: verifyMessageBytes(msg, s.getContent());
0626:
0627: verifySigners(s.getCertificatesAndCRLs("Collection", "BC"), s
0628: .getSignerInfos());
0629: }
0630:
0631: public void testSHA256WithRSABinaryWithParser() throws Exception {
0632: MimeBodyPart msg = generateBinaryPart();
0633: MimeMultipart smm = generateMultiPartRsa(
0634: SMIMESignedGenerator.DIGEST_SHA256, msg);
0635: SMIMESignedParser s = new SMIMESignedParser(smm);
0636:
0637: verifyMessageBytes(msg, s.getContent());
0638:
0639: verifySigners(s.getCertificatesAndCRLs("Collection", "BC"), s
0640: .getSignerInfos());
0641: }
0642:
0643: public void testWithAttributeCertificate() throws Exception {
0644: List certList = new ArrayList();
0645:
0646: certList.add(_signCert);
0647: certList.add(_origCert);
0648:
0649: CertStore certs = CertStore.getInstance("Collection",
0650: new CollectionCertStoreParameters(certList), "BC");
0651:
0652: ASN1EncodableVector signedAttrs = generateSignedAttributes();
0653:
0654: SMIMESignedGenerator gen = new SMIMESignedGenerator();
0655:
0656: gen.addSigner(_signKP.getPrivate(), _signCert,
0657: SMIMESignedGenerator.DIGEST_SHA256, new AttributeTable(
0658: signedAttrs), null);
0659:
0660: gen.addCertificatesAndCRLs(certs);
0661:
0662: X509AttributeCertificate attrCert = CMSTestUtil
0663: .getAttributeCertificate();
0664:
0665: X509Store store = X509Store.getInstance(
0666: "AttributeCertificate/Collection",
0667: new X509CollectionStoreParameters(Collections
0668: .singleton(attrCert)), "BC");
0669:
0670: gen.addAttributeCertificates(store);
0671:
0672: SMIMESigned s = new SMIMESigned(gen.generateEncapsulated(msg,
0673: "BC"));
0674:
0675: verifyMessageBytes(msg, s.getContent());
0676:
0677: verifySigners(s.getCertificatesAndCRLs("Collection", "BC"), s
0678: .getSignerInfos());
0679:
0680: X509Store attrCerts = s.getAttributeCertificates("Collection",
0681: "BC");
0682:
0683: assertTrue(attrCerts.getMatches(null).contains(attrCert));
0684: }
0685:
0686: private MimeBodyPart generateBinaryPart() throws MessagingException {
0687: byte[] content = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 10,
0688: 11, 12, 13, 14, 10, 10, 15, 16 };
0689: InternetHeaders ih = new InternetHeaders();
0690:
0691: ih.setHeader("Content-Transfer-Encoding", "binary");
0692: return new MimeBodyPart(ih, content);
0693: }
0694:
0695: private MimeMultipart generateMultiPartRsa(String digestOid,
0696: MimeBodyPart msg, Date signingTime) throws Exception {
0697: List certList = new ArrayList();
0698:
0699: certList.add(_signCert);
0700: certList.add(_origCert);
0701:
0702: CertStore certs = CertStore.getInstance("Collection",
0703: new CollectionCertStoreParameters(certList), "BC");
0704:
0705: ASN1EncodableVector signedAttrs = generateSignedAttributes();
0706:
0707: if (signingTime != null) {
0708: signedAttrs.add(new Attribute(CMSAttributes.signingTime,
0709: new DERSet(new Time(signingTime))));
0710: }
0711:
0712: SMIMESignedGenerator gen = new SMIMESignedGenerator();
0713:
0714: gen.addSigner(_signKP.getPrivate(), _signCert, digestOid,
0715: new AttributeTable(signedAttrs), null);
0716: gen.addCertificatesAndCRLs(certs);
0717:
0718: return gen.generate(msg, "BC");
0719: }
0720:
0721: private MimeMultipart generateMultiPartGost(MimeBodyPart msg)
0722: throws Exception {
0723: List certList = new ArrayList();
0724:
0725: certList.add(_signCert);
0726: certList.add(_signGostCert);
0727:
0728: CertStore certs = CertStore.getInstance("Collection",
0729: new CollectionCertStoreParameters(certList), "BC");
0730:
0731: SMIMESignedGenerator gen = new SMIMESignedGenerator();
0732:
0733: gen.addSigner(_signGostKP.getPrivate(), _signGostCert,
0734: SMIMESignedGenerator.DIGEST_GOST3411);
0735: gen.addCertificatesAndCRLs(certs);
0736:
0737: return gen.generate(msg, "BC");
0738: }
0739:
0740: private MimeMultipart generateMultiPartECGost(MimeBodyPart msg)
0741: throws Exception {
0742: List certList = new ArrayList();
0743:
0744: certList.add(_signCert);
0745: certList.add(_signEcGostCert);
0746:
0747: CertStore certs = CertStore.getInstance("Collection",
0748: new CollectionCertStoreParameters(certList), "BC");
0749:
0750: SMIMESignedGenerator gen = new SMIMESignedGenerator();
0751:
0752: gen.addSigner(_signEcGostKP.getPrivate(), _signEcGostCert,
0753: SMIMESignedGenerator.DIGEST_GOST3411);
0754: gen.addCertificatesAndCRLs(certs);
0755:
0756: return gen.generate(msg, "BC");
0757: }
0758:
0759: private MimeMultipart generateMultiPartRsa(String digestOid,
0760: MimeBodyPart msg) throws Exception {
0761: return generateMultiPartRsa(digestOid, msg, null);
0762: }
0763:
0764: private MimeBodyPart generateEncapsulatedRsa(String digestOid,
0765: MimeBodyPart msg) throws Exception {
0766: List certList = new ArrayList();
0767:
0768: certList.add(_signCert);
0769: certList.add(_origCert);
0770:
0771: CertStore certs = CertStore.getInstance("Collection",
0772: new CollectionCertStoreParameters(certList), "BC");
0773:
0774: ASN1EncodableVector signedAttrs = generateSignedAttributes();
0775:
0776: SMIMESignedGenerator gen = new SMIMESignedGenerator();
0777:
0778: gen.addSigner(_signKP.getPrivate(), _signCert, digestOid,
0779: new AttributeTable(signedAttrs), null);
0780: gen.addCertificatesAndCRLs(certs);
0781:
0782: return gen.generateEncapsulated(msg, "BC");
0783: }
0784:
0785: public void testCertificateManagement() throws Exception {
0786: List certList = new ArrayList();
0787:
0788: certList.add(_signCert);
0789: certList.add(_origCert);
0790:
0791: CertStore certs = CertStore.getInstance("Collection",
0792: new CollectionCertStoreParameters(certList), "BC");
0793:
0794: SMIMESignedGenerator gen = new SMIMESignedGenerator();
0795:
0796: gen.addCertificatesAndCRLs(certs);
0797:
0798: MimeBodyPart smm = gen.generateCertificateManagement("BC");
0799:
0800: SMIMESigned s = new SMIMESigned(smm);
0801:
0802: certs = s.getCertificatesAndCRLs("Collection", "BC");
0803:
0804: assertEquals(2, certs.getCertificates(null).size());
0805: }
0806:
0807: public void testMimeMultipart() throws Exception {
0808: MimeBodyPart m = createMultipartMessage();
0809:
0810: List certList = new ArrayList();
0811:
0812: certList.add(_signCert);
0813: certList.add(_origCert);
0814:
0815: CertStore certs = CertStore.getInstance("Collection",
0816: new CollectionCertStoreParameters(certList), "BC");
0817:
0818: ASN1EncodableVector signedAttrs = generateSignedAttributes();
0819:
0820: SMIMESignedGenerator gen = new SMIMESignedGenerator("binary");
0821:
0822: gen.addSigner(_signKP.getPrivate(), _signCert,
0823: SMIMESignedGenerator.DIGEST_SHA1, new AttributeTable(
0824: signedAttrs), null);
0825: gen.addCertificatesAndCRLs(certs);
0826:
0827: MimeMultipart mm = gen.generate(m, "BC");
0828:
0829: SMIMESigned s = new SMIMESigned(mm);
0830:
0831: verifySigners(s.getCertificatesAndCRLs("Collection", "BC"), s
0832: .getSignerInfos());
0833:
0834: byte[] contentDigest = (byte[]) gen.getGeneratedDigests().get(
0835: SMIMESignedGenerator.DIGEST_SHA1);
0836:
0837: AttributeTable table = ((SignerInformation) s.getSignerInfos()
0838: .getSigners().iterator().next()).getSignedAttributes();
0839: Attribute hash = table.get(CMSAttributes.messageDigest);
0840:
0841: assertTrue(MessageDigest.isEqual(contentDigest,
0842: ((ASN1OctetString) hash.getAttrValues().getObjectAt(0))
0843: .getOctets()));
0844: }
0845:
0846: public void testMimeMultipartBinaryReader() throws Exception {
0847: MimeBodyPart m = createMultipartMessage();
0848:
0849: List certList = new ArrayList();
0850:
0851: certList.add(_signCert);
0852: certList.add(_origCert);
0853:
0854: CertStore certs = CertStore.getInstance("Collection",
0855: new CollectionCertStoreParameters(certList), "BC");
0856:
0857: ASN1EncodableVector signedAttrs = generateSignedAttributes();
0858:
0859: SMIMESignedGenerator gen = new SMIMESignedGenerator("binary");
0860:
0861: gen.addSigner(_signKP.getPrivate(), _signCert,
0862: SMIMESignedGenerator.DIGEST_SHA1, new AttributeTable(
0863: signedAttrs), null);
0864: gen.addCertificatesAndCRLs(certs);
0865:
0866: MimeMultipart mm = gen.generate(m, "BC");
0867:
0868: SMIMESigned s = new SMIMESigned(mm, "binary");
0869:
0870: verifySigners(s.getCertificatesAndCRLs("Collection", "BC"), s
0871: .getSignerInfos());
0872: }
0873:
0874: public void testMimeMultipartBinaryParser() throws Exception {
0875: MimeBodyPart m = createMultipartMessage();
0876:
0877: List certList = new ArrayList();
0878:
0879: certList.add(_signCert);
0880: certList.add(_origCert);
0881:
0882: CertStore certs = CertStore.getInstance("Collection",
0883: new CollectionCertStoreParameters(certList), "BC");
0884:
0885: ASN1EncodableVector signedAttrs = generateSignedAttributes();
0886:
0887: SMIMESignedGenerator gen = new SMIMESignedGenerator("binary");
0888:
0889: gen.addSigner(_signKP.getPrivate(), _signCert,
0890: SMIMESignedGenerator.DIGEST_SHA1, new AttributeTable(
0891: signedAttrs), null);
0892: gen.addCertificatesAndCRLs(certs);
0893:
0894: MimeMultipart mm = gen.generate(m, "BC");
0895:
0896: SMIMESignedParser s = new SMIMESignedParser(mm, "binary");
0897:
0898: verifySigners(s.getCertificatesAndCRLs("Collection", "BC"), s
0899: .getSignerInfos());
0900: }
0901:
0902: private MimeBodyPart createMultipartMessage()
0903: throws MessagingException {
0904: MimeBodyPart msg1 = new MimeBodyPart();
0905:
0906: msg1.setText("Hello part 1!\n");
0907:
0908: MimeBodyPart msg2 = new MimeBodyPart();
0909:
0910: msg2.setText("Hello part 2!\n");
0911:
0912: MimeMultipart mp = new MimeMultipart();
0913:
0914: mp.addBodyPart(msg1);
0915: mp.addBodyPart(msg2);
0916:
0917: MimeBodyPart m = new MimeBodyPart();
0918:
0919: m.setContent(mp);
0920:
0921: return m;
0922: }
0923:
0924: public void testQuotable() throws Exception {
0925: MimeMessage message = loadMessage("quotable.message");
0926:
0927: SMIMESigned s = new SMIMESigned((MimeMultipart) message
0928: .getContent());
0929:
0930: verifySigners(s.getCertificatesAndCRLs("Collection", "BC"), s
0931: .getSignerInfos());
0932: }
0933:
0934: public void testQuotableParser() throws Exception {
0935: MimeMessage message = loadMessage("quotable.message");
0936:
0937: SMIMESignedParser s = new SMIMESignedParser(
0938: (MimeMultipart) message.getContent());
0939:
0940: verifySigners(s.getCertificatesAndCRLs("Collection", "BC"), s
0941: .getSignerInfos());
0942: }
0943:
0944: public void testEmbeddedMulti() throws Exception {
0945: MimeMessage message = loadMessage("embeddedmulti.message");
0946:
0947: SMIMESigned s = new SMIMESigned((MimeMultipart) message
0948: .getContent());
0949:
0950: verifySigners(s.getCertificatesAndCRLs("Collection", "BC"), s
0951: .getSignerInfos());
0952: }
0953:
0954: public void testEmbeddedMultiParser() throws Exception {
0955: MimeMessage message = loadMessage("embeddedmulti.message");
0956:
0957: SMIMESignedParser s = new SMIMESignedParser(
0958: (MimeMultipart) message.getContent());
0959:
0960: verifySigners(s.getCertificatesAndCRLs("Collection", "BC"), s
0961: .getSignerInfos());
0962: }
0963:
0964: public void testBasicAS2() throws Exception {
0965: MimeMessage message = loadMessage("basicAS2.message");
0966:
0967: SMIMESigned s = new SMIMESigned((MimeMultipart) message
0968: .getContent());
0969:
0970: verifySigners(s.getCertificatesAndCRLs("Collection", "BC"), s
0971: .getSignerInfos());
0972: }
0973:
0974: public void testBasicAS2Parser() throws Exception {
0975: MimeMessage message = loadMessage("basicAS2.message");
0976:
0977: SMIMESignedParser s = new SMIMESignedParser(
0978: (MimeMultipart) message.getContent());
0979:
0980: verifySigners(s.getCertificatesAndCRLs("Collection", "BC"), s
0981: .getSignerInfos());
0982: }
0983:
0984: private String getDigestOid(SignerInformationStore s) {
0985: return ((SignerInformation) s.getSigners().iterator().next())
0986: .getDigestAlgOID();
0987: }
0988:
0989: private void verifySigners(CertStore certs,
0990: SignerInformationStore signers) throws Exception {
0991: Collection c = signers.getSigners();
0992: Iterator it = c.iterator();
0993:
0994: while (it.hasNext()) {
0995: SignerInformation signer = (SignerInformation) it.next();
0996: Collection certCollection = certs.getCertificates(signer
0997: .getSID());
0998:
0999: Iterator certIt = certCollection.iterator();
1000: X509Certificate cert = (X509Certificate) certIt.next();
1001:
1002: assertEquals(true, signer.verify(cert, "BC"));
1003: }
1004: }
1005:
1006: private void verifyMessageBytes(MimeBodyPart a, MimeBodyPart b)
1007: throws Exception {
1008: ByteArrayOutputStream bOut1 = new ByteArrayOutputStream();
1009:
1010: a.writeTo(bOut1);
1011: bOut1.close();
1012:
1013: ByteArrayOutputStream bOut2 = new ByteArrayOutputStream();
1014:
1015: b.writeTo(bOut2);
1016: bOut2.close();
1017:
1018: assertEquals(true, Arrays.equals(bOut1.toByteArray(), bOut2
1019: .toByteArray()));
1020: }
1021:
1022: private ASN1EncodableVector generateSignedAttributes() {
1023: ASN1EncodableVector signedAttrs = new ASN1EncodableVector();
1024: SMIMECapabilityVector caps = new SMIMECapabilityVector();
1025:
1026: caps.addCapability(SMIMECapability.dES_EDE3_CBC);
1027: caps.addCapability(SMIMECapability.rC2_CBC, 128);
1028: caps.addCapability(SMIMECapability.dES_CBC);
1029:
1030: signedAttrs.add(new SMIMECapabilitiesAttribute(caps));
1031:
1032: return signedAttrs;
1033: }
1034:
1035: private MimeMessage loadMessage(String name)
1036: throws MessagingException, FileNotFoundException {
1037: Session session = Session.getDefaultInstance(System
1038: .getProperties(), null);
1039:
1040: return new MimeMessage(session, getClass().getResourceAsStream(
1041: name));
1042: }
1043:
1044: private MimeBodyPart createTemplate(String contentType,
1045: String contentTransferEncoding)
1046: throws UnsupportedEncodingException, MessagingException {
1047: byte[] content = "<?xml version=\"1.0\"?>\n<INVOICE_CENTER>\n <CONTENT_FRAME>\n</CONTENT_FRAME>\n</INVOICE_CENTER>\n"
1048: .getBytes("US-ASCII");
1049:
1050: InternetHeaders ih = new InternetHeaders();
1051: ih.setHeader("Content-Type", contentType);
1052: ih.setHeader("Content-Transfer-Encoding",
1053: contentTransferEncoding);
1054:
1055: return new MimeBodyPart(ih, content);
1056: }
1057:
1058: private String getMicAlg(MimeMultipart mm) {
1059: String contentType = mm.getContentType();
1060: String micAlg = contentType.substring(contentType
1061: .indexOf("micalg=") + 7);
1062:
1063: return micAlg.substring(0, micAlg.indexOf(';'));
1064: }
1065: }
|