Example usage for org.bouncycastle.bcpg.sig KeyFlags AUTHENTICATION

Introduction

In this page you can find the example usage for org.bouncycastle.bcpg.sig KeyFlags AUTHENTICATION.

Prototype

int AUTHENTICATION

To view the source code for org.bouncycastle.bcpg.sig KeyFlags AUTHENTICATION.

Click Source Link

Usage

From source file:org.sufficientlysecure.keychain.pgp.CanonicalizedPublicKey.java

License:Open Source License

public boolean canAuthenticate() {
    // if key flags subpacket is available, honor it!
    if (getKeyUsage() != 0) {
        return (getKeyUsage() & KeyFlags.AUTHENTICATION) != 0;
    }/* w w  w  . j  a  v a  2s. c o  m*/

    return false;
}

---

From source file:org.sufficientlysecure.keychain.provider.KeyRepositorySaveTest.java

License:Open Source License

@Test
public void testImportDivertToCard() throws Exception {

    UncachedKeyRing sec = readRingFromResource("/test-keys/divert_to_card_sec.asc");
    long keyId = sec.getMasterKeyId();

    SaveKeyringResult result;/* ww  w  . j av  a2s. co m*/

    result = mDatabaseInteractor.saveSecretKeyRing(sec);
    Assert.assertTrue("import of secret keyring should succeed", result.success());

    // make sure both the CanonicalizedSecretKeyRing as well as the CachedPublicKeyRing correctly
    // indicate the secret key type
    CachedPublicKeyRing cachedRing = mDatabaseInteractor.getCachedPublicKeyRing(keyId);
    CanonicalizedSecretKeyRing secRing = mDatabaseInteractor.getCanonicalizedSecretKeyRing(keyId);

    Iterator<CanonicalizedSecretKey> it = secRing.secretKeyIterator().iterator();

    { // first subkey
        Assert.assertTrue("keyring should have 3 subkeys (1)", it.hasNext());
        CanonicalizedSecretKey key = it.next();
        Assert.assertEquals("first subkey should be of type sign+certify",
                KeyFlags.CERTIFY_OTHER | KeyFlags.SIGN_DATA, (int) key.getKeyUsage());
        Assert.assertEquals("first subkey should be divert-to-card", SecretKeyType.DIVERT_TO_CARD,
                key.getSecretKeyTypeSuperExpensive());
        Assert.assertTrue("canCertify() should be true", key.canCertify());
        Assert.assertTrue("canSign() should be true", key.canSign());

        // cached
        Assert.assertEquals("all subkeys from CachedPublicKeyRing should be divert-to-key",
                SecretKeyType.DIVERT_TO_CARD, cachedRing.getSecretKeyType(key.getKeyId()));
    }

    { // second subkey
        Assert.assertTrue("keyring should have 3 subkeys (2)", it.hasNext());
        CanonicalizedSecretKey key = it.next();
        Assert.assertEquals("second subkey should be of type authenticate", KeyFlags.AUTHENTICATION,
                (int) key.getKeyUsage());
        Assert.assertEquals("second subkey should be divert-to-card", SecretKeyType.DIVERT_TO_CARD,
                key.getSecretKeyTypeSuperExpensive());
        Assert.assertTrue("canAuthenticate() should be true", key.canAuthenticate());

        // cached
        Assert.assertEquals("all subkeys from CachedPublicKeyRing should be divert-to-key",
                SecretKeyType.DIVERT_TO_CARD, cachedRing.getSecretKeyType(key.getKeyId()));
    }

    { // third subkey
        Assert.assertTrue("keyring should have 3 subkeys (3)", it.hasNext());
        CanonicalizedSecretKey key = it.next();
        Assert.assertEquals("first subkey should be of type encrypt (both types)",
                KeyFlags.ENCRYPT_COMMS | KeyFlags.ENCRYPT_STORAGE, (int) key.getKeyUsage());
        Assert.assertEquals("third subkey should be divert-to-card", SecretKeyType.DIVERT_TO_CARD,
                key.getSecretKeyTypeSuperExpensive());
        Assert.assertTrue("canEncrypt() should be true", key.canEncrypt());

        // cached
        Assert.assertEquals("all subkeys from CachedPublicKeyRing should be divert-to-key",
                SecretKeyType.DIVERT_TO_CARD, cachedRing.getSecretKeyType(key.getKeyId()));
    }

    Assert.assertFalse("keyring should have 3 subkeys (4)", it.hasNext());

}

