Remove 'KeyId', this is all covered by 'rpki::crypto::KeyIdentifier' now.

commons/src/api/ca.rs

@@ -30,7 +30,6 @@ use crate::remote::id::IdCert;
 use crate::rpki::crl::{Crl, CrlEntry};
 use crate::rpki::manifest::{FileAndHash, Manifest};
 use crate::util::ext_serde;
-use crate::util::softsigner::KeyId;
 
 //------------ ResourceClassName -------------------------------------------
 
@@ -604,22 +603,22 @@ impl Eq for RepoInfo {}
 /// when a certificate is received.
 #[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
 pub struct PendingKey {
-    key_id: KeyId,
+    key_id: KeyIdentifier,
     request: Option<IssuanceRequest>,
 }
 
 impl PendingKey {
-    pub fn new(key_id: KeyId) -> Self {
+    pub fn new(key_id: KeyIdentifier) -> Self {
         PendingKey {
             key_id,
             request: None,
         }
     }
-    pub fn unwrap(self) -> (KeyId, Option<IssuanceRequest>) {
+    pub fn unwrap(self) -> (KeyIdentifier, Option<IssuanceRequest>) {
         (self.key_id, self.request)
     }
 
-    pub fn key_id(&self) -> &KeyId {
+    pub fn key_id(&self) -> &KeyIdentifier {
         &self.key_id
     }
     pub fn request(&self) -> Option<&IssuanceRequest> {
@@ -674,14 +673,14 @@ impl DerefMut for OldKey {
 /// Describes a Key that is certified. I.e. it received an incoming certificate
 /// and has at least a MFT and CRL.
 pub struct CertifiedKey {
-    key_id: KeyId,
+    key_id: KeyIdentifier,
     incoming_cert: RcvdCert,
     current_set: CurrentObjectSet,
     request: Option<IssuanceRequest>,
 }
 
 impl CertifiedKey {
-    pub fn new(key_id: KeyId, incoming_cert: RcvdCert) -> Self {
+    pub fn new(key_id: KeyIdentifier, incoming_cert: RcvdCert) -> Self {
         let current_set = CurrentObjectSet::default();
 
         CertifiedKey {
@@ -692,7 +691,7 @@ impl CertifiedKey {
         }
     }
 
-    pub fn key_id(&self) -> &KeyId {
+    pub fn key_id(&self) -> &KeyIdentifier {
         &self.key_id
     }
     pub fn incoming_cert(&self) -> &RcvdCert {

commons/src/remote/api.rs

@@ -1,8 +1,7 @@
+use rpki::crypto::KeyIdentifier;
 use rpki::uri;
 
 use crate::api::admin::Handle;
-use crate::util::softsigner::KeyId;
-
 use crate::remote::id::IdCert;
 
 //------------ Client ------------------------------------------------------
@@ -55,12 +54,17 @@ impl ClientInfo {
 pub struct CmsClientInfo {
     handle: Handle,
     server_cert: IdCert,
-    key_id: KeyId,
+    key_id: KeyIdentifier,
     publication_uri: uri::Https,
 }
 
 impl CmsClientInfo {
-    pub fn new(handle: Handle, cert: IdCert, key_id: KeyId, publication_uri: uri::Https) -> Self {
+    pub fn new(
+        handle: Handle,
+        cert: IdCert,
+        key_id: KeyIdentifier,
+        publication_uri: uri::Https,
+    ) -> Self {
         CmsClientInfo {
             handle,
             server_cert: cert,
@@ -81,10 +85,10 @@ impl CmsClientInfo {
     pub fn set_server_cert(&mut self, cert: IdCert) {
         self.server_cert = cert;
     }
-    pub fn key_id(&self) -> &KeyId {
-        &self.key_id
+    pub fn key_id(&self) -> KeyIdentifier {
+        self.key_id
     }
-    pub fn set_key_id(&mut self, key_id: KeyId) {
+    pub fn set_key_id(&mut self, key_id: KeyIdentifier) {
         self.key_id = key_id;
     }
     pub fn publication_uri(&self) -> &uri::Https {

commons/src/remote/builder.rs

@@ -1,9 +1,12 @@
 //! Support for building RPKI Certificates and Objects
+use std::fmt;
+
+use bytes::Bytes;
+use chrono::Utc;
+
 use bcder::encode::{Constructed, PrimitiveContent, Values};
 use bcder::{decode, encode};
 use bcder::{BitString, Mode, OctetString, Oid, Tag};
-use bytes::Bytes;
-use chrono::Utc;
 use rpki::cert::ext::{CrlNumber, Extensions, KeyIdentifier};
 use rpki::crypto::signer::KeyError;
 use rpki::crypto::{
@@ -11,7 +14,6 @@ use rpki::crypto::{
 };
 use rpki::oid;
 use rpki::x509::{Name, Time, Validity};
-use std::fmt;
 
 use crate::remote::id::{IdCert, IdExtensions};
 use crate::remote::sigmsg::SigMsgCrl;
@@ -211,9 +213,7 @@ impl IdCertBuilder {
         signer: &S,
     ) -> Result<IdCert, Error<S::Error>> {
         let issuing_key_info = signer.get_key_info(issuing_key)?;
-
         let ext = IdExtensions::for_id_ee_cert(subject_key, &issuing_key_info);
-
         let cert = IdCertBuilder::create_signed_cert(issuing_key, subject_key, ext, signer)?;
         Ok(cert)
     }

commons/src/remote/id.rs

@@ -1,17 +1,16 @@
+use bytes::Bytes;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
 use bcder::encode::Constructed;
 use bcder::encode::Values;
 use bcder::{decode, encode};
 use bcder::{Mode, OctetString, Oid, Tag, Unsigned};
-use bytes::Bytes;
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
-
 use rpki::cert::ext::{AuthorityKeyIdentifier, BasicCa, SubjectKeyIdentifier};
-use rpki::crypto::{PublicKey, SignatureAlgorithm};
+use rpki::crypto::{KeyIdentifier, PublicKey, SignatureAlgorithm};
 use rpki::uri;
 use rpki::x509::{Name, SignedData, Time, ValidationError, Validity};
 
 use crate::remote::rfc8183::ServiceUri;
-use crate::util::softsigner::KeyId;
 
 //------------ MyIdentity ----------------------------------------------------
 
@@ -20,14 +19,12 @@ use crate::util::softsigner::KeyId;
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct MyIdentity {
     name: String,
-
     id_cert: IdCert,
-
-    key_id: KeyId,
+    key_id: KeyIdentifier,
 }
 
 impl MyIdentity {
-    pub fn new(name: &str, id_cert: IdCert, key_id: KeyId) -> Self {
+    pub fn new(name: &str, id_cert: IdCert, key_id: KeyIdentifier) -> Self {
         MyIdentity {
             name: name.to_string(),
             id_cert,
@@ -47,8 +44,8 @@ impl MyIdentity {
 
     /// The identifier that the Signer needs to use the key for the identity
     /// certificate.
-    pub fn key_id(&self) -> &KeyId {
-        &self.key_id
+    pub fn key_id(&self) -> KeyIdentifier {
+        self.key_id
     }
 }
 

commons/src/remote/proxy.rs

@@ -204,7 +204,7 @@ impl ProxyServer {
         let responder = self.responder_store.get_latest(&responder::id())?;
 
         let builder =
-            SignedMessageBuilder::create(responder.id().key_id(), &self.signer, msg.into_bytes())?;
+            SignedMessageBuilder::create(&responder.id().key_id(), &self.signer, msg.into_bytes())?;
 
         let enc = builder.encode();
 
@@ -391,7 +391,7 @@ impl ClientProxy {
         let key_id = self.id.key_id();
         let signer = OpenSslSigner::build(&self.work_dir)?;
 
-        let builder = SignedMessageBuilder::create(key_id, &signer, msg.into_bytes())?;
+        let builder = SignedMessageBuilder::create(&key_id, &signer, msg.into_bytes())?;
         let enc = builder.encode();
 
         Ok(enc.to_captured(Mode::Der))

commons/src/util/softsigner.rs

@@ -15,45 +15,9 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 use rpki::crypto::signer::KeyError;
 use rpki::crypto::{
-    PublicKey, PublicKeyFormat, Signature, SignatureAlgorithm, Signer, SigningError,
+    KeyIdentifier, PublicKey, PublicKeyFormat, Signature, SignatureAlgorithm, Signer, SigningError,
 };
 
-//------------ KeyId ---------------------------------------------------------
-
-#[derive(Clone, Debug, Eq, Hash, PartialEq)]
-pub struct KeyId(String);
-
-impl KeyId {
-    pub fn new(s: &str) -> Self {
-        KeyId(s.to_string())
-    }
-}
-
-impl AsRef<str> for KeyId {
-    fn as_ref(&self) -> &str {
-        &self.0
-    }
-}
-
-impl Serialize for KeyId {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        self.as_ref().serialize(serializer)
-    }
-}
-
-impl<'de> Deserialize<'de> for KeyId {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let s = String::deserialize(deserializer)?;
-        Ok(KeyId::new(&s))
-    }
-}
-
 //------------ OpenSslSigner -------------------------------------------------
 
 /// An openssl based signer.
@@ -97,7 +61,7 @@ impl OpenSslSigner {
         Ok(signature)
     }
 
-    fn load_key(&self, id: &KeyId) -> Result<OpenSslKeyPair, SignerError> {
+    fn load_key(&self, id: &KeyIdentifier) -> Result<OpenSslKeyPair, SignerError> {
         let path = self.key_path(id);
         if path.exists() {
             let f = File::open(path)?;
@@ -108,23 +72,22 @@ impl OpenSslSigner {
         }
     }
 
-    fn key_path(&self, key_id: &KeyId) -> PathBuf {
+    fn key_path(&self, key_id: &KeyIdentifier) -> PathBuf {
         let mut path = self.keys_dir.clone();
-        path.push(key_id.as_ref());
+        path.push(&key_id.to_string());
         path
     }
 }
 
 impl Signer for OpenSslSigner {
-    type KeyId = KeyId;
+    type KeyId = KeyIdentifier;
     type Error = SignerError;
 
     fn create_key(&mut self, _algorithm: PublicKeyFormat) -> Result<Self::KeyId, Self::Error> {
         let kp = OpenSslKeyPair::build()?;
 
         let pk = &kp.subject_public_key_info()?;
-        let hex_hash = hex::encode(pk.key_identifier().as_ref());
-        let key_id = KeyId(hex_hash);
+        let key_id = pk.key_identifier();
 
         let path = self.key_path(&key_id);
         let json = serde_json::to_string(&kp)?;

daemon/src/ca/certauth.rs

@@ -7,7 +7,7 @@ use bytes::Bytes;
 use chrono::Duration;
 
 use rpki::cert::{Cert, KeyUsage, Overclaim, TbsCert};
-use rpki::crypto::{PublicKey, PublicKeyFormat};
+use rpki::crypto::{KeyIdentifier, PublicKey, PublicKeyFormat};
 use rpki::x509::{Name, Serial, Time, Validity};
 
 use krill_commons::api::admin::{
@@ -29,7 +29,6 @@ use krill_commons::remote::id::IdCert;
 use krill_commons::remote::rfc6492;
 use krill_commons::remote::rfc8183::ChildRequest;
 use krill_commons::remote::sigmsg::SignedMessage;
-use krill_commons::util::softsigner::KeyId;
 
 use crate::ca::rc::PublishMode;
 use crate::ca::signing::CertSiaInfo;
@@ -42,7 +41,7 @@ use crate::ca::{
 
 #[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
 pub struct Rfc8183Id {
-    key: KeyId,
+    key: KeyIdentifier,
     cert: IdCert,
 }
 
@@ -345,7 +344,7 @@ impl<S: Signer> CertAuth<S> {
     pub fn id_cert(&self) -> &IdCert {
         &self.id.cert
     }
-    pub fn id_key(&self) -> &KeyId {
+    pub fn id_key(&self) -> &KeyIdentifier {
         &self.id.key
     }
     pub fn handle(&self) -> &Handle {
@@ -669,7 +668,7 @@ impl<S: Signer> CertAuth<S> {
             cert.set_authority_key_identifier(Some(issuing_cert.cert().subject_key_identifier()));
 
             let cert = {
-                cert.into_cert(signer, issuing_key.key_id())
+                cert.into_cert(signer, &issuing_key.key_id())
                     .map_err(Error::signer)?
             };
 
@@ -697,7 +696,7 @@ impl<S: Signer> CertAuth<S> {
         issued_certs: Vec<&IssuedCert>,
         removed_certs: Vec<&Cert>,
         signer: Arc<RwLock<S>>,
-    ) -> Result<HashMap<KeyId, PublicationDelta>> {
+    ) -> Result<HashMap<KeyIdentifier, PublicationDelta>> {
         let signer = signer.read().unwrap();
 
         let my_rc = self

daemon/src/ca/events.rs

@@ -4,7 +4,7 @@ use std::ops::{Deref, DerefMut};
 use std::sync::{Arc, RwLock};
 
 use rpki::cert::{Cert, KeyUsage, Overclaim, TbsCert};
-use rpki::crypto::PublicKeyFormat;
+use rpki::crypto::{KeyIdentifier, PublicKeyFormat};
 use rpki::uri;
 use rpki::x509::{Serial, Time, Validity};
 
@@ -19,7 +19,6 @@ use krill_commons::api::{
 };
 use krill_commons::eventsourcing::StoredEvent;
 use krill_commons::remote::id::IdCert;
-use krill_commons::util::softsigner::KeyId;
 
 use crate::ca::signing::Signer;
 use crate::ca::{ChildHandle, Error, ParentHandle, ResourceClass, Result, Rfc8183Id, RoaInfo};
@@ -259,11 +258,11 @@ pub enum EvtDet {
         ParentHandle,
         Vec<RevocationRequest>,
     ),
-    CertificateRequested(ResourceClassName, IssuanceRequest, KeyId),
-    CertificateReceived(ResourceClassName, KeyId, RcvdCert),
+    CertificateRequested(ResourceClassName, IssuanceRequest, KeyIdentifier),
+    CertificateReceived(ResourceClassName, KeyIdentifier, RcvdCert),
 
     // Key roll
-    KeyRollPendingKeyAdded(ResourceClassName, KeyId),
+    KeyRollPendingKeyAdded(ResourceClassName, KeyIdentifier),
     KeyRollActivated(ResourceClassName, RevocationRequest),
     KeyRollFinished(ResourceClassName, ObjectsDelta),
 
@@ -273,7 +272,7 @@ pub enum EvtDet {
     RoasUpdated(ResourceClassName, RoaUpdates),
 
     // Publishing
-    Published(ResourceClassName, HashMap<KeyId, PublicationDelta>),
+    Published(ResourceClassName, HashMap<KeyIdentifier, PublicationDelta>),
 }
 
 impl EvtDet {
@@ -375,7 +374,7 @@ impl EvtDet {
         handle: &Handle,
         version: u64,
         class_name: ResourceClassName,
-        deltas: HashMap<KeyId, PublicationDelta>,
+        deltas: HashMap<KeyIdentifier, PublicationDelta>,
     ) -> Evt {
         StoredEvent::new(handle, version, EvtDet::Published(class_name, deltas))
     }

daemon/src/ca/rc.rs

@@ -3,7 +3,7 @@ use std::collections::HashMap;
 use chrono::Duration;
 use serde::{Deserialize, Serialize};
 
-use rpki::crypto::PublicKeyFormat;
+use rpki::crypto::{KeyIdentifier, PublicKeyFormat};
 use rpki::csr::Csr;
 use rpki::uri;
 use rpki::x509::Time;
@@ -16,7 +16,6 @@ use krill_commons::api::ca::{
 use krill_commons::api::{
     EntitlementClass, IssuanceRequest, RequestResourceLimit, RevocationRequest, RouteAuthorization,
 };
-use krill_commons::util::softsigner::KeyId;
 
 use crate::ca::events::RoaUpdates;
 use crate::ca::{
@@ -57,7 +56,7 @@ impl ResourceClass {
         name_space: String,
         parent_handle: ParentHandle,
         parent_rc_name: ResourceClassName,
-        pending_key: KeyId,
+        pending_key: KeyIdentifier,
     ) -> Self {
         ResourceClass {
             name_space,
@@ -99,7 +98,7 @@ impl ResourceClass {
     }
 
     /// Adds a request to an existing key for future reference.
-    pub fn add_request(&mut self, key_id: KeyId, req: IssuanceRequest) {
+    pub fn add_request(&mut self, key_id: KeyIdentifier, req: IssuanceRequest) {
         self.keys.add_request(key_id, req);
     }
 
@@ -169,7 +168,7 @@ impl ResourceClass {
             match &self.keys {
                 ResourceClassKeys::Pending(pending)
                 | ResourceClassKeys::RollPending(pending, _) => {
-                    let key = CertifiedKey::new(pending.key_id().clone(), rcvd_cert.clone());
+                    let key = CertifiedKey::new(*pending.key_id(), rcvd_cert.clone());
                     PublishMode::PendingKeyActivation(key)
                 }
                 _ => PublishMode::UpdatedResources(resources),
@@ -221,7 +220,7 @@ impl ResourceClass {
 ///
 impl ResourceClass {
     /// Applies a publication delta to the appropriate key in this resource class.
-    pub fn apply_delta(&mut self, delta: PublicationDelta, key_id: KeyId) {
+    pub fn apply_delta(&mut self, delta: PublicationDelta, key_id: KeyIdentifier) {
         self.keys.apply_delta(delta, key_id);
     }
 
@@ -362,11 +361,11 @@ impl ResourceClass {
 ///
 impl ResourceClass {
     /// This function marks a certificate as received.
-    pub fn received_cert(&mut self, key_id: KeyId, cert: RcvdCert) {
+    pub fn received_cert(&mut self, key_id: KeyIdentifier, cert: RcvdCert) {
         // if there is a pending key, then we need to do some promotions..
         match &mut self.keys {
             ResourceClassKeys::Pending(pending) => {
-                let current = CertifiedKey::new(pending.key_id().clone(), cert);
+                let current = CertifiedKey::new(*pending.key_id(), cert);
                 self.last_key_change = Time::now();
                 self.keys = ResourceClassKeys::Active(current);
             }
@@ -375,7 +374,7 @@ impl ResourceClass {
             }
             ResourceClassKeys::RollPending(pending, current) => {
                 if pending.key_id() == &key_id {
-                    let new = CertifiedKey::new(pending.key_id().clone(), cert);
+                    let new = CertifiedKey::new(*pending.key_id(), cert);
                     self.last_key_change = Time::now();
                     self.keys = ResourceClassKeys::RollNew(new, current.clone());
                 } else {
@@ -400,7 +399,7 @@ impl ResourceClass {
     }
 
     /// Adds a pending key.
-    pub fn pending_key_added(&mut self, key_id: KeyId) {
+    pub fn pending_key_added(&mut self, key_id: KeyIdentifier) {
         match &self.keys {
             ResourceClassKeys::Active(current) => {
                 let pending = PendingKey::new(key_id);
@@ -599,7 +598,7 @@ type NewKey = CertifiedKey;
 type CurrentKey = CertifiedKey;
 
 impl ResourceClassKeys {
-    fn create(pending_key: KeyId) -> Self {
+    fn create(pending_key: KeyIdentifier) -> Self {
         ResourceClassKeys::Pending(PendingKey::new(pending_key))
     }
 
@@ -607,7 +606,7 @@ impl ResourceClassKeys {
         ResourceClassKeys::Active(key)
     }
 
-    fn add_request(&mut self, key_id: KeyId, req: IssuanceRequest) {
+    fn add_request(&mut self, key_id: KeyIdentifier, req: IssuanceRequest) {
         match self {
             ResourceClassKeys::Pending(pending) => pending.add_request(req),
             ResourceClassKeys::Active(current) => current.add_request(req),
@@ -695,7 +694,7 @@ impl ResourceClassKeys {
 
     fn revoke_key<S: Signer>(
         class_name: ResourceClassName,
-        key_id: &KeyId,
+        key_id: &KeyIdentifier,
         signer: &S,
     ) -> ca::Result<RevocationRequest> {
         let ki = signer
@@ -714,7 +713,7 @@ impl ResourceClassKeys {
         match self {
             ResourceClassKeys::Pending(pending) => {
                 self.matches_key_id(pending.key_id(), cert, signer)?;
-                Ok(CertifiedKey::new(pending.key_id().clone(), cert.clone()))
+                Ok(CertifiedKey::new(*pending.key_id(), cert.clone()))
             }
             ResourceClassKeys::Active(current) => {
                 self.matches_key_id(current.key_id(), cert, signer)?;
@@ -722,7 +721,7 @@ impl ResourceClassKeys {
             }
             ResourceClassKeys::RollPending(pending, current) => {
                 if self.matches_key_id(pending.key_id(), cert, signer).is_ok() {
-                    Ok(CertifiedKey::new(pending.key_id().clone(), cert.clone()))
+                    Ok(CertifiedKey::new(*pending.key_id(), cert.clone()))
                 } else {
                     self.matches_key_id(current.key_id(), cert, signer)?;
                     Ok(current.clone())
@@ -750,7 +749,7 @@ impl ResourceClassKeys {
     /// Helper to match a key_id to a pub key.
     fn matches_key_id<S: Signer>(
         &self,
-        key_id: &KeyId,
+        key_id: &KeyIdentifier,
         cert: &RcvdCert,
         signer: &S,
     ) -> ca::Result<()> {
@@ -776,12 +775,12 @@ impl ResourceClassKeys {
 
         Ok(EvtDet::CertificateReceived(
             rcn.clone(),
-            certified_key.key_id().clone(),
+            *certified_key.key_id(),
             rcvd_cert,
         ))
     }
 
-    fn apply_delta(&mut self, delta: PublicationDelta, key_id: KeyId) {
+    fn apply_delta(&mut self, delta: PublicationDelta, key_id: KeyIdentifier) {
         match self {
             ResourceClassKeys::Pending(_pending) => panic!("Should never have delta for pending"),
             ResourceClassKeys::Active(current) => current.apply_delta(delta),
@@ -856,11 +855,7 @@ impl ResourceClassKeys {
                 signer,
             )?;
 
-            res.push(EvtDet::CertificateRequested(
-                rcn.clone(),
-                req,
-                key_id.clone(),
-            ));
+            res.push(EvtDet::CertificateRequested(rcn.clone(), req, *key_id));
         }
 
         Ok(res)
@@ -917,7 +912,7 @@ impl ResourceClassKeys {
         base_repo: &RepoInfo,
         name_space: &str,
         class_name: ResourceClassName,
-        key: &KeyId,
+        key: &KeyIdentifier,
         signer: &S,
     ) -> Result<IssuanceRequest> {
         let pub_key = signer.get_key_info(key).map_err(Error::signer)?;
@@ -989,7 +984,7 @@ impl ResourceClassKeys {
                 )?;
 
                 Ok(vec![
-                    EvtDet::KeyRollPendingKeyAdded(class_name.clone(), key_id.clone()),
+                    EvtDet::KeyRollPendingKeyAdded(class_name.clone(), key_id),
                     EvtDet::CertificateRequested(class_name, issuance_req, key_id),
                 ])
             }

daemon/src/ca/routes.rs

@@ -1,12 +1,12 @@
 use std::collections::HashMap;
 
+use rpki::crypto::KeyIdentifier;
 use rpki::roa::{Roa, RoaBuilder};
 use rpki::sigobj::SignedObjectBuilder;
 use rpki::x509::{Serial, Time};
 
 use krill_commons::api::ca::{RcvdCert, ReplacedObject};
 use krill_commons::api::RouteAuthorization;
-use krill_commons::util::softsigner::KeyId;
 
 use crate::ca::events::RoaUpdates;
 use crate::ca::{self, SignSupport, Signer};
@@ -149,7 +149,7 @@ impl Roas {
     pub fn make_roa<S: Signer>(
         auth: &RouteAuthorization,
         incoming_cert: &RcvdCert,
-        signing_key: &KeyId,
+        signing_key: &KeyIdentifier,
         signer: &S,
     ) -> ca::Result<Roa> {
         let prefix = auth.prefix();

daemon/src/ca/server.rs

@@ -6,6 +6,7 @@ use std::sync::{Arc, RwLock};
 use bytes::Bytes;
 use chrono::Duration;
 
+use rpki::crypto::KeyIdentifier;
 use rpki::uri;
 
 use krill_commons::api;
@@ -25,7 +26,6 @@ use krill_commons::remote::builder::SignedMessageBuilder;
 use krill_commons::remote::sigmsg::SignedMessage;
 use krill_commons::remote::{rfc6492, rfc8183};
 use krill_commons::util::httpclient;
-use krill_commons::util::softsigner::KeyId;
 
 use crate::ca::{
     self, ta_handle, CertAuth, ChildHandle, CmdDet, IniDet, ParentHandle, ServerError,
@@ -534,7 +534,7 @@ impl<S: Signer> CaServer<S> {
     fn send_revoke_requests_rfc6492(
         &self,
         revoke_requests: HashMap<ResourceClassName, Vec<RevocationRequest>>,
-        signing_key: &KeyId,
+        signing_key: &KeyIdentifier,
         parent_res: &rfc8183::ParentResponse,
     ) -> ServerResult<HashMap<ResourceClassName, Vec<RevocationResponse>>, S> {
         let mut revoke_map = HashMap::new();
@@ -643,7 +643,7 @@ impl<S: Signer> CaServer<S> {
     fn send_cert_requests_rfc6492(
         &self,
         requests: HashMap<ResourceClassName, Vec<IssuanceRequest>>,
-        signing_key: &KeyId,
+        signing_key: &KeyIdentifier,
         parent_res: &rfc8183::ParentResponse,
     ) -> ServerResult<HashMap<ResourceClassName, Vec<IssuedCert>>, S> {
         let mut issued_map = HashMap::new();
@@ -753,7 +753,7 @@ impl<S: Signer> CaServer<S> {
 
     fn send_rfc6492_and_validate_response(
         &self,
-        signing_key: &KeyId,
+        signing_key: &KeyIdentifier,
         parent_res: &rfc8183::ParentResponse,
         msg: Bytes,
     ) -> ServerResult<rfc6492::Res, S> {

daemon/src/ca/signing.rs

@@ -14,12 +14,17 @@ use krill_commons::api::ca::{
     AddedObject, CertifiedKey, CurrentObject, ObjectsDelta, PublicationDelta, RepoInfo, Revocation,
     RevocationsDelta, UpdatedObject,
 };
-use krill_commons::util::softsigner::KeyId;
 
 //------------ Signer --------------------------------------------------------
 
-pub trait Signer: crypto::Signer<KeyId = KeyId> + Clone + Sized + Sync + Send + 'static {}
-impl<T: crypto::Signer<KeyId = KeyId> + Clone + Sized + Sync + Send + 'static> Signer for T {}
+pub trait Signer:
+    crypto::Signer<KeyId = KeyIdentifier> + Clone + Sized + Sync + Send + 'static
+{
+}
+impl<T: crypto::Signer<KeyId = KeyIdentifier> + Clone + Sized + Sync + Send + 'static> Signer
+    for T
+{
+}
 
 //------------ CertSiaInfo ---------------------------------------------------