~brian-thomason/+junk/bouncycastle

byte[] text = { (byte)'h', (byte)'e', (byte)'l', (byte)'l', (byte)'o', (byte)' ', (byte)'w', (byte)'o', (byte)'r', (byte)'l', (byte)'d', (byte)'!', (byte)'\n' };

405

406

407

// literal data

408

409

ByteArrayOutputStream bOut = new ByteArrayOutputStream();

410

PGPLiteralDataGenerator lGen = new PGPLiteralDataGenerator();

411

OutputStream lOut = lGen.open(bOut, PGPLiteralData.BINARY, PGPLiteralData.CONSOLE, text.length, new Date());

412

413

lOut.write(text);

414

415

lGen.close();

416

417

byte[] bytes = bOut.toByteArray();

418

419

PGPObjectFactory f = new PGPObjectFactory(bytes);

420

checkLiteralData((PGPLiteralData)f.nextObject(), text);

421

422

ByteArrayOutputStream bcOut = new ByteArrayOutputStream();

423

424

PGPEncryptedDataGenerator encGen = new PGPEncryptedDataGenerator(SymmetricKeyAlgorithmTags.AES_128, true, new SecureRandom(), "BC");

425

426

encGen.addMethod(pgpPubKey);

427

428

encGen.addMethod("password".toCharArray());

429

430

OutputStream cOut = encGen.open(bcOut, bytes.length);

431

432

cOut.write(bytes);

433

434

cOut.close();

435

436

byte[] encData = bcOut.toByteArray();

437

438

439

// asymmetric

440

441

PGPObjectFactory pgpF = new PGPObjectFactory(encData);

442

443

PGPEncryptedDataList encList = (PGPEncryptedDataList)pgpF.nextObject();

444

445

PGPPublicKeyEncryptedData encP = (PGPPublicKeyEncryptedData)encList.get(0);

446

447

InputStream clear = encP.getDataStream(pgpPrivKey, "BC");

448

449

PGPObjectFactory pgpFact = new PGPObjectFactory(clear);

450

451

checkLiteralData((PGPLiteralData)pgpFact.nextObject(), text);

452

453

454

// PBE

455

456

pgpF = new PGPObjectFactory(encData);

457

458

encList = (PGPEncryptedDataList)pgpF.nextObject();

459

460

PGPPBEEncryptedData encPbe = (PGPPBEEncryptedData)encList.get(1);

461

462

clear = encPbe.getDataStream("password".toCharArray(), "BC");

463

464

pgpF = new PGPObjectFactory(clear);

465

466

checkLiteralData((PGPLiteralData)pgpF.nextObject(), text);

467

}

468

469

private void checkLiteralData(PGPLiteralData ld, byte[] data)

470

throws IOException

471

{

472

ByteArrayOutputStream bOut = new ByteArrayOutputStream();

473

474

if (!ld.getFileName().equals(PGPLiteralData.CONSOLE))

475

{

476

throw new RuntimeException("wrong filename in packet");

477

}

478

479

InputStream inLd = ld.getDataStream();

480

int ch;

481

482

while ((ch = inLd.read()) >= 0)

483

{

484

bOut.write(ch);

485

}

486

487

if (!areEqual(bOut.toByteArray(), data))

488

{

489

fail("wrong plain text in decrypted packet");

490

}

491

}

492

493

private void existingEmbeddedJpegTest()

494

throws Exception

495

{

496

PGPPublicKeyRing pgpPub = new PGPPublicKeyRing(embeddedJPEGKey);

497

498

PGPPublicKey pubKey = pgpPub.getPublicKey();

499

500

Iterator it = pubKey.getUserAttributes();

501

int count = 0;

502

while (it.hasNext())

503

{

504

PGPUserAttributeSubpacketVector attributes = (PGPUserAttributeSubpacketVector)it.next();

505

506

Iterator sigs = pubKey.getSignaturesForUserAttribute(attributes);

507

int sigCount = 0;

508

while (sigs.hasNext())

509

{

510

PGPSignature sig = (PGPSignature)sigs.next();

511

512

sig.initVerify(pubKey, "BC");

513

514

if (!sig.verifyCertification(attributes, pubKey))

515

{

516

fail("signature failed verification");

517

}

518

519

sigCount++;

520

}

521

522

if (sigCount != 1)

523

{

524

fail("Failed user attributes signature check");

525

}

526

count++;

527

}

528

529

if (count != 1)

530

{

531

fail("didn't find user attributes");

532

}

533

}

