Examples with UnprotectedKeysProtector org.pgpainless.key.protection.UnprotectedKeysProtector used on opensource projects

Example 1 with UnprotectedKeysProtector

use of org.pgpainless.key.protection.UnprotectedKeysProtector in project Smack by igniterealtime.

the class OpenPgpStoreTest method t00_store_protectorGetSet.

/*
    Generic
     */
@Test
public void t00_store_protectorGetSet() {
    openPgpStoreInstance1.setKeyRingProtector(new UnprotectedKeysProtector());
    assertNotNull(openPgpStoreInstance1.getKeyRingProtector());
    // TODO: Test method below
    openPgpStoreInstance1.setSecretKeyPassphraseCallback(new SecretKeyPassphraseCallback() {

        @Override
        public Passphrase onPassphraseNeeded(OpenPgpV4Fingerprint fingerprint) {
            return null;
        }
    });
}

Example 2 with UnprotectedKeysProtector

use of org.pgpainless.key.protection.UnprotectedKeysProtector in project Smack by igniterealtime.

the class OXSecretKeyBackupIntegrationTest method test.

@SmackIntegrationTest
public void test() throws InvalidAlgorithmParameterException, NoSuchAlgorithmException, NoSuchProviderException, IOException, InterruptedException, PubSubException.NotALeafNodeException, SmackException.NoResponseException, SmackException.NotConnectedException, XMPPException.XMPPErrorException, SmackException.NotLoggedInException, SmackException.FeatureNotSupportedException, MissingUserIdOnKeyException, NoBackupFoundException, InvalidBackupCodeException, PGPException, MissingOpenPgpKeyException {
    OpenPgpStore beforeStore = new FileBasedOpenPgpStore(beforePath);
    beforeStore.setKeyRingProtector(new UnprotectedKeysProtector());
    PainlessOpenPgpProvider beforeProvider = new PainlessOpenPgpProvider(beforeStore);
    OpenPgpManager openPgpManager = OpenPgpManager.getInstanceFor(aliceConnection);
    openPgpManager.setOpenPgpProvider(beforeProvider);
    OpenPgpSelf self = openPgpManager.getOpenPgpSelf();
    assertNull(self.getSigningKeyFingerprint());
    OpenPgpV4Fingerprint keyFingerprint = openPgpManager.generateAndImportKeyPair(alice);
    assertEquals(keyFingerprint, self.getSigningKeyFingerprint());
    assertTrue(self.getSecretKeys().contains(keyFingerprint.getKeyId()));
    PGPSecretKeyRing beforeSec = beforeStore.getSecretKeyRing(alice, keyFingerprint);
    assertNotNull(beforeSec);
    PGPPublicKeyRing beforePub = beforeStore.getPublicKeyRing(alice, keyFingerprint);
    assertNotNull(beforePub);
    OpenPgpSecretKeyBackupPassphrase backupPassphrase = openPgpManager.backupSecretKeyToServer(availableSecretKeys -> availableSecretKeys);
    FileBasedOpenPgpStore afterStore = new FileBasedOpenPgpStore(afterPath);
    afterStore.setKeyRingProtector(new UnprotectedKeysProtector());
    PainlessOpenPgpProvider afterProvider = new PainlessOpenPgpProvider(afterStore);
    openPgpManager.setOpenPgpProvider(afterProvider);
    OpenPgpV4Fingerprint fingerprint = openPgpManager.restoreSecretKeyServerBackup(() -> backupPassphrase);
    assertEquals(keyFingerprint, fingerprint);
    assertTrue(self.getSecretKeys().contains(keyFingerprint.getKeyId()));
    assertEquals(keyFingerprint, self.getSigningKeyFingerprint());
    PGPSecretKeyRing afterSec = afterStore.getSecretKeyRing(alice, keyFingerprint);
    assertNotNull(afterSec);
    assertArrayEquals(beforeSec.getEncoded(), afterSec.getEncoded());
    PGPPublicKeyRing afterPub = afterStore.getPublicKeyRing(alice, keyFingerprint);
    assertNotNull(afterPub);
    assertArrayEquals(beforePub.getEncoded(), afterPub.getEncoded());
}

Example 3 with UnprotectedKeysProtector

use of org.pgpainless.key.protection.UnprotectedKeysProtector in project Smack by igniterealtime.

the class OXInstantMessagingIntegrationTest method basicInstantMessagingTest.