---

From source file:org.sufficientlysecure.keychain.provider.ProviderHelperSaveTest.java

License:Open Source License

@Test
public void testImportDivertToCard() throws Exception {

    UncachedKeyRing sec = readRingFromResource("/test-keys/divert_to_card_sec.asc");
    long keyId = sec.getMasterKeyId();

    SaveKeyringResult result;/* w w  w  .ja va 2 s .  c  o  m*/

    result = mProviderHelper.saveSecretKeyRing(sec, new ProgressScaler());
    Assert.assertTrue("import of secret keyring should succeed", result.success());

    // make sure both the CanonicalizedSecretKeyRing as well as the CachedPublicKeyRing correctly
    // indicate the secret key type
    CachedPublicKeyRing cachedRing = mProviderHelper.getCachedPublicKeyRing(keyId);
    CanonicalizedSecretKeyRing secRing = mProviderHelper.getCanonicalizedSecretKeyRing(keyId);

    Iterator<CanonicalizedSecretKey> it = secRing.secretKeyIterator().iterator();

    { // first subkey
        Assert.assertTrue("keyring should have 3 subkeys (1)", it.hasNext());
        CanonicalizedSecretKey key = it.next();
        Assert.assertEquals("first subkey should be of type sign+certify",
                KeyFlags.CERTIFY_OTHER | KeyFlags.SIGN_DATA, (int) key.getKeyUsage());
        Assert.assertEquals("first subkey should be divert-to-card", SecretKeyType.DIVERT_TO_CARD,
                key.getSecretKeyTypeSuperExpensive());
        Assert.assertTrue("canCertify() should be true", key.canCertify());
        Assert.assertTrue("canSign() should be true", key.canSign());

        // cached
        Assert.assertEquals("all subkeys from CachedPublicKeyRing should be divert-to-key",
                SecretKeyType.DIVERT_TO_CARD, cachedRing.getSecretKeyType(key.getKeyId()));
    }

    { // second subkey
        Assert.assertTrue("keyring should have 3 subkeys (2)", it.hasNext());
        CanonicalizedSecretKey key = it.next();
        Assert.assertEquals("second subkey should be of type authenticate", KeyFlags.AUTHENTICATION,
                (int) key.getKeyUsage());
        Assert.assertEquals("second subkey should be divert-to-card", SecretKeyType.DIVERT_TO_CARD,
                key.getSecretKeyTypeSuperExpensive());
        Assert.assertTrue("canAuthenticate() should be true", key.canAuthenticate());

        // cached
        Assert.assertEquals("all subkeys from CachedPublicKeyRing should be divert-to-key",
                SecretKeyType.DIVERT_TO_CARD, cachedRing.getSecretKeyType(key.getKeyId()));
    }

    { // third subkey
        Assert.assertTrue("keyring should have 3 subkeys (3)", it.hasNext());
        CanonicalizedSecretKey key = it.next();
        Assert.assertEquals("first subkey should be of type encrypt (both types)",
                KeyFlags.ENCRYPT_COMMS | KeyFlags.ENCRYPT_STORAGE, (int) key.getKeyUsage());
        Assert.assertEquals("third subkey should be divert-to-card", SecretKeyType.DIVERT_TO_CARD,
                key.getSecretKeyTypeSuperExpensive());
        Assert.assertTrue("canEncrypt() should be true", key.canEncrypt());

        // cached
        Assert.assertEquals("all subkeys from CachedPublicKeyRing should be divert-to-key",
                SecretKeyType.DIVERT_TO_CARD, cachedRing.getSecretKeyType(key.getKeyId()));
    }

    Assert.assertFalse("keyring should have 3 subkeys (4)", it.hasNext());

}

---

From source file:org.sufficientlysecure.keychain.ui.adapter.SubkeysAddedAdapter.java

License:Open Source License