534

535

private void embeddedJpegTest()

536

throws Exception

537

{

538

PGPPublicKeyRing pgpPub = new PGPPublicKeyRing(testPubKey);

539

PGPSecretKeyRing pgpSec = new PGPSecretKeyRing(testPrivKey);

540

541

PGPPublicKey pubKey = pgpPub.getPublicKey();

542

543

PGPUserAttributeSubpacketVectorGenerator vGen = new PGPUserAttributeSubpacketVectorGenerator();

544

545

vGen.setImageAttribute(ImageAttribute.JPEG, jpegImage);

546

547

PGPUserAttributeSubpacketVector uVec = vGen.generate();

548

549

PGPSignatureGenerator sGen = new PGPSignatureGenerator(PublicKeyAlgorithmTags.RSA_GENERAL, HashAlgorithmTags.SHA1, "BC");

550

551

sGen.initSign(PGPSignature.POSITIVE_CERTIFICATION, pgpSec.getSecretKey().extractPrivateKey(pass, "BC"));

552

553

PGPSignature sig = sGen.generateCertification(uVec, pubKey);

554

555

PGPPublicKey nKey = PGPPublicKey.addCertification(pubKey, uVec, sig);

556

557

Iterator it = nKey.getUserAttributes();

558

int count = 0;

559

while (it.hasNext())

560

{

561

PGPUserAttributeSubpacketVector attributes = (PGPUserAttributeSubpacketVector)it.next();

562

563

Iterator sigs = nKey.getSignaturesForUserAttribute(attributes);

564

int sigCount = 0;

565

while (sigs.hasNext())

566

{

567

PGPSignature s = (PGPSignature)sigs.next();

568

569

s.initVerify(pubKey, "BC");

570

571

if (!s.verifyCertification(attributes, pubKey))

572

{

573

fail("added signature failed verification");

574

}

575

576

sigCount++;

577

}

578

579

if (sigCount != 1)

580

{

581

fail("Failed added user attributes signature check");

582

}

583

count++;

584

}

585

586

if (count != 1)

587

{

588

fail("didn't find added user attributes");

589

}

590

591

nKey = PGPPublicKey.removeCertification(nKey, uVec);

592

count = 0;

593

for (it = nKey.getUserAttributes(); it.hasNext();)

594

{

595

count++;

596

}

597

if (count != 0)

598

{

599

fail("found attributes where none expected");

600

}

601

}

602

603

public void performTest()

604

throws Exception

605

