turnkey/openpgp-card
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

remove "use sequoia_openpgp as openpgp;" pattern

Browse source
This commit is contained in:
Heiko Schaefer 2022-11-03 11:54:31 +01:00
parent fd07f6b6b9
commit 5e039204d5
No known key found for this signature in database
GPG key ID: 4A849A1904CCBD7D
8 changed files with 61 additions and 67 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
openpgp-card-examples/src/bin/decrypt.rs
View file

@ -1,11 +1,10 @@
// SPDX-FileCopyrightText: 2021 Wiktor Kwapisiewicz <wiktor@metacode.biz>
// SPDX-License-Identifier: MIT OR Apache-2.0
use openpgp::parse::{stream::DecryptorBuilder, Parse};
use openpgp::policy::StandardPolicy;
use openpgp_card_pcsc::PcscBackend;
use openpgp_card_sequoia::{state::Open, Card};
use sequoia_openpgp as openpgp;
use sequoia_openpgp::parse::{stream::DecryptorBuilder, Parse};
use sequoia_openpgp::policy::StandardPolicy;
fn main() -> Result<(), Box<dyn std::error::Error>> {
let args = std::env::args().collect::<Vec<_>>();

3
openpgp-card-examples/src/bin/detach-sign.rs
View file

@ -1,10 +1,9 @@
// SPDX-FileCopyrightText: 2021 Wiktor Kwapisiewicz <wiktor@metacode.biz>
// SPDX-License-Identifier: MIT OR Apache-2.0
use openpgp::serialize::stream::{Armorer, Message, Signer};
use openpgp_card_pcsc::PcscBackend;
use openpgp_card_sequoia::{state::Open, Card};
use sequoia_openpgp as openpgp;
use sequoia_openpgp::serialize::stream::{Armorer, Message, Signer};
fn main() -> Result<(), Box<dyn std::error::Error>> {
let args = std::env::args().collect::<Vec<_>>();

28
openpgp-card-sequoia/src/decryptor.rs
View file

@ -2,15 +2,14 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
use anyhow::anyhow;
use openpgp::crypto;
use openpgp::crypto::mpi;
use openpgp::crypto::SessionKey;
use openpgp::packet;
use openpgp::parse::stream::{DecryptionHelper, MessageStructure, VerificationHelper};
use openpgp::types::{Curve, SymmetricAlgorithm};
use openpgp_card::crypto_data::Cryptogram;
use openpgp_card::OpenPgpTransaction;
use sequoia_openpgp as openpgp;
use sequoia_openpgp::crypto::mpi;
use sequoia_openpgp::crypto::SessionKey;
use sequoia_openpgp::packet;
use sequoia_openpgp::parse::stream::{DecryptionHelper, MessageStructure, VerificationHelper};
use sequoia_openpgp::types::{Curve, SymmetricAlgorithm};
use sequoia_openpgp::{crypto, KeyHandle};
use crate::PublicKey;
@ -48,7 +47,7 @@ impl<'a, 'app> crypto::Decryptor for CardDecryptor<'a, 'app> {
&mut self,
ciphertext: &mpi::Ciphertext,
_plaintext_len: Option<usize>,
) -> openpgp::Result<crypto::SessionKey> {
) -> sequoia_openpgp::Result<SessionKey> {
// FIXME: use cached ARD value from caller?
let ard = self.ca.application_related_data()?;
@ -77,7 +76,7 @@ impl<'a, 'app> crypto::Decryptor for CardDecryptor<'a, 'app> {
let dec = self.ca.decipher(dm)?;
let sk = openpgp::crypto::SessionKey::from(&dec[..]);
let sk = SessionKey::from(&dec[..]);
Ok(sk)
}
(mpi::Ciphertext::ECDH { ref e, .. }, mpi::PublicKey::ECDH { ref curve, .. }) => {
@ -113,7 +112,7 @@ impl<'a, 'app> crypto::Decryptor for CardDecryptor<'a, 'app> {
}
#[allow(non_snake_case)]
let S: openpgp::crypto::mem::Protected = dec.into();
let S: crypto::mem::Protected = dec.into();
Ok(crypto::ecdh::decrypt_unwrap(&self.public, &S, ciphertext)?)
}
@ -135,7 +134,7 @@ impl<'a, 'app> DecryptionHelper for CardDecryptor<'a, 'app> {
_skesks: &[packet::SKESK],
sym_algo: Option<SymmetricAlgorithm>,
mut dec_fn: D,
) -> openpgp::Result<Option<openpgp::Fingerprint>>
) -> sequoia_openpgp::Result<Option<sequoia_openpgp::Fingerprint>>
where
D: FnMut(SymmetricAlgorithm, &SessionKey) -> bool,
{
@ -159,10 +158,13 @@ impl<'a, 'app> DecryptionHelper for CardDecryptor<'a, 'app> {
}
impl VerificationHelper for CardDecryptor<'_, '_> {
fn get_certs(&mut self, _ids: &[openpgp::KeyHandle]) -> openpgp::Result<Vec<openpgp::Cert>> {
fn get_certs(
&mut self,
_ids: &[KeyHandle],
) -> sequoia_openpgp::Result<Vec<sequoia_openpgp::Cert>> {
Ok(vec![])
}
fn check(&mut self, _structure: MessageStructure) -> openpgp::Result<()> {
fn check(&mut self, _structure: MessageStructure) -> sequoia_openpgp::Result<()> {
Ok(())
}
}

3
openpgp-card-sequoia/src/lib.rs
View file

@ -141,7 +141,6 @@
//! # }
//! ```
use openpgp::packet::{key, Key};
use openpgp_card::algorithm::{Algo, AlgoInfo, AlgoSimple};
use openpgp_card::card_do::{
ApplicationIdentifier, CardholderRelatedData, ExtendedCapabilities, ExtendedLengthInfo,
@ -150,9 +149,9 @@ use openpgp_card::card_do::{
};
use openpgp_card::crypto_data::PublicKeyMaterial;
use openpgp_card::{CardBackend, Error, KeySet, KeyType, OpenPgp, OpenPgpTransaction};
use sequoia_openpgp as openpgp;
use sequoia_openpgp::cert::prelude::ValidErasedKeyAmalgamation;
use sequoia_openpgp::packet::key::SecretParts;
use sequoia_openpgp::packet::{key, Key};
use sequoia_openpgp::types::{HashAlgorithm, SymmetricAlgorithm};
use crate::decryptor::CardDecryptor;

18
openpgp-card-sequoia/src/privkey.rs
View file

@ -4,19 +4,17 @@
use std::convert::TryFrom;
use std::convert::TryInto;
use openpgp::cert::amalgamation::key::ValidErasedKeyAmalgamation;
use openpgp::crypto::{mpi, mpi::ProtectedMPI, mpi::MPI};
use openpgp::packet::{
use openpgp_card::card_do::{Fingerprint, KeyGenerationTime};
use openpgp_card::crypto_data::{CardUploadableKey, EccKey, EccType, PrivateKeyMaterial, RSAKey};
use openpgp_card::Error;
use sequoia_openpgp::cert::amalgamation::key::ValidErasedKeyAmalgamation;
use sequoia_openpgp::crypto::{mpi, mpi::ProtectedMPI, mpi::MPI};
use sequoia_openpgp::packet::{
key,
key::{SecretParts, UnspecifiedRole},
Key,
};
use openpgp::types::Timestamp;
use openpgp_card::card_do::{Fingerprint, KeyGenerationTime};
use openpgp_card::crypto_data::{CardUploadableKey, EccKey, EccType, PrivateKeyMaterial, RSAKey};
use openpgp_card::Error;
use sequoia_openpgp as openpgp;
use sequoia_openpgp::types::Curve;
use sequoia_openpgp::types::{Curve, Timestamp};
/// A SequoiaKey represents the private cryptographic key material of an
/// OpenPGP (sub)key to be uploaded to an OpenPGP card.
@ -54,7 +52,7 @@ impl CardUploadableKey for SequoiaKey {
Some(pw) => self
.key
.clone()
.decrypt_secret(&openpgp::crypto::Password::from(pw.as_str()))
.decrypt_secret(&sequoia_openpgp::crypto::Password::from(pw.as_str()))
.map_err(|e| Error::InternalError(format!("sequoia decrypt failed {:?}", e)))?,
};

17
openpgp-card-sequoia/src/signer.rs
View file

@ -4,12 +4,11 @@
use std::convert::TryInto;
use anyhow::anyhow;
use openpgp::crypto;
use openpgp::crypto::mpi;
use openpgp::types::{Curve, PublicKeyAlgorithm};
use openpgp_card::crypto_data::Hash;
use openpgp_card::OpenPgpTransaction;
use sequoia_openpgp as openpgp;
use sequoia_openpgp::crypto;
use sequoia_openpgp::crypto::mpi;
use sequoia_openpgp::types::{Curve, PublicKeyAlgorithm};
use crate::PublicKey;
@ -62,9 +61,9 @@ impl<'a, 'app> crypto::Signer for CardSigner<'a, 'app> {
fn sign(
&mut self,
hash_algo: openpgp::types::HashAlgorithm,
hash_algo: sequoia_openpgp::types::HashAlgorithm,
digest: &[u8],
) -> openpgp::Result<mpi::Signature> {
) -> sequoia_openpgp::Result<mpi::Signature> {
// FIXME: use cached ARD value from caller?
let ard = self.ca.application_related_data()?;
@ -103,17 +102,17 @@ impl<'a, 'app> crypto::Signer for CardSigner<'a, 'app> {
(PublicKeyAlgorithm::RSASign, mpi::PublicKey::RSA { .. })
| (PublicKeyAlgorithm::RSAEncryptSign, mpi::PublicKey::RSA { .. }) => {
let hash = match hash_algo {
openpgp::types::HashAlgorithm::SHA256 => Hash::SHA256(
sequoia_openpgp::types::HashAlgorithm::SHA256 => Hash::SHA256(
digest
.try_into()
.map_err(|_| anyhow!("invalid slice length"))?,
),
openpgp::types::HashAlgorithm::SHA384 => Hash::SHA384(
sequoia_openpgp::types::HashAlgorithm::SHA384 => Hash::SHA384(
digest
.try_into()
.map_err(|_| anyhow!("invalid slice length"))?,
),
openpgp::types::HashAlgorithm::SHA512 => Hash::SHA512(
sequoia_openpgp::types::HashAlgorithm::SHA512 => Hash::SHA512(
digest
.try_into()
.map_err(|_| anyhow!("invalid slice length"))?,

19
openpgp-card-sequoia/src/sq_util.rs
View file

@ -8,19 +8,18 @@
use std::io;
use anyhow::{anyhow, Context, Result};
use openpgp::armor;
use openpgp::cert::amalgamation::key::{ErasedKeyAmalgamation, ValidErasedKeyAmalgamation};
use openpgp::crypto;
use openpgp::packet::key::{PublicParts, SecretParts};
use openpgp::parse::{
use openpgp_card::{Error, KeyType};
use sequoia_openpgp::armor;
use sequoia_openpgp::cert::amalgamation::key::{ErasedKeyAmalgamation, ValidErasedKeyAmalgamation};
use sequoia_openpgp::crypto;
use sequoia_openpgp::packet::key::{PublicParts, SecretParts};
use sequoia_openpgp::parse::{
stream::{DecryptionHelper, DecryptorBuilder, VerificationHelper},
Parse,
};
use openpgp::policy::Policy;
use openpgp::serialize::stream::{Message, Signer};
use openpgp::{Cert, Fingerprint};
use openpgp_card::{Error, KeyType};
use sequoia_openpgp as openpgp;
use sequoia_openpgp::policy::Policy;
use sequoia_openpgp::serialize::stream::{Message, Signer};
use sequoia_openpgp::{Cert, Fingerprint};
use crate::{CardDecryptor, CardSigner};

35
openpgp-card-sequoia/src/util.rs
View file

@ -7,23 +7,22 @@ use std::convert::TryFrom;
use std::convert::TryInto;
use anyhow::{anyhow, Result};
use openpgp::cert::amalgamation::key::ValidErasedKeyAmalgamation;
use openpgp::crypto::mpi;
use openpgp::packet::Signature;
use openpgp::packet::{
key::{Key4, KeyRole, PrimaryRole, SecretParts, SubordinateRole},
signature::SignatureBuilder,
Key, UserID,
};
use openpgp::types::{
HashAlgorithm, KeyFlags, PublicKeyAlgorithm, SignatureType, SymmetricAlgorithm, Timestamp,
};
use openpgp::{Cert, Packet};
use openpgp_card::algorithm::{Algo, Curve};
use openpgp_card::card_do::{Fingerprint, KeyGenerationTime};
use openpgp_card::crypto_data::{CardUploadableKey, PublicKeyMaterial};
use openpgp_card::{Error, KeyType};
use sequoia_openpgp as openpgp;
use sequoia_openpgp::cert::amalgamation::key::ValidErasedKeyAmalgamation;
use sequoia_openpgp::crypto::mpi;
use sequoia_openpgp::packet::Signature;
use sequoia_openpgp::packet::{
key::{Key4, KeyRole, PrimaryRole, SecretParts, SubordinateRole},
signature::SignatureBuilder,
Key, UserID,
};
use sequoia_openpgp::types::{
HashAlgorithm, KeyFlags, PublicKeyAlgorithm, SignatureType, SymmetricAlgorithm, Timestamp,
};
use sequoia_openpgp::{Cert, Packet};
use crate::privkey::SequoiaKey;
use crate::state::Transaction;
@ -240,11 +239,11 @@ pub fn public_key_material_to_key(
let algo = ecc.algo().clone(); // FIXME?
if let Algo::Ecc(algo_ecc) = algo {
let curve = match algo_ecc.curve() {
Curve::NistP256r1 => openpgp::types::Curve::NistP256,
Curve::NistP384r1 => openpgp::types::Curve::NistP384,
Curve::NistP521r1 => openpgp::types::Curve::NistP521,
Curve::Ed25519 => openpgp::types::Curve::Ed25519,
Curve::Cv25519 => openpgp::types::Curve::Cv25519,
Curve::NistP256r1 => sequoia_openpgp::types::Curve::NistP256,
Curve::NistP384r1 => sequoia_openpgp::types::Curve::NistP384,
Curve::NistP521r1 => sequoia_openpgp::types::Curve::NistP521,
Curve::Ed25519 => sequoia_openpgp::types::Curve::Ed25519,
Curve::Cv25519 => sequoia_openpgp::types::Curve::Cv25519,
c => unimplemented!("unhandled curve: {:?}", c),
};