diff --git a/base16ct/src/error.rs b/base16ct/src/error.rs
index a5f99c2ea..29cbabf5e 100644
--- a/base16ct/src/error.rs
+++ b/base16ct/src/error.rs
@@ -25,8 +25,8 @@ impl fmt::Display for Error {
 #[cfg(feature = "std")]
 impl std::error::Error for Error {}
 
-impl From<Error> for core::fmt::Error {
-    fn from(_: Error) -> core::fmt::Error {
-        core::fmt::Error::default()
+impl From<Error> for fmt::Error {
+    fn from(_: Error) -> fmt::Error {
+        fmt::Error::default()
     }
 }
diff --git a/base16ct/src/upper.rs b/base16ct/src/upper.rs
index a747f297c..2b82ce68a 100644
--- a/base16ct/src/upper.rs
+++ b/base16ct/src/upper.rs
@@ -46,7 +46,7 @@ pub fn encode_string(input: &[u8]) -> String {
     let res = encode(input, &mut dst).expect("dst length is correct");
 
     debug_assert_eq!(elen, res.len());
-    unsafe { crate::String::from_utf8_unchecked(dst) }
+    unsafe { String::from_utf8_unchecked(dst) }
 }
 
 /// Decode a single nibble of upper hex
diff --git a/pkcs1/src/error.rs b/pkcs1/src/error.rs
index 135bcd7d9..ac8f4feaa 100644
--- a/pkcs1/src/error.rs
+++ b/pkcs1/src/error.rs
@@ -75,18 +75,18 @@ impl From<pkcs8::Error> for Error {
 }
 
 #[cfg(feature = "pkcs8")]
-impl From<Error> for pkcs8::spki::Error {
-    fn from(err: Error) -> pkcs8::spki::Error {
+impl From<Error> for spki::Error {
+    fn from(err: Error) -> spki::Error {
         match err {
-            Error::Asn1(e) => pkcs8::spki::Error::Asn1(e),
-            _ => pkcs8::spki::Error::KeyMalformed,
+            Error::Asn1(e) => spki::Error::Asn1(e),
+            _ => spki::Error::KeyMalformed,
         }
     }
 }
 
 #[cfg(feature = "pkcs8")]
-impl From<pkcs8::spki::Error> for Error {
-    fn from(err: pkcs8::spki::Error) -> Error {
+impl From<spki::Error> for Error {
+    fn from(err: spki::Error) -> Error {
         Error::Pkcs8(pkcs8::Error::PublicKey(err))
     }
 }
diff --git a/pkcs1/src/traits.rs b/pkcs1/src/traits.rs
index cd3d04e21..fe424cdce 100644
--- a/pkcs1/src/traits.rs
+++ b/pkcs1/src/traits.rs
@@ -171,7 +171,7 @@ where
 #[cfg(feature = "pkcs8")]
 impl<T> DecodeRsaPublicKey for T
 where
-    T: for<'a> TryFrom<pkcs8::SubjectPublicKeyInfoRef<'a>, Error = pkcs8::spki::Error>,
+    T: for<'a> TryFrom<pkcs8::SubjectPublicKeyInfoRef<'a>, Error = spki::Error>,
 {
     fn from_pkcs1_der(public_key: &[u8]) -> Result<Self> {
         Ok(Self::try_from(pkcs8::SubjectPublicKeyInfoRef {
diff --git a/pkcs5/src/pbes1.rs b/pkcs5/src/pbes1.rs
index 217154795..946c3032a 100644
--- a/pkcs5/src/pbes1.rs
+++ b/pkcs5/src/pbes1.rs
@@ -91,8 +91,8 @@ impl<'a> TryFrom<AlgorithmIdentifierRef<'a>> for Algorithm {
 
     fn try_from(alg: AlgorithmIdentifierRef<'a>) -> der::Result<Self> {
         // Ensure that we have a supported PBES1 algorithm identifier
-        let encryption = EncryptionScheme::try_from(alg.oid)
-            .map_err(|_| der::Tag::ObjectIdentifier.value_error())?;
+        let encryption =
+            EncryptionScheme::try_from(alg.oid).map_err(|_| Tag::ObjectIdentifier.value_error())?;
 
         let parameters = alg
             .parameters
@@ -153,7 +153,7 @@ impl TryFrom<AnyRef<'_>> for Parameters {
                 salt: OctetStringRef::decode(reader)?
                     .as_bytes()
                     .try_into()
-                    .map_err(|_| der::Tag::OctetString.value_error())?,
+                    .map_err(|_| Tag::OctetString.value_error())?,
                 iteration_count: reader.decode()?,
             })
         })
diff --git a/pkcs5/src/pbes2.rs b/pkcs5/src/pbes2.rs
index 301105cc2..7b51ab09a 100644
--- a/pkcs5/src/pbes2.rs
+++ b/pkcs5/src/pbes2.rs
@@ -318,31 +318,25 @@ impl<'a> TryFrom<AlgorithmIdentifierRef<'a>> for EncryptionScheme<'a> {
 
         match alg.oid {
             AES_128_CBC_OID => Ok(Self::Aes128Cbc {
-                iv: iv
-                    .try_into()
-                    .map_err(|_| der::Tag::OctetString.value_error())?,
+                iv: iv.try_into().map_err(|_| Tag::OctetString.value_error())?,
             }),
             AES_192_CBC_OID => Ok(Self::Aes192Cbc {
-                iv: iv
-                    .try_into()
-                    .map_err(|_| der::Tag::OctetString.value_error())?,
+                iv: iv.try_into().map_err(|_| Tag::OctetString.value_error())?,
             }),
             AES_256_CBC_OID => Ok(Self::Aes256Cbc {
-                iv: iv
-                    .try_into()
-                    .map_err(|_| der::Tag::OctetString.value_error())?,
+                iv: iv.try_into().map_err(|_| Tag::OctetString.value_error())?,
             }),
             #[cfg(feature = "des-insecure")]
             DES_CBC_OID => Ok(Self::DesCbc {
                 iv: iv[0..DES_BLOCK_SIZE]
                     .try_into()
-                    .map_err(|_| der::Tag::OctetString.value_error())?,
+                    .map_err(|_| Tag::OctetString.value_error())?,
             }),
             #[cfg(feature = "3des")]
             DES_EDE3_CBC_OID => Ok(Self::DesEde3Cbc {
                 iv: iv[0..DES_BLOCK_SIZE]
                     .try_into()
-                    .map_err(|_| der::Tag::OctetString.value_error())?,
+                    .map_err(|_| Tag::OctetString.value_error())?,
             }),
             oid => Err(ErrorKind::OidUnknown { oid }.into()),
         }
diff --git a/sec1/src/private_key.rs b/sec1/src/private_key.rs
index 531579936..ec851e14e 100644
--- a/sec1/src/private_key.rs
+++ b/sec1/src/private_key.rs
@@ -98,7 +98,7 @@ impl<'a> DecodeValue<'a> for EcPrivateKey<'a> {
     fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> der::Result<Self> {
         reader.read_nested(header.length, |reader| {
             if u8::decode(reader)? != VERSION {
-                return Err(der::Tag::Integer.value_error());
+                return Err(Tag::Integer.value_error());
             }
 
             let private_key = OctetStringRef::decode(reader)?.as_bytes();
diff --git a/x509-cert/src/request.rs b/x509-cert/src/request.rs
index 50478d8bc..4e15b0416 100644
--- a/x509-cert/src/request.rs
+++ b/x509-cert/src/request.rs
@@ -142,7 +142,7 @@ pub mod attributes {
     pub trait AsAttribute: AssociatedOid + Tagged + EncodeValue + Sized {
         /// Returns the Attribute with the content encoded.
         fn to_attribute(&self) -> Result<Attribute> {
-            let inner: Any = der::asn1::Any::encode_from(self)?;
+            let inner: Any = Any::encode_from(self)?;
 
             let values = SetOfVec::try_from(vec![inner])?;