{

606

PublicKey pubKey = null;

607

608

609

// Read the public key

610

611

PGPPublicKeyRing pgpPub = new PGPPublicKeyRing(testPubKey);

612

613

pubKey = pgpPub.getPublicKey().getKey("BC");

614

615

Iterator it = pgpPub.getPublicKey().getUserIDs();

616

617

String uid = (String)it.next();

618

619

it = pgpPub.getPublicKey().getSignaturesForID(uid);

620

621

PGPSignature sig = (PGPSignature)it.next();

622

623

sig.initVerify(pgpPub.getPublicKey(), "BC");

624

625

if (!sig.verifyCertification(uid, pgpPub.getPublicKey()))

626

{

627

fail("failed to verify certification");

628

}

629

630

631

// write a public key

632

633

ByteArrayOutputStream bOut = new ByteArrayOutputStream();

634

BCPGOutputStream pOut = new BCPGOutputStream(bOut);

635

636

pgpPub.encode(pOut);

637

638

if (!areEqual(bOut.toByteArray(), testPubKey))

639

{

640

fail("public key rewrite failed");

641

}

642

643

644

// Read the public key

645

646

PGPPublicKeyRing pgpPubV3 = new PGPPublicKeyRing(testPubKeyV3);

647

PublicKey pubKeyV3 = pgpPub.getPublicKey().getKey("BC");

648

649

650

// write a V3 public key

651

652

bOut = new ByteArrayOutputStream();

653

pOut = new BCPGOutputStream(bOut);

654

655

pgpPubV3.encode(pOut);

656

657

658

// Read a v3 private key

659

660

char[] passP = "FIXCITY_QA".toCharArray();

661

662

if (!noIDEA())

663

{

664

PGPSecretKeyRing pgpPriv = new PGPSecretKeyRing(testPrivKeyV3);

665

PGPPrivateKey pgpPrivKey = pgpPriv.getSecretKey().extractPrivateKey(passP, "BC");

666

667

668

// write a v3 private key

669

670

bOut = new ByteArrayOutputStream();

671

pOut = new BCPGOutputStream(bOut);

672

673

pgpPriv.encode(pOut);

674

675

if (!areEqual(bOut.toByteArray(), testPrivKeyV3))

676

{

677

fail("private key V3 rewrite failed");

678

}

679

}

680

681

682

// Read the private key

683

684

PGPSecretKeyRing pgpPriv = new PGPSecretKeyRing(testPrivKey);

685

PGPPrivateKey pgpPrivKey = pgpPriv.getSecretKey().extractPrivateKey(pass, "BC");

686

687

688

// write a private key

689

690

bOut = new ByteArrayOutputStream();

691

pOut = new BCPGOutputStream(bOut);

692

693

pgpPriv.encode(pOut);

694

695

if (!areEqual(bOut.toByteArray(), testPrivKey))

696

{

697

fail("private key rewrite failed");

698

}

699

700

701

702

// test encryption

703

704

Cipher c = Cipher.getInstance("RSA", "BC");

705

706

c.init(Cipher.ENCRYPT_MODE, pubKey);

707

708

byte[] in = "hello world".getBytes();

709

710

byte[] out = c.doFinal(in);

711

712

c.init(Cipher.DECRYPT_MODE, pgpPrivKey.getKey());

713

714

out = c.doFinal(out);

715

716

if (!areEqual(in, out))

717

{

718

fail("decryption failed.");

719

}

720

721

722

// test signature message

723

724

PGPObjectFactory pgpFact = new PGPObjectFactory(sig1);

725

726

PGPCompressedData c1 = (PGPCompressedData)pgpFact.nextObject();

727

728

pgpFact = new PGPObjectFactory(c1.getDataStream());

729

730

PGPOnePassSignatureList p1 = (PGPOnePassSignatureList)pgpFact.nextObject();

731

732

PGPOnePassSignature ops = p1.get(0);

733

734

PGPLiteralData p2 = (PGPLiteralData)pgpFact.nextObject();

735

736

InputStream dIn = p2.getInputStream();

737

int ch;

738

739

ops.initVerify(pgpPub.getPublicKey(ops.getKeyID()), "BC");

740

741

while ((ch = dIn.read()) >= 0)

742

{

743

ops.update((byte)ch);

744

}

745

746

PGPSignatureList p3 = (PGPSignatureList)pgpFact.nextObject();

747

748

if (!ops.verify(p3.get(0)))

749

{

750

fail("Failed signature check");

751

}

752

753

754

// encrypted message - read subkey

755

756

pgpPriv = new PGPSecretKeyRing(subKey);

757

758

759

// encrypted message

760

761

byte[] text = { (byte)'h', (byte)'e', (byte)'l', (byte)'l', (byte)'o', (byte)' ', (byte)'w', (byte)'o', (byte)'r', (byte)'l', (byte)'d', (byte)'!', (byte)'\n' };

762

763

PGPObjectFactory pgpF = new PGPObjectFactory(enc1);

764

765

PGPEncryptedDataList encList = (PGPEncryptedDataList)pgpF.nextObject();

766

767

PGPPublicKeyEncryptedData encP = (PGPPublicKeyEncryptedData)encList.get(0);

768

769

pgpPrivKey = pgpPriv.getSecretKey(encP.getKeyID()).extractPrivateKey(pass, "BC");

770

771

InputStream clear = encP.getDataStream(pgpPrivKey, "BC");

772

773

pgpFact = new PGPObjectFactory(clear);

774

775

c1 = (PGPCompressedData)pgpFact.nextObject();

776

777

pgpFact = new PGPObjectFactory(c1.getDataStream());

778

779

PGPLiteralData ld = (PGPLiteralData)pgpFact.nextObject();

780

781

bOut = new ByteArrayOutputStream();

782

783

if (!ld.getFileName().equals("test.txt"))

784

{

785

throw new RuntimeException("wrong filename in packet");

786

}

787

788

InputStream inLd = ld.getDataStream();

789

790

while ((ch = inLd.read()) >= 0)

791

{

792

bOut.write(ch);

793

}

794

795

if (!areEqual(bOut.toByteArray(), text))

796

{

797

fail("wrong plain text in decrypted packet");

798

}

799

800

801

// encrypt - short message

802

803

byte[] shortText = { (byte)'h', (byte)'e', (byte)'l', (byte)'l', (byte)'o' };

804

805

ByteArrayOutputStream cbOut = new ByteArrayOutputStream();

806

PGPEncryptedDataGenerator cPk = new PGPEncryptedDataGenerator(SymmetricKeyAlgorithmTags.CAST5, new SecureRandom(), "BC");

807

PGPPublicKey puK = pgpPriv.getSecretKey(encP.getKeyID()).getPublicKey();

808

809

cPk.addMethod(puK);

810

811

OutputStream cOut = cPk.open(new UncloseableOutputStream(cbOut), shortText.length);

812

813

cOut.write(shortText);

814

815

cOut.close();

816

817

pgpF = new PGPObjectFactory(cbOut.toByteArray());

818

819

encList = (PGPEncryptedDataList)pgpF.nextObject();

820

821

encP = (PGPPublicKeyEncryptedData)encList.get(0);

822

823

pgpPrivKey = pgpPriv.getSecretKey(encP.getKeyID()).extractPrivateKey(pass, "BC");

824

825

if (encP.getSymmetricAlgorithm(pgpPrivKey, "BC") != SymmetricKeyAlgorithmTags.CAST5)

826

{

827

fail("symmetric algorithm mismatch");

828

}

829

830

clear = encP.getDataStream(pgpPrivKey, "BC");

831

832

bOut.reset();

833

834

while ((ch = clear.read()) >= 0)

835

{

836

bOut.write(ch);

837

}

838

839

out = bOut.toByteArray();

840

841

if (!areEqual(out, shortText))

842

{

843

fail("wrong plain text in generated short text packet");

844

}

845

846

847

// encrypt

848

849

cbOut = new ByteArrayOutputStream();

850

cPk = new PGPEncryptedDataGenerator(SymmetricKeyAlgorithmTags.CAST5, new SecureRandom(), "BC");

851

puK = pgpPriv.getSecretKey(encP.getKeyID()).getPublicKey();

852

853

cPk.addMethod(puK);

854

855

cOut = cPk.open(new UncloseableOutputStream(cbOut), text.length);

856

857

cOut.write(text);

858

859

cOut.close();

860

861

pgpF = new PGPObjectFactory(cbOut.toByteArray());

862

863

encList = (PGPEncryptedDataList)pgpF.nextObject();

864

865

encP = (PGPPublicKeyEncryptedData)encList.get(0);

866

867

pgpPrivKey = pgpPriv.getSecretKey(encP.getKeyID()).extractPrivateKey(pass, "BC");

868

869

clear = encP.getDataStream(pgpPrivKey, "BC");

870

871

bOut.reset();

872

873

while ((ch = clear.read()) >= 0)

874

{

875

bOut.write(ch);

876

}

877

878

out = bOut.toByteArray();

879

880

if (!areEqual(out, text))

881

{

882

fail("wrong plain text in generated packet");

883

}

884

885

886

// read public key with sub key.

887

888

pgpF = new PGPObjectFactory(subPubKey);

889

Object o;

890

891

while ((o = pgpFact.nextObject()) != null)

892

{

893

// System.out.println(o);

894

}

895

896

897

// key pair generation - CAST5 encryption

898

899

char[] passPhrase = "hello".toCharArray();

900

901

KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", "BC");

902

903

kpg.initialize(1024);

904

905

KeyPair kp = kpg.generateKeyPair();

906

907

PGPSecretKey secretKey = new PGPSecretKey(PGPSignature.DEFAULT_CERTIFICATION, PublicKeyAlgorithmTags.RSA_GENERAL, kp.getPublic(), kp.getPrivate(), new Date(), "fred", SymmetricKeyAlgorithmTags.CAST5, passPhrase, null, null, new SecureRandom(), "BC");

908

909

PGPPublicKey key = secretKey.getPublicKey();

910

911

it = key.getUserIDs();

912

913

uid = (String)it.next();

914

915

it = key.getSignaturesForID(uid);

916

917

sig = (PGPSignature)it.next();

918

919

sig.initVerify(key, "BC");

920

921

if (!sig.verifyCertification(uid, key))

922

{

923

fail("failed to verify certification");

924

}

925

926

pgpPrivKey = secretKey.extractPrivateKey(passPhrase, "BC");

927

928

key = PGPPublicKey.removeCertification(key, uid, sig);

929

930

if (key == null)

931

{

932

fail("failed certification removal");

933

}

934

935

byte[] keyEnc = key.getEncoded();

936

937

key = PGPPublicKey.addCertification(key, uid, sig);

938

939

keyEnc = key.getEncoded();

940

941

PGPSignatureGenerator sGen = new PGPSignatureGenerator(PublicKeyAlgorithmTags.RSA_GENERAL, HashAlgorithmTags.SHA1, "BC");

942

943

sGen.initSign(PGPSignature.KEY_REVOCATION, secretKey.extractPrivateKey(passPhrase, "BC"));

944

945

sig = sGen.generateCertification(key);

946

947

key = PGPPublicKey.addCertification(key, sig);

948

949

keyEnc = key.getEncoded();

950

951

PGPPublicKeyRing tmpRing = new PGPPublicKeyRing(keyEnc);

952

953

key = tmpRing.getPublicKey();

954

955

Iterator sgIt = key.getSignaturesOfType(PGPSignature.KEY_REVOCATION);

956

957

sig = (PGPSignature)sgIt.next();

958

959

sig.initVerify(key, "BC");

960

961

if (!sig.verifyCertification(key))

962

{

963

fail("failed to verify revocation certification");

964

}

965

966

967

// use of PGPKeyPair

968

969

PGPKeyPair pgpKp = new PGPKeyPair(PGPPublicKey.RSA_GENERAL , kp.getPublic(), kp.getPrivate(), new Date());

970

971

PGPPublicKey k1 = pgpKp.getPublicKey();

972

973

PGPPrivateKey k2 = pgpKp.getPrivateKey();

974

975

k1.getEncoded();

976

977

mixedTest(k2, k1);

978

979

980

// key pair generation - AES_256 encryption.

981

982

kp = kpg.generateKeyPair();

983

984

secretKey = new PGPSecretKey(PGPSignature.DEFAULT_CERTIFICATION, PublicKeyAlgorithmTags.RSA_GENERAL, kp.getPublic(), kp.getPrivate(), new Date(), "fred", SymmetricKeyAlgorithmTags.AES_256, passPhrase, null, null, new SecureRandom(), "BC");

985

986

secretKey.extractPrivateKey(passPhrase, "BC");

987

988

secretKey.encode(new ByteArrayOutputStream());

989

990

991

// secret key password changing.

992

993

String newPass = "newPass";

994

995

secretKey = PGPSecretKey.copyWithNewPassword(secretKey, passPhrase, newPass.toCharArray(), secretKey.getKeyEncryptionAlgorithm(), new SecureRandom(), "BC");

996

997

secretKey.extractPrivateKey(newPass.toCharArray(), "BC");

998

999

secretKey.encode(new ByteArrayOutputStream());

1000

1001

key = secretKey.getPublicKey();

1002

1003

key.encode(new ByteArrayOutputStream());

1004

1005

it = key.getUserIDs();

1006

1007

uid = (String)it.next();

1008

1009

it = key.getSignaturesForID(uid);

1010

1011

sig = (PGPSignature)it.next();

1012

1013

sig.initVerify(key, "BC");

1014

1015

if (!sig.verifyCertification(uid, key))

1016

{

1017

fail("failed to verify certification");

1018

}

1019

1020

pgpPrivKey = secretKey.extractPrivateKey(newPass.toCharArray(), "BC");

1021

1022

1023

// signature generation

1024

1025

String data = "hello world!";

1026

1027

bOut = new ByteArrayOutputStream();

1028

1029

ByteArrayInputStream testIn = new ByteArrayInputStream(data.getBytes());

1030

1031

sGen = new PGPSignatureGenerator(PublicKeyAlgorithmTags.RSA_GENERAL, HashAlgorithmTags.SHA1, "BC");

1032

1033

sGen.initSign(PGPSignature.BINARY_DOCUMENT, pgpPrivKey);

1034

1035

PGPCompressedDataGenerator cGen = new PGPCompressedDataGenerator(

1036

PGPCompressedData.ZIP);

1037

1038

BCPGOutputStream bcOut = new BCPGOutputStream(

1039

cGen.open(new UncloseableOutputStream(bOut)));

1040

1041

sGen.generateOnePassVersion(false).encode(bcOut);

1042

1043

PGPLiteralDataGenerator lGen = new PGPLiteralDataGenerator();

1044

1045

Date testDate = new Date((System.currentTimeMillis() / 1000) * 1000);

1046

OutputStream lOut = lGen.open(

1047

new UncloseableOutputStream(bcOut),

1048

PGPLiteralData.BINARY,

1049

"_CONSOLE",

1050

data.getBytes().length,

1051

testDate);

1052

1053

while ((ch = testIn.read()) >= 0)

1054

{

1055

lOut.write(ch);

1056

sGen.update((byte)ch);

1057

}

1058

1059

lOut.close();

1060

1061

sGen.generate().encode(bcOut);

1062

1063

bcOut.close();

1064

1065

1066

// verify generated signature

1067

1068

pgpFact = new PGPObjectFactory(bOut.toByteArray());

1069

1070

c1 = (PGPCompressedData)pgpFact.nextObject();

1071

1072

pgpFact = new PGPObjectFactory(c1.getDataStream());

1073

1074

p1 = (PGPOnePassSignatureList)pgpFact.nextObject();

1075

1076

ops = p1.get(0);

1077

1078

p2 = (PGPLiteralData)pgpFact.nextObject();

1079

if (!p2.getModificationTime().equals(testDate))

1080

{

1081

fail("Modification time not preserved: " + p2.getModificationTime() + " " + testDate);

1082

}

1083

1084

dIn = p2.getInputStream();

1085

1086

ops.initVerify(secretKey.getPublicKey(), "BC");

1087

1088

while ((ch = dIn.read()) >= 0)

1089

{

1090

ops.update((byte)ch);

1091

}

1092

1093

p3 = (PGPSignatureList)pgpFact.nextObject();

1094

1095

if (!ops.verify(p3.get(0)))

1096

{

1097

fail("Failed generated signature check");

1098

}

1099

1100

1101

// signature generation - version 3

1102

1103

bOut = new ByteArrayOutputStream();

1104

1105

testIn = new ByteArrayInputStream(data.getBytes());

1106

PGPV3SignatureGenerator sGenV3 = new PGPV3SignatureGenerator(PGPPublicKey.RSA_GENERAL, PGPUtil.SHA1, "BC");

1107

1108

sGen.initSign(PGPSignature.BINARY_DOCUMENT, pgpPrivKey);

1109

1110

cGen = new PGPCompressedDataGenerator(

1111

PGPCompressedData.ZIP);

1112

1113

bcOut = new BCPGOutputStream(cGen.open(bOut));

1114

1115

sGen.generateOnePassVersion(false).encode(bcOut);

1116

1117

lGen = new PGPLiteralDataGenerator();

1118

lOut = lGen.open(

1119

new UncloseableOutputStream(bcOut),

1120

PGPLiteralData.BINARY,

1121

"_CONSOLE",

1122

data.getBytes().length,

1123

testDate);

1124

1125

while ((ch = testIn.read()) >= 0)

1126

{

1127

lOut.write(ch);

1128

sGen.update((byte)ch);

1129

}

1130

1131

lOut.close();

1132

1133

sGen.generate().encode(bcOut);

1134

1135

bcOut.close();

1136

1137

1138

// verify generated signature

1139

1140

pgpFact = new PGPObjectFactory(bOut.toByteArray());

1141

1142

c1 = (PGPCompressedData)pgpFact.nextObject();

1143

1144

pgpFact = new PGPObjectFactory(c1.getDataStream());

1145

1146

p1 = (PGPOnePassSignatureList)pgpFact.nextObject();

1147

1148

ops = p1.get(0);

1149

1150

p2 = (PGPLiteralData)pgpFact.nextObject();

1151

if (!p2.getModificationTime().equals(testDate))

1152

{

1153

fail("Modification time not preserved");

1154

}

1155

1156

dIn = p2.getInputStream();

1157

1158

ops.initVerify(secretKey.getPublicKey(), "BC");

1159

1160

while ((ch = dIn.read()) >= 0)

1161

{

1162

ops.update((byte)ch);

1163

}

1164

1165

p3 = (PGPSignatureList)pgpFact.nextObject();

1166

1167

if (!ops.verify(p3.get(0)))

1168

{

1169

fail("Failed v3 generated signature check");

1170

}

1171

1172

1173

// extract PGP 8 private key

1174

1175

pgpPriv = new PGPSecretKeyRing(pgp8Key);

1176

1177

secretKey = pgpPriv.getSecretKey();

1178

1179

pgpPrivKey = secretKey.extractPrivateKey(pgp8Pass, "BC");

1180

1181

1182

// expiry

1183

1184

testExpiry(expiry60and30daysSig13Key, 60, 30);

1185

1186

fingerPrintTest();

1187

existingEmbeddedJpegTest();

1188

embeddedJpegTest();

1189

}