@SmackIntegrationTest
public void basicInstantMessagingTest() throws Exception {
    final SimpleResultSyncPoint bobReceivedMessage = new SimpleResultSyncPoint();
    final String body = "Writing integration tests is an annoying task, but it has to be done, so lets do it!!!";
    FileBasedOpenPgpStore aliceStore = new FileBasedOpenPgpStore(aliceStorePath);
    aliceStore.setKeyRingProtector(new UnprotectedKeysProtector());
    FileBasedOpenPgpStore bobStore = new FileBasedOpenPgpStore(bobStorePath);
    bobStore.setKeyRingProtector(new UnprotectedKeysProtector());
    PainlessOpenPgpProvider aliceProvider = new PainlessOpenPgpProvider(aliceStore);
    PainlessOpenPgpProvider bobProvider = new PainlessOpenPgpProvider(bobStore);
    aliceOpenPgp = OpenPgpManager.getInstanceFor(aliceConnection);
    bobOpenPgp = OpenPgpManager.getInstanceFor(bobConnection);
    OXInstantMessagingManager aliceInstantMessaging = OXInstantMessagingManager.getInstanceFor(aliceConnection);
    OXInstantMessagingManager bobInstantMessaging = OXInstantMessagingManager.getInstanceFor(bobConnection);
    bobInstantMessaging.addOxMessageListener(new OxMessageListener() {

        @Override
        public void newIncomingOxMessage(OpenPgpContact contact, Message originalMessage, SigncryptElement decryptedPayload, OpenPgpMetadata metadata) {
            if (((Message.Body) decryptedPayload.getExtension(Message.Body.NAMESPACE)).getMessage().equals(body)) {
                bobReceivedMessage.signal();
            } else {
                bobReceivedMessage.signalFailure();
            }
        }
    });
    aliceOpenPgp.setOpenPgpProvider(aliceProvider);
    bobOpenPgp.setOpenPgpProvider(bobProvider);
    aliceFingerprint = aliceOpenPgp.generateAndImportKeyPair(alice);
    bobFingerprint = bobOpenPgp.generateAndImportKeyPair(bob);
    aliceOpenPgp.announceSupportAndPublish();
    bobOpenPgp.announceSupportAndPublish();
    OpenPgpContact bobForAlice = aliceOpenPgp.getOpenPgpContact(bob.asEntityBareJidIfPossible());
    OpenPgpContact aliceForBob = bobOpenPgp.getOpenPgpContact(alice.asEntityBareJidIfPossible());
    bobForAlice.updateKeys(aliceConnection);
    assertFalse(bobForAlice.isTrusted(bobFingerprint));
    assertFalse(aliceForBob.isTrusted(aliceFingerprint));
    bobForAlice.trust(bobFingerprint);
    aliceForBob.trust(aliceFingerprint);
    assertTrue(bobForAlice.isTrusted(bobFingerprint));
    assertTrue(aliceForBob.isTrusted(aliceFingerprint));
    aliceInstantMessaging.sendOxMessage(bobForAlice, body);
    bobReceivedMessage.waitForResult(timeout);
}

Example 4 with UnprotectedKeysProtector

use of org.pgpainless.key.protection.UnprotectedKeysProtector in project Smack by igniterealtime.

the class PainlessOpenPgpProviderTest method encryptDecryptTest.

