← Back to branch summary

~brian-thomason/+junk/bouncycastle

« back to all changes in this revision

Viewing changes to test/src/org/bouncycastle/tsp/test/TSPTest.java

  • Committer: Brian Thomason
  • Date: 2011-12-20 17:20:32 UTC
  • Revision ID: brian.thomason@canonical.com-20111220172032-rdtm13jgdxtksacr
Initial import

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/src/org/bouncycastle/tsp/test/TSPTest.java
 
1
package org.bouncycastle.tsp.test;
 
2
 
 
3
import java.math.BigInteger;
 
4
import java.security.KeyPair;
 
5
import java.security.PrivateKey;
 
6
import java.security.cert.CertStore;
 
7
import java.security.cert.CollectionCertStoreParameters;
 
8
import java.security.cert.X509Certificate;
 
9
import java.util.ArrayList;
 
10
import java.util.Collection;
 
11
import java.util.Date;
 
12
import java.util.HashSet;
 
13
import java.util.List;
 
14
 
 
15
import junit.framework.TestCase;
 
16
import org.bouncycastle.asn1.cmp.PKIFailureInfo;
 
17
import org.bouncycastle.asn1.cms.AttributeTable;
 
18
import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;
 
19
import org.bouncycastle.tsp.GenTimeAccuracy;
 
20
import org.bouncycastle.tsp.TSPAlgorithms;
 
21
import org.bouncycastle.tsp.TSPValidationException;
 
22
import org.bouncycastle.tsp.TimeStampRequest;
 
23
import org.bouncycastle.tsp.TimeStampRequestGenerator;
 
24
import org.bouncycastle.tsp.TimeStampResponse;
 
25
import org.bouncycastle.tsp.TimeStampResponseGenerator;
 
26
import org.bouncycastle.tsp.TimeStampToken;
 
27
import org.bouncycastle.tsp.TimeStampTokenGenerator;
 
28
import org.bouncycastle.tsp.TimeStampTokenInfo;
 
29
import org.bouncycastle.util.Arrays;
 
30
 
 
31
public class TSPTest
 
32
    extends TestCase
 