public View getView(final int position, View convertView, ViewGroup parent) {
    if (convertView == null) {
        // Not recycled, inflate a new view
        convertView = mInflater.inflate(R.layout.view_key_adv_subkey_item, parent, false);
        final ViewHolder holder = new ViewHolder();
        holder.vKeyId = (TextView) convertView.findViewById(R.id.subkey_item_key_id);
        holder.vKeyDetails = (TextView) convertView.findViewById(R.id.subkey_item_details);
        holder.vKeyExpiry = (TextView) convertView.findViewById(R.id.subkey_item_expiry);
        holder.vCertifyIcon = (ImageView) convertView.findViewById(R.id.subkey_item_ic_certify);
        holder.vSignIcon = (ImageView) convertView.findViewById(R.id.subkey_item_ic_sign);
        holder.vEncryptIcon = (ImageView) convertView.findViewById(R.id.subkey_item_ic_encrypt);
        holder.vAuthenticateIcon = (ImageView) convertView.findViewById(R.id.subkey_item_ic_authenticate);

        holder.vDelete = (ImageButton) convertView.findViewById(R.id.subkey_item_delete_button);
        holder.vDelete.setVisibility(View.VISIBLE); // always visible

        // not used:
        ImageView vEdit = (ImageView) convertView.findViewById(R.id.subkey_item_edit_image);
        vEdit.setVisibility(View.GONE);
        ImageView vStatus = (ImageView) convertView.findViewById(R.id.subkey_item_status);
        vStatus.setVisibility(View.GONE);

        convertView.setTag(holder);//from  w w w  . j a v a2s  .  c  o m
    }

    final ViewHolder holder = (ViewHolder) convertView.getTag();

    // save reference to model item
    holder.mModel = getItem(position);

    String algorithmStr = KeyFormattingUtils.getAlgorithmInfo(mActivity, holder.mModel.mAlgorithm,
            holder.mModel.mKeySize, holder.mModel.mCurve);

    boolean isMasterKey = mNewKeyring && position == 0;
    if (isMasterKey) {
        holder.vKeyId.setTypeface(null, Typeface.BOLD);
        holder.vDelete.setImageResource(R.drawable.ic_change_grey_24dp);
        holder.vDelete.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // swapping out the old master key with newly set master key
                AddSubkeyDialogFragment addSubkeyDialogFragment = AddSubkeyDialogFragment.newInstance(true);
                addSubkeyDialogFragment.setOnAlgorithmSelectedListener(
                        new AddSubkeyDialogFragment.OnAlgorithmSelectedListener() {
                            @Override
                            public void onAlgorithmSelected(SaveKeyringParcel.SubkeyAdd newSubkey) {
                                // calculate manually as the provided position variable
                                // is not always accurate
                                int pos = SubkeysAddedAdapter.this.getPosition(holder.mModel);
                                SubkeysAddedAdapter.this.remove(holder.mModel);
                                SubkeysAddedAdapter.this.insert(newSubkey, pos);
                            }
                        });
                addSubkeyDialogFragment.show(((FragmentActivity) mActivity).getSupportFragmentManager(),
                        "addSubkeyDialog");
            }
        });
    } else {
        holder.vKeyId.setTypeface(null, Typeface.NORMAL);
        holder.vDelete.setImageResource(R.drawable.ic_close_grey_24dp);
        holder.vDelete.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // remove reference model item from adapter (data and notify about change)
                SubkeysAddedAdapter.this.remove(holder.mModel);
            }
        });
    }

    holder.vKeyId.setText(R.string.edit_key_new_subkey);
    holder.vKeyDetails.setText(algorithmStr);

    if (holder.mModel.mExpiry != 0L) {
        Date expiryDate = new Date(holder.mModel.mExpiry * 1000);
        Calendar expiryCal = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
        expiryCal.setTime(expiryDate);
        // convert from UTC to time zone of device
        expiryCal.setTimeZone(TimeZone.getDefault());

        holder.vKeyExpiry.setText(getContext().getString(R.string.label_expiry) + ": "
                + DateFormat.getDateFormat(getContext()).format(expiryCal.getTime()));
    } else {
        holder.vKeyExpiry.setText(
                getContext().getString(R.string.label_expiry) + ": " + getContext().getString(R.string.none));
    }

    int flags = holder.mModel.mFlags;
    if ((flags & KeyFlags.CERTIFY_OTHER) > 0) {
        holder.vCertifyIcon.setVisibility(View.VISIBLE);
    } else {
        holder.vCertifyIcon.setVisibility(View.GONE);
    }
    if ((flags & KeyFlags.SIGN_DATA) > 0) {
        holder.vSignIcon.setVisibility(View.VISIBLE);
    } else {
        holder.vSignIcon.setVisibility(View.GONE);
    }
    if (((flags & KeyFlags.ENCRYPT_COMMS) > 0) || ((flags & KeyFlags.ENCRYPT_STORAGE) > 0)) {
        holder.vEncryptIcon.setVisibility(View.VISIBLE);
    } else {
        holder.vEncryptIcon.setVisibility(View.GONE);
    }
    if ((flags & KeyFlags.AUTHENTICATION) > 0) {
        holder.vAuthenticateIcon.setVisibility(View.VISIBLE);
    } else {
        holder.vAuthenticateIcon.setVisibility(View.GONE);
    }

    return convertView;
}