@Test
public void encryptDecryptTest() throws PGPException, NoSuchAlgorithmException, NoSuchProviderException, InvalidAlgorithmParameterException, IOException, MissingUserIdOnKeyException, XmlPullParserException {
    // Initialize
    OpenPgpStore aliceStore = new FileBasedOpenPgpStore(storagePath);
    OpenPgpStore bobStore = new FileBasedOpenPgpStore(storagePath);
    aliceStore.setKeyRingProtector(new UnprotectedKeysProtector());
    bobStore.setKeyRingProtector(new UnprotectedKeysProtector());
    XMPPConnection bobConnection = new DummyConnection();
    PainlessOpenPgpProvider aliceProvider = new PainlessOpenPgpProvider(aliceStore);
    PainlessOpenPgpProvider bobProvider = new PainlessOpenPgpProvider(bobStore);
    PGPSecretKeyRing aliceKeys = aliceStore.generateKeyRing(alice);
    PGPSecretKeyRing bobKeys = bobStore.generateKeyRing(bob);
    PGPPublicKeyRing alicePubKeys = KeyRingUtils.publicKeyRingFrom(aliceKeys);
    PGPPublicKeyRing bobPubKeys = KeyRingUtils.publicKeyRingFrom(bobKeys);
    OpenPgpV4Fingerprint aliceFingerprint = new OpenPgpV4Fingerprint(aliceKeys);
    OpenPgpV4Fingerprint bobFingerprint = new OpenPgpV4Fingerprint(bobKeys);
    aliceStore.importSecretKey(alice, aliceKeys);
    bobStore.importSecretKey(bob, bobKeys);
    aliceStore.setAnnouncedFingerprintsOf(alice, Collections.singletonMap(aliceFingerprint, new Date()));
    bobStore.setAnnouncedFingerprintsOf(bob, Collections.singletonMap(bobFingerprint, new Date()));
    OpenPgpSelf aliceSelf = new OpenPgpSelf(alice, aliceStore);
    aliceSelf.trust(aliceFingerprint);
    OpenPgpSelf bobSelf = new OpenPgpSelf(bob, bobStore);
    bobSelf.trust(bobFingerprint);
    // Exchange keys
    aliceStore.importPublicKey(bob, bobPubKeys);
    bobStore.importPublicKey(alice, alicePubKeys);
    aliceStore.setAnnouncedFingerprintsOf(bob, Collections.singletonMap(bobFingerprint, new Date()));
    bobStore.setAnnouncedFingerprintsOf(alice, Collections.singletonMap(aliceFingerprint, new Date()));
    OpenPgpContact aliceForBob = new OpenPgpContact(alice, bobStore);
    aliceForBob.trust(aliceFingerprint);
    OpenPgpContact bobForAlice = new OpenPgpContact(bob, aliceStore);
    bobForAlice.trust(bobFingerprint);
    // Prepare message
    Message.Body body = new Message.Body(null, "Lorem ipsum dolor sit amet, consectetur adipisici elit, sed eiusmod tempor incidunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquid ex ea commodi consequat. Quis aute iure reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint obcaecat cupiditat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.");
    List<ExtensionElement> payload = Collections.singletonList(body);
    OpenPgpElementAndMetadata encrypted;
    OpenPgpMessage decrypted;
    /*
        test signcrypt
         */
    SigncryptElement signcryptElement = new SigncryptElement(Collections.<Jid>singleton(bob), payload);
    // Encrypt and Sign
    encrypted = aliceProvider.signAndEncrypt(signcryptElement, aliceSelf, Collections.singleton(bobForAlice));
    // Decrypt and Verify
    decrypted = bobProvider.decryptAndOrVerify(bobConnection, encrypted.getElement(), bobSelf, aliceForBob);
    OpenPgpFingerprint decryptionFingerprint = decrypted.getMetadata().getDecryptionKey().getFingerprint();
    assertTrue(bobSelf.getSecretKeys().contains(decryptionFingerprint.getKeyId()));
    assertTrue(decrypted.getMetadata().containsVerifiedSignatureFrom(alicePubKeys));
    assertEquals(OpenPgpMessage.State.signcrypt, decrypted.getState());
    SigncryptElement decryptedSignCrypt = (SigncryptElement) decrypted.getOpenPgpContentElement();
    assertEquals(body.getMessage(), decryptedSignCrypt.<Message.Body>getExtension(Message.Body.ELEMENT, Message.Body.NAMESPACE).getMessage());
    /*
        test crypt
         */
    CryptElement cryptElement = new CryptElement(Collections.<Jid>singleton(bob), payload);
    // Encrypt
    encrypted = aliceProvider.encrypt(cryptElement, aliceSelf, Collections.singleton(bobForAlice));
    decrypted = bobProvider.decryptAndOrVerify(bobConnection, encrypted.getElement(), bobSelf, aliceForBob);
    decryptionFingerprint = decrypted.getMetadata().getDecryptionKey().getFingerprint();
    assertTrue(bobSelf.getSecretKeys().contains(decryptionFingerprint.getKeyId()));
    assertTrue(decrypted.getMetadata().getVerifiedSignatures().isEmpty());
    assertEquals(OpenPgpMessage.State.crypt, decrypted.getState());
    CryptElement decryptedCrypt = (CryptElement) decrypted.getOpenPgpContentElement();
    assertEquals(body.getMessage(), decryptedCrypt.<Message.Body>getExtension(Message.Body.ELEMENT, Message.Body.NAMESPACE).getMessage());
    /*
        test sign
         */
    SignElement signElement = new SignElement(Collections.singleton(bob), new Date(), payload);
    // Sign
    encrypted = aliceProvider.sign(signElement, aliceSelf);
    decrypted = bobProvider.decryptAndOrVerify(bobConnection, encrypted.getElement(), bobSelf, aliceForBob);
    assertNull(decrypted.getMetadata().getDecryptionKey());
    assertTrue(decrypted.getMetadata().containsVerifiedSignatureFrom(alicePubKeys));
    assertEquals(OpenPgpMessage.State.sign, decrypted.getState());
    SignElement decryptedSign = (SignElement) decrypted.getOpenPgpContentElement();
    assertEquals(body.getMessage(), decryptedSign.<Message.Body>getExtension(Message.Body.ELEMENT, Message.Body.NAMESPACE).getMessage());
}