33
{
 
34
    public void testGeneral()
 
35
        throws Exception
 
36
    {
 
37
            String signDN = "O=Bouncy Castle, C=AU";
 
38
            KeyPair signKP = TSPTestUtil.makeKeyPair();
 
39
            X509Certificate signCert = TSPTestUtil.makeCACertificate(signKP,
 
40
                    signDN, signKP, signDN);
 
41
 
 
42
            String origDN = "CN=Eric H. Echidna, E=eric@bouncycastle.org, O=Bouncy Castle, C=AU";
 
43
            KeyPair origKP = TSPTestUtil.makeKeyPair();
 
44
            X509Certificate origCert = TSPTestUtil.makeCertificate(origKP,
 
45
                    origDN, signKP, signDN);
 
46
 
 
47
 
 
48
            
 
49
            List certList = new ArrayList();
 
50
            certList.add(origCert);
 
51
            certList.add(signCert);
 
52
 
 
53
            CertStore certs = CertStore.getInstance("Collection",
 
54
                    new CollectionCertStoreParameters(certList), "BC");
 
55
            
 
56
            basicTest(origKP.getPrivate(), origCert, certs);     
 
57
            responseValidationTest(origKP.getPrivate(), origCert, certs);
 
58
            incorrectHashTest(origKP.getPrivate(), origCert, certs);
 
59
            badAlgorithmTest(origKP.getPrivate(), origCert, certs);
 
60
            timeNotAvailableTest(origKP.getPrivate(), origCert, certs);
 
61
            badPolicyTest(origKP.getPrivate(), origCert, certs);
 
62
            tokenEncodingTest(origKP.getPrivate(), origCert, certs);
 
63
            certReqTest(origKP.getPrivate(), origCert, certs);
 
64
            testAccuracyZeroCerts(origKP.getPrivate(), origCert, certs);
 
65
            testAccuracyWithCertsAndOrdering(origKP.getPrivate(), origCert, certs);
 
66
            testNoNonse(origKP.getPrivate(), origCert, certs);
 
67
    }
 
68
    
 
69
    private void basicTest(
 
70
        PrivateKey      privateKey,
 
71
        X509Certificate cert,
 
72
        CertStore       certs)
 
73
        throws Exception
 
74
    {
 
75
        TimeStampTokenGenerator tsTokenGen = new TimeStampTokenGenerator(
 
76
                privateKey, cert, TSPAlgorithms.SHA1, "1.2");
 
77
        
 
78
        tsTokenGen.setCertificatesAndCRLs(certs);
 
79
 
 
80
        TimeStampRequestGenerator reqGen = new TimeStampRequestGenerator();
 
81
        TimeStampRequest          request = reqGen.generate(TSPAlgorithms.SHA1, new byte[20], BigInteger.valueOf(100));
 
82
 
 
83
        TimeStampResponseGenerator tsRespGen = new TimeStampResponseGenerator(tsTokenGen, TSPAlgorithms.ALLOWED);
 
84
 
 
85
        TimeStampResponse tsResp = tsRespGen.generate(request, new BigInteger("23"), new Date(), "BC");
 
86
 
 
87
        tsResp = new TimeStampResponse(tsResp.getEncoded());
 
88
 
 
89
        TimeStampToken  tsToken = tsResp.getTimeStampToken();
 
90
 
 
91
        tsToken.validate(cert, "BC");
 
92
 
 
93
        AttributeTable  table = tsToken.getSignedAttributes();
 
94
 
 
95
        assertNotNull("no signingCertificate attribute found", table.get(PKCSObjectIdentifiers.id_aa_signingCertificate));
 
96
    }
 
97
    
 
98
    private void responseValidationTest(
 
99
        PrivateKey      privateKey,
 
100
        X509Certificate cert,
 
101
        CertStore       certs)
 
102
        throws Exception
 
103
    {
 
104
        TimeStampTokenGenerator tsTokenGen = new TimeStampTokenGenerator(
 
105
                privateKey, cert, TSPAlgorithms.MD5, "1.2");
 
106
        
 
107
        tsTokenGen.setCertificatesAndCRLs(certs);
 
108
 
 
109
        TimeStampRequestGenerator reqGen = new TimeStampRequestGenerator();
 
110
        TimeStampRequest          request = reqGen.generate(TSPAlgorithms.SHA1, new byte[20], BigInteger.valueOf(100));
 
111
 
 
112
        TimeStampResponseGenerator tsRespGen = new TimeStampResponseGenerator(tsTokenGen, TSPAlgorithms.ALLOWED);
 
113
 
 
114
        TimeStampResponse tsResp = tsRespGen.generate(request, new BigInteger("23"), new Date(), "BC");
 
115
 
 
116
        tsResp = new TimeStampResponse(tsResp.getEncoded());
 
117
 
 
118
        TimeStampToken  tsToken = tsResp.getTimeStampToken();
 
119
 
 
120
        tsToken.validate(cert, "BC");
 
121
        
 
122
        //
 
123
        // check validation
 
124
        //
 
125
        tsResp.validate(request);
 
126
        
 
127
        try
 
128
        {
 
129
            request = reqGen.generate(TSPAlgorithms.SHA1, new byte[20], BigInteger.valueOf(101));
 
130
            
 
131
            tsResp.validate(request);
 
132
            
 
133
            fail("response validation failed on invalid nonce.");
 
134
        }
 
135
        catch (TSPValidationException e)
 
136
        {
 
137
            // ignore
 
138
        }
 
139
 
 
140
        try
 
141
        {
 
142
            request = reqGen.generate(TSPAlgorithms.SHA1, new byte[22], BigInteger.valueOf(100));
 
143
            
 
144
            tsResp.validate(request);
 
145
            
 
146
            fail("response validation failed on wrong digest.");
 
147
        }
 
148
        catch (TSPValidationException e)
 
149
        {
 
150
            // ignore
 
151
        }
 
152
        
 
153
        try
 
154
        {
 
155
            request = reqGen.generate(TSPAlgorithms.MD5, new byte[20], BigInteger.valueOf(100));
 
156
            
 
157
            tsResp.validate(request);
 
158
            
 
159
            fail("response validation failed on wrong digest.");
 
160
        }
 
161
        catch (TSPValidationException e)
 
162
        {
 
163
            // ignore
 
164
        }
 
165
    }
 
166
    
 
167
    private void incorrectHashTest(
 
168
        PrivateKey      privateKey,
 
169
        X509Certificate cert,
 
170
        CertStore       certs)
 
171
        throws Exception
 
172
    {
 
173
        TimeStampTokenGenerator tsTokenGen = new TimeStampTokenGenerator(
 
174
                privateKey, cert, TSPAlgorithms.SHA1, "1.2");
 
175
        
 
176
        tsTokenGen.setCertificatesAndCRLs(certs);
 
177
 
 
178
        TimeStampRequestGenerator reqGen = new TimeStampRequestGenerator();
 
179
        TimeStampRequest            request = reqGen.generate(TSPAlgorithms.SHA1, new byte[16]);
 
180
 
 
181
        TimeStampResponseGenerator tsRespGen = new TimeStampResponseGenerator(tsTokenGen, TSPAlgorithms.ALLOWED);
 
182
 
 
183
        TimeStampResponse tsResp = tsRespGen.generate(request, new BigInteger("23"), new Date(), "BC");
 
184
 
 
185
        tsResp = new TimeStampResponse(tsResp.getEncoded());
 
186
 
 
187
        TimeStampToken  tsToken = tsResp.getTimeStampToken();
 
188
 
 
189
        if (tsToken != null)
 
190
        {
 
191
            fail("incorrectHash - token not null.");
 
192
        }
 
193
        
 
194
        PKIFailureInfo  failInfo = tsResp.getFailInfo();
 
195
        
 
196
        if (failInfo == null)
 
197
        {
 
198
            fail("incorrectHash - failInfo set to null.");
 
199
        }
 
200
        
 
201
        if (failInfo.intValue() != PKIFailureInfo.badDataFormat)
 
202
        {
 
203
            fail("incorrectHash - wrong failure info returned.");
 
204
        }
 
205
    }
 
206
    
 
207
    private void badAlgorithmTest(
 
208
        PrivateKey      privateKey,
 
209
        X509Certificate cert,
 
210
        CertStore       certs)
 
211
        throws Exception
 
212
    {
 
213
        TimeStampTokenGenerator tsTokenGen = new TimeStampTokenGenerator(
 
214
                privateKey, cert, TSPAlgorithms.SHA1, "1.2");
 
215
        
 
216
        tsTokenGen.setCertificatesAndCRLs(certs);
 
217
 
 
218
        TimeStampRequestGenerator reqGen = new TimeStampRequestGenerator();
 
219
        TimeStampRequest            request = reqGen.generate("1.2.3.4.5", new byte[20]);
 
220
 
 
221
        TimeStampResponseGenerator tsRespGen = new TimeStampResponseGenerator(tsTokenGen, TSPAlgorithms.ALLOWED);
 
222
 
 
223
        TimeStampResponse tsResp = tsRespGen.generate(request, new BigInteger("23"), new Date(), "BC");
 
224
 
 
225
        tsResp = new TimeStampResponse(tsResp.getEncoded());
 
226
 
 
227
        TimeStampToken  tsToken = tsResp.getTimeStampToken();
 
228
 
 
229
        if (tsToken != null)
 
230
        {
 
231
            fail("badAlgorithm - token not null.");
 
232
        }
 
233
 
 
234
        PKIFailureInfo  failInfo = tsResp.getFailInfo();
 
235
        
 
236
        if (failInfo == null)
 
237
        {
 
238
            fail("badAlgorithm - failInfo set to null.");
 
239
        }
 
240
        
 
241
        if (failInfo.intValue() != PKIFailureInfo.badAlg)
 
242
        {
 
243
            fail("badAlgorithm - wrong failure info returned.");
 
244
        }
 
245
    }
 
246
 
 
247
    private void timeNotAvailableTest(
 
248
        PrivateKey      privateKey,
 
249
        X509Certificate cert,
 
250
        CertStore       certs)
 
251
        throws Exception
 
252
    {
 
253
        TimeStampTokenGenerator tsTokenGen = new TimeStampTokenGenerator(
 
254
                privateKey, cert, TSPAlgorithms.SHA1, "1.2");
 
255
 
 
256
        tsTokenGen.setCertificatesAndCRLs(certs);
 
257
 
 
258
        TimeStampRequestGenerator reqGen = new TimeStampRequestGenerator();
 
259
        TimeStampRequest            request = reqGen.generate("1.2.3.4.5", new byte[20]);
 
260
 
 
261
        TimeStampResponseGenerator tsRespGen = new TimeStampResponseGenerator(tsTokenGen, TSPAlgorithms.ALLOWED);
 
262
 
 
263
        TimeStampResponse tsResp = tsRespGen.generate(request, new BigInteger("23"), null, "BC");
 
264
 
 
265
        tsResp = new TimeStampResponse(tsResp.getEncoded());
 
266
 
 
267
        TimeStampToken  tsToken = tsResp.getTimeStampToken();
 
268
 
 
269
        if (tsToken != null)
 
270
        {
 
271
            fail("timeNotAvailable - token not null.");
 
272
        }
 
273
 
 
274
        PKIFailureInfo  failInfo = tsResp.getFailInfo();
 
275
 
 
276
        if (failInfo == null)
 
277
        {
 
278
            fail("timeNotAvailable - failInfo set to null.");
 
279
        }
 
280
 
 
281
        if (failInfo.intValue() != PKIFailureInfo.timeNotAvailable)
 
282
        {
 
283
            fail("timeNotAvailable - wrong failure info returned.");
 
284
        }
 
285
    }
 
286
 
 
287
    private void badPolicyTest(
 
288
        PrivateKey      privateKey,
 
289
        X509Certificate cert,
 
290
        CertStore       certs)
 
291
        throws Exception
 
292
    {
 
293
        TimeStampTokenGenerator tsTokenGen = new TimeStampTokenGenerator(
 
294
                privateKey, cert, TSPAlgorithms.SHA1, "1.2");
 
295
        
 
296
        tsTokenGen.setCertificatesAndCRLs(certs);
 
297
 
 
298
        TimeStampRequestGenerator reqGen = new TimeStampRequestGenerator();
 
299
        
 
300
        reqGen.setReqPolicy("1.1");
 
301
        
 
302
        TimeStampRequest            request = reqGen.generate(TSPAlgorithms.SHA1, new byte[20]);
 
303
 
 
304
        TimeStampResponseGenerator tsRespGen = new TimeStampResponseGenerator(tsTokenGen, TSPAlgorithms.ALLOWED, new HashSet());
 
305
 
 
306
        TimeStampResponse tsResp = tsRespGen.generate(request, new BigInteger("23"), new Date(), "BC");
 
307
 
 
308
        tsResp = new TimeStampResponse(tsResp.getEncoded());
 
309
 
 
310
        TimeStampToken  tsToken = tsResp.getTimeStampToken();
 
311
 
 
312
        if (tsToken != null)
 
313
        {
 
314
            fail("badPolicy - token not null.");
 
315
        }
 
316
 
 
317
        PKIFailureInfo  failInfo = tsResp.getFailInfo();
 
318
        
 
319
        if (failInfo == null)
 
320
        {
 
321
            fail("badPolicy - failInfo set to null.");
 
322
        }
 
323
        
 
324
        if (failInfo.intValue() != PKIFailureInfo.unacceptedPolicy)
 
325
        {
 
326
            fail("badPolicy - wrong failure info returned.");
 
327
        }
 
328
    }
 
329
    
 
330
    private void certReqTest(
 
331
        PrivateKey      privateKey,
 
332
        X509Certificate cert,
 
333
        CertStore       certs)
 
334
        throws Exception
 
335
    {
 
336
        TimeStampTokenGenerator tsTokenGen = new TimeStampTokenGenerator(
 
337
                privateKey, cert, TSPAlgorithms.MD5, "1.2");
 
338
        
 
339
        tsTokenGen.setCertificatesAndCRLs(certs);
 
340
        
 
341
        TimeStampRequestGenerator reqGen = new TimeStampRequestGenerator();
 
342
        
 
343
        //
 
344
        // request with certReq false
 
345
        //
 
346
        reqGen.setCertReq(false);
 
347
        
 
348
        TimeStampRequest          request = reqGen.generate(TSPAlgorithms.SHA1, new byte[20], BigInteger.valueOf(100));
 
349
 
 
350
        TimeStampResponseGenerator tsRespGen = new TimeStampResponseGenerator(tsTokenGen, TSPAlgorithms.ALLOWED);
 
351
 
 
352
        TimeStampResponse tsResp = tsRespGen.generate(request, new BigInteger("23"), new Date(), "BC");
 
353
        
 
354
        tsResp = new TimeStampResponse(tsResp.getEncoded());
 
355
 
 
356
        TimeStampToken  tsToken = tsResp.getTimeStampToken();
 
357
        
 
358
        assertNull(tsToken.getTimeStampInfo().getGenTimeAccuracy());  // check for abscence of accuracy
 
359
        
 
360
        assertEquals("1.2", tsToken.getTimeStampInfo().getPolicy());
 
361
        
 
362
        try
 
363
        {
 
364
            tsToken.validate(cert, "BC");
 
365
        }
 
366
        catch (TSPValidationException e)
 
367
        {
 
368
            fail("certReq(false) verification of token failed.");
 
369
        }
 
370
 
 
371
        CertStore   respCerts = tsToken.getCertificatesAndCRLs("Collection", "BC");
 
372
        
 
373
        Collection  certsColl = respCerts.getCertificates(null);
 
374
        
 
375
        if (!certsColl.isEmpty())
 
376
        {
 
377
            fail("certReq(false) found certificates in response.");
 
378
        }
 
379
    }
 
380
    
 
381
    
 
382
    private void tokenEncodingTest(
 
383
        PrivateKey      privateKey,
 
384
        X509Certificate cert,
 
385
        CertStore       certs)
 
386
        throws Exception
 
387
    {
 
388
        TimeStampTokenGenerator tsTokenGen = new TimeStampTokenGenerator(
 
389
                privateKey, cert, TSPAlgorithms.SHA1, "1.2.3.4.5.6");
 
390
        
 
391
        tsTokenGen.setCertificatesAndCRLs(certs);
 
392
 
 
393
        TimeStampRequestGenerator  reqGen = new TimeStampRequestGenerator();
 
394
        TimeStampRequest           request = reqGen.generate(TSPAlgorithms.SHA1, new byte[20], BigInteger.valueOf(100));
 
395
        TimeStampResponseGenerator tsRespGen = new TimeStampResponseGenerator(tsTokenGen, TSPAlgorithms.ALLOWED);
 
396
        TimeStampResponse          tsResp = tsRespGen.generate(request, new BigInteger("23"), new Date(), "BC");
 
397
 
 
398
        tsResp = new TimeStampResponse(tsResp.getEncoded());
 
399
 
 
400
        TimeStampResponse tsResponse = new TimeStampResponse(tsResp.getEncoded());
 
401
 
 
402
        if (!Arrays.areEqual(tsResponse.getEncoded(), tsResp.getEncoded())
 
403
            || !Arrays.areEqual(tsResponse.getTimeStampToken().getEncoded(),
 
404
                        tsResp.getTimeStampToken().getEncoded()))
 
405
        {
 
406
            fail();
 
407
        }
 
408
    }
 
409
    
 
410
    private void testAccuracyZeroCerts(
 
411
        PrivateKey      privateKey,
 
412
        X509Certificate cert,
 
413
        CertStore       certs)
 
414
        throws Exception
 
415
    {
 
416
        TimeStampTokenGenerator tsTokenGen = new TimeStampTokenGenerator(
 
417
                privateKey, cert, TSPAlgorithms.MD5, "1.2");
 
418
        
 
419
        tsTokenGen.setCertificatesAndCRLs(certs);
 
420
 
 
421
        tsTokenGen.setAccuracySeconds(1);
 
422
        tsTokenGen.setAccuracyMillis(2);
 
423
        tsTokenGen.setAccuracyMicros(3);
 
424
        
 
425
        TimeStampRequestGenerator reqGen = new TimeStampRequestGenerator();
 
426
        TimeStampRequest          request = reqGen.generate(TSPAlgorithms.SHA1, new byte[20], BigInteger.valueOf(100));
 
427
 
 
428
        TimeStampResponseGenerator tsRespGen = new TimeStampResponseGenerator(tsTokenGen, TSPAlgorithms.ALLOWED);
 
429
 
 
430
        TimeStampResponse tsResp = tsRespGen.generate(request, new BigInteger("23"), new Date(), "BC");
 
431
 
 
432
        tsResp = new TimeStampResponse(tsResp.getEncoded());
 
433
 
 
434
        TimeStampToken  tsToken = tsResp.getTimeStampToken();
 
435
 
 
436
        tsToken.validate(cert, "BC");
 
437
        
 
438
        //
 
439
        // check validation
 
440
        //
 
441
        tsResp.validate(request);
 
442
 
 
443
        //
 
444
        // check tstInfo
 
445
        //
 
446
        TimeStampTokenInfo tstInfo = tsToken.getTimeStampInfo();
 
447
        
 
448
        //
 
449
        // check accuracy
 
450
        //
 
451
        GenTimeAccuracy accuracy = tstInfo.getGenTimeAccuracy();
 
452
        
 
453
        assertEquals(1, accuracy.getSeconds());
 
454
        assertEquals(2, accuracy.getMillis());
 
455
        assertEquals(3, accuracy.getMicros());
 
456
        
 
457
        assertEquals(new BigInteger("23"), tstInfo.getSerialNumber());
 
458
        
 
459
        assertEquals("1.2", tstInfo.getPolicy());
 
460
        
 
461
        //
 
462
        // test certReq
 
463
        //
 
464
        CertStore store = tsToken.getCertificatesAndCRLs("Collection", "BC");
 
465
        
 
466
        Collection certificates = store.getCertificates(null);
 
467
        
 
468
        assertEquals(0, certificates.size());
 
469
    }
 
470
    
 
471
    private void testAccuracyWithCertsAndOrdering(
 
472
        PrivateKey      privateKey,
 
473
        X509Certificate cert,
 
474
        CertStore       certs)
 
475
        throws Exception
 
476
    {
 
477
        TimeStampTokenGenerator tsTokenGen = new TimeStampTokenGenerator(
 
478
                privateKey, cert, TSPAlgorithms.MD5, "1.2.3");
 
479
        
 
480
        tsTokenGen.setCertificatesAndCRLs(certs);
 
481
 
 
482
        tsTokenGen.setAccuracySeconds(3);
 
483
        tsTokenGen.setAccuracyMillis(1);
 
484
        tsTokenGen.setAccuracyMicros(2);
 
485
        
 
486
        tsTokenGen.setOrdering(true);
 
487
        
 
488
        TimeStampRequestGenerator reqGen = new TimeStampRequestGenerator();
 
489
        
 
490
        reqGen.setCertReq(true);
 
491
        
 
492
        TimeStampRequest          request = reqGen.generate(TSPAlgorithms.SHA1, new byte[20], BigInteger.valueOf(100));
 
493
 
 
494
        assertTrue(request.getCertReq());
 
495
        
 
496
        TimeStampResponseGenerator tsRespGen = new TimeStampResponseGenerator(tsTokenGen, TSPAlgorithms.ALLOWED);
 
497
 
 
498
        TimeStampResponse tsResp = tsRespGen.generate(request, new BigInteger("23"), new Date(), "BC");
 
499
 
 
500
        tsResp = new TimeStampResponse(tsResp.getEncoded());
 
501
 
 
502
        TimeStampToken  tsToken = tsResp.getTimeStampToken();
 
503
 
 
504
        tsToken.validate(cert, "BC");
 
505
        
 
506
        //
 
507
        // check validation
 
508
        //
 
509
        tsResp.validate(request);
 
510
 
 
511
        //
 
512
        // check tstInfo
 
513
        //
 
514
        TimeStampTokenInfo tstInfo = tsToken.getTimeStampInfo();
 
515
        
 
516
        //
 
517
        // check accuracy
 
518
        //
 
519
        GenTimeAccuracy accuracy = tstInfo.getGenTimeAccuracy();
 
520
        
 
521
        assertEquals(3, accuracy.getSeconds());
 
522
        assertEquals(1, accuracy.getMillis());
 
523
        assertEquals(2, accuracy.getMicros());
 
524
        
 
525
        assertEquals(new BigInteger("23"), tstInfo.getSerialNumber());
 
526
        
 
527
        assertEquals("1.2.3", tstInfo.getPolicy());
 
528
        
 
529
        assertEquals(true, tstInfo.isOrdered());
 
530
        
 
531
        assertEquals(tstInfo.getNonce(), BigInteger.valueOf(100));
 
532
        
 
533
        //
 
534
        // test certReq
 
535
        //
 
536
        CertStore store = tsToken.getCertificatesAndCRLs("Collection", "BC");
 
537
        
 
538
        Collection certificates = store.getCertificates(null);
 
539
        
 
540
        assertEquals(2, certificates.size());
 
541
    }   
 
542
    
 
543
    private void testNoNonse(
 
544
        PrivateKey      privateKey,
 
545
        X509Certificate cert,
 
546
        CertStore       certs)
 
547
        throws Exception
 
548
    {
 
549
        TimeStampTokenGenerator tsTokenGen = new TimeStampTokenGenerator(
 
550
                privateKey, cert, TSPAlgorithms.MD5, "1.2.3");
 
551
        
 
552
        tsTokenGen.setCertificatesAndCRLs(certs);
 
553
        
 
554
        TimeStampRequestGenerator reqGen = new TimeStampRequestGenerator();
 
555
        TimeStampRequest          request = reqGen.generate(TSPAlgorithms.SHA1, new byte[20]);
 
556
 
 
557
        assertFalse(request.getCertReq());
 
558
        
 
559
        TimeStampResponseGenerator tsRespGen = new TimeStampResponseGenerator(tsTokenGen, TSPAlgorithms.ALLOWED);
 
560
 
 
561
        TimeStampResponse tsResp = tsRespGen.generate(request, new BigInteger("24"), new Date(), "BC");
 
562
 
 
563
        tsResp = new TimeStampResponse(tsResp.getEncoded());
 
564
 
 
565
        TimeStampToken  tsToken = tsResp.getTimeStampToken();
 
566
 
 
567
        tsToken.validate(cert, "BC");
 
568
        
 
569
        //
 
570
        // check validation
 
571
        //
 
572
        tsResp.validate(request);
 
573
 
 
574
        //
 
575
        // check tstInfo
 
576
        //
 
577
        TimeStampTokenInfo tstInfo = tsToken.getTimeStampInfo();
 
578
        
 
579
        //
 
580
        // check accuracy
 
581
        //
 
582
        GenTimeAccuracy accuracy = tstInfo.getGenTimeAccuracy();
 
583
        
 
584
        assertNull(accuracy);
 
585
        
 
586
        assertEquals(new BigInteger("24"), tstInfo.getSerialNumber());
 
587
        
 
588
        assertEquals("1.2.3", tstInfo.getPolicy());
 
589
        
 
590
        assertEquals(false, tstInfo.isOrdered());
 
591
        
 
592
        assertNull(tstInfo.getNonce());
 
593
        
 
594
        //
 
595
        // test certReq
 
596
        //
 
597
        CertStore store = tsToken.getCertificatesAndCRLs("Collection", "BC");
 
598
        
 
599
        Collection certificates = store.getCertificates(null);
 
600
        
 
601
        assertEquals(0, certificates.size());
 
602
    } 
 
603
}