---

From source file:org.sufficientlysecure.keychain.ui.CreateKeyFinalFragment.java

License:Open Source License

private static SaveKeyringParcel createDefaultSaveKeyringParcel(CreateKeyActivity createKeyActivity) {
    SaveKeyringParcel saveKeyringParcel = new SaveKeyringParcel();

    if (createKeyActivity.mCreateSecurityToken) {
        saveKeyringParcel.mAddSubKeys.add(new SaveKeyringParcel.SubkeyAdd(Algorithm.RSA, 2048, null,
                KeyFlags.SIGN_DATA | KeyFlags.CERTIFY_OTHER, 0L));
        saveKeyringParcel.mAddSubKeys.add(new SaveKeyringParcel.SubkeyAdd(Algorithm.RSA, 2048, null,
                KeyFlags.ENCRYPT_COMMS | KeyFlags.ENCRYPT_STORAGE, 0L));
        saveKeyringParcel.mAddSubKeys/*from ww w  . jav a  2 s.com*/
                .add(new SaveKeyringParcel.SubkeyAdd(Algorithm.RSA, 2048, null, KeyFlags.AUTHENTICATION, 0L));

        // use empty passphrase
        saveKeyringParcel.setNewUnlock(new ChangeUnlockParcel(new Passphrase()));
    } else {
        saveKeyringParcel.mAddSubKeys
                .add(new SaveKeyringParcel.SubkeyAdd(Algorithm.RSA, 3072, null, KeyFlags.CERTIFY_OTHER, 0L));
        saveKeyringParcel.mAddSubKeys
                .add(new SaveKeyringParcel.SubkeyAdd(Algorithm.RSA, 3072, null, KeyFlags.SIGN_DATA, 0L));
        saveKeyringParcel.mAddSubKeys.add(new SaveKeyringParcel.SubkeyAdd(Algorithm.RSA, 3072, null,
                KeyFlags.ENCRYPT_COMMS | KeyFlags.ENCRYPT_STORAGE, 0L));

        if (createKeyActivity.mPassphrase != null) {
            saveKeyringParcel.setNewUnlock(new ChangeUnlockParcel(createKeyActivity.mPassphrase));
        } else {
            saveKeyringParcel.setNewUnlock(null);
        }
    }
    String userId = KeyRing
            .createUserId(new OpenPgpUtils.UserId(createKeyActivity.mName, createKeyActivity.mEmail, null));
    saveKeyringParcel.mAddUserIds.add(userId);
    saveKeyringParcel.mChangePrimaryUserId = userId;
    if (createKeyActivity.mAdditionalEmails != null && createKeyActivity.mAdditionalEmails.size() > 0) {
        for (String email : createKeyActivity.mAdditionalEmails) {
            String thisUserId = KeyRing
                    .createUserId(new OpenPgpUtils.UserId(createKeyActivity.mName, email, null));
            saveKeyringParcel.mAddUserIds.add(thisUserId);
        }
    }

    return saveKeyringParcel;
}

---