1190

1191

private void testExpiry(

1192

byte[] encodedRing,

1193

int masterDays,

1194

int subKeyDays)

1195

throws Exception

1196

{

1197

PGPPublicKeyRing pubRing = new PGPPublicKeyRing(encodedRing);

1198

PGPPublicKey k = pubRing.getPublicKey();

1199

1200

if (k.getValidDays() != masterDays)

1201

{

1202

fail("mismatch on master valid days.");

1203

}

1204

1205

Iterator it = pubRing.getPublicKeys();

1206

1207

it.next();

1208

1209

k = (PGPPublicKey)it.next();

1210

1211

if (k.getValidDays() != subKeyDays)

1212

{

1213

fail("mismatch on subkey valid days.");

1214

}

1215

}

1216

1217

private boolean noIDEA()

1218

{

1219

try

1220

{

1221

Cipher.getInstance("IDEA", "BC");

1222

1223

return false;

1224

}

1225

catch (Exception e)

1226

{

1227

return true;

1228

}

1229

}

1230

1231

public String getName()

1232

{

1233

return "PGPRSATest";

1234

}

1235

1236

public static void main(

1237

String[] args)

1238

{

1239

Security.addProvider(new BouncyCastleProvider());

1240

1241

runTest(new PGPRSATest());

1242

}

1243

}