Merge pull request #183 from ionut-arm/format-log

Improve log security

Author: ionut-arm

src/front/domain_socket.rs

@@ -88,13 +88,13 @@ impl Listen for DomainSocketListener {
         match stream_result {
             Ok((stream, _)) => {
                 if let Err(err) = stream.set_read_timeout(Some(self.timeout)) {
-                    error!("Failed to set read timeout ({})", err);
+                    format_error!("Failed to set read timeout", err);
                     None
                 } else if let Err(err) = stream.set_write_timeout(Some(self.timeout)) {
-                    error!("Failed to set write timeout ({})", err);
+                    format_error!("Failed to set write timeout", err);
                     None
                 } else if let Err(err) = stream.set_nonblocking(false) {
-                    error!("Failed to set stream as blocking ({})", err);
+                    format_error!("Failed to set stream as blocking", err);
                     None
                 } else {
                     Some(Box::from(stream))
@@ -104,7 +104,7 @@ impl Listen for DomainSocketListener {
                 // Check if the error is because no connections are currently present.
                 if err.kind() != ErrorKind::WouldBlock {
                     // Only log the real errors.
-                    error!("Failed to connect with a UnixStream ({})", err);
+                    format_error!("Failed to connect with a UnixStream", err);
                 }
                 None
             }

src/front/front_end.rs

@@ -7,7 +7,7 @@
 use crate::authenticators::Authenticate;
 use crate::back::dispatcher::Dispatcher;
 use derivative::Derivative;
-use log::{error, info, trace};
+use log::{info, trace};
 use parsec_interface::requests::AuthType;
 use parsec_interface::requests::ResponseStatus;
 use parsec_interface::requests::{Request, Response};
@@ -47,11 +47,11 @@ impl FrontEndHandler {
         let request = match Request::read_from_stream(&mut stream, self.body_len_limit) {
             Ok(request) => request,
             Err(status) => {
-                error!("Failed to read request; status: {}", status);
+                format_error!("Failed to read request", status);
 
                 let response = Response::from_status(status);
                 if let Err(status) = response.write_to_stream(&mut stream) {
-                    error!("Failed to write response; status: {}", status);
+                    format_error!("Failed to write response", status);
                 }
                 return;
             }
@@ -85,7 +85,7 @@ impl FrontEndHandler {
         // Write bytes to stream
         match response.write_to_stream(&mut stream) {
             Ok(_) => info!("Request handled successfully"),
-            Err(err) => error!("Failed to send response; error: {}", err),
+            Err(err) => format_error!("Failed to send response", err),
         }
     }
 }

src/key_info_managers/mod.rs

@@ -8,7 +8,6 @@
 //! means but it has to be persistent.
 
 use crate::authenticators::ApplicationName;
-use log::error;
 use parsec_interface::operations::psa_key_attributes::Attributes;
 use parsec_interface::requests::{ProviderID, ResponseStatus};
 use serde::{Deserialize, Serialize};
@@ -75,8 +74,8 @@ impl KeyTriple {
 /// Converts the error string returned by the ManageKeyInfo methods to
 /// ResponseStatus::KeyInfoManagerError.
 pub fn to_response_status(error_string: String) -> ResponseStatus {
-    error!(
-        "Converting error string \"{}\" to ResponseStatus:KeyInfoManagerError.",
+    format_error!(
+        "Converting error to ResponseStatus:KeyInfoManagerError",
         error_string
     );
     ResponseStatus::KeyInfoManagerError

src/key_info_managers/on_disk_manager/mod.rs

@@ -187,12 +187,14 @@ impl OnDiskKeyInfoManager {
         for app_name_dir_path in list_dirs(&mappings_dir_path)?.iter() {
             for provider_dir_path in list_dirs(&app_name_dir_path)?.iter() {
                 for key_name_file_path in list_files(&provider_dir_path)?.iter() {
-                    info!("Found mapping file: {:?}.", key_name_file_path);
+                    if crate::utils::GlobalConfig::log_error_details() {
+                        info!("Found mapping file: {:?}.", key_name_file_path);
+                    }
                     let mut key_info = Vec::new();
                     let mut key_info_file = File::open(&key_name_file_path)?;
                     let _ = key_info_file.read_to_end(&mut key_info)?;
                     let key_info = bincode::deserialize(&key_info[..]).or_else(|e| {
-                        error!("Error deserializing key info ({}).", e);
+                        format_error!("Error deserializing key info", e);
                         Err(Error::new(ErrorKind::Other, "error deserializing key info"))
                     })?;
                     match base64_data_triple_to_key_triple(
@@ -210,13 +212,20 @@ impl OnDiskKeyInfoManager {
                             let _ = key_store.insert(key_triple, key_info);
                         }
                         Err(string) => {
-                            error!("Failed to convert the mapping path found to an UTF-8 string (error: {}).", string);
+                            format_error!(
+                                "Failed to convert the mapping path found to an UTF-8 string",
+                                string
+                            );
                         }
                     }
                 }
             }
         }
 
+        if !crate::utils::GlobalConfig::log_error_details() {
+            info!("Found {} mapping files", key_store.len());
+        }
+
         Ok(OnDiskKeyInfoManager {
             key_store,
             mappings_dir_path,
@@ -240,7 +249,7 @@ impl OnDiskKeyInfoManager {
 
         let mut mapping_file = fs::File::create(&key_name_file_path)?;
         mapping_file.write_all(&bincode::serialize(key_info).or_else(|e| {
-            error!("Error serializing key info ({}).", e);
+            format_error!("Error serializing key info", e);
             Err(Error::new(ErrorKind::Other, "error serializing key info"))
         })?)
     }

src/providers/core_provider/mod.rs

@@ -6,7 +6,7 @@
 //! aiding clients in discovering the capabilities offered by their underlying
 //! platform.
 use super::Provide;
-use log::{error, trace};
+use log::trace;
 use parsec_interface::operations::list_providers::ProviderInfo;
 use parsec_interface::operations::{list_opcodes, list_providers, ping};
 use parsec_interface::requests::{Opcode, ProviderID, ResponseStatus, Result};
@@ -73,7 +73,7 @@ pub struct CoreProviderBuilder {
 impl CoreProviderBuilder {
     pub fn new() -> std::io::Result<Self> {
         let crate_version: Version = Version::from_str(version!()).or_else(|e| {
-            error!("Error parsing the crate version: {}.", e);
+            format_error!("Error parsing the crate version", e);
             Err(Error::new(
                 ErrorKind::InvalidData,
                 "crate version number has invalid format",

src/providers/pkcs11_provider/asym_sign.rs

@@ -71,7 +71,9 @@ impl Pkcs11Provider {
         };
 
         let session = Session::new(self, ReadWriteSession::ReadWrite)?;
-        info!("Asymmetric sign in session {}", session.session_handle());
+        if crate::utils::GlobalConfig::log_error_details() {
+            info!("Asymmetric sign in session {}", session.session_handle());
+        }
 
         let key = self.find_key(session.session_handle(), key_id, KeyPairType::PrivateKey)?;
         info!("Located signing key.");
@@ -96,7 +98,7 @@ impl Pkcs11Provider {
                 }
             }
             Err(e) => {
-                error!("Failed to initialize signing operation. Error: {}", e);
+                format_error!("Failed to initialize signing operation", e);
                 Err(utils::to_response_status(e))
             }
         }
@@ -155,7 +157,9 @@ impl Pkcs11Provider {
         };
 
         let session = Session::new(self, ReadWriteSession::ReadWrite)?;
-        info!("Asymmetric verify in session {}", session.session_handle());
+        if crate::utils::GlobalConfig::log_error_details() {
+            info!("Asymmetric verify in session {}", session.session_handle());
+        }
 
         let key = self.find_key(session.session_handle(), key_id, KeyPairType::PublicKey)?;
         info!("Located public key.");
@@ -183,7 +187,7 @@ impl Pkcs11Provider {
                 }
             }
             Err(e) => {
-                error!("Failed to initialize verifying operation. Error: {}", e);
+                format_error!("Failed to initialize verifying operation", e);
                 Err(utils::to_response_status(e))
             }
         }