Can't borrow data as a '&' reference as mutable - rust

Question

I have this function that looks like this
Install Magic-Crypt to reproduce the error.
magic-crypt = "3.1.10"
Import the following: pub use magic_crypt::{new_magic_crypt, MagicCryptTrait, MagicCryptError};
Here is the function
pub fn magic_decrypt(mut phrase: &String, hash: &String, decrypt: String) -> Option<Result<String, MagicCryptError>> {
println!("Please insert your decryption phrase: ");
std::io::stdin().read_line(&mut phrase).expect("Failed to read line");
if &hash_string(&phrase.replace("\r", "").clone().to_string()) == hash {
println!("Success, you've entered the correct phrase, decrypting...");
return Some(new_magic_crypt!(phrase.replace("\r", "").clone().to_string(), 256).decrypt_base64_to_string(&decrypt));
} else {
println!("Failed to enter the correct phrase, please try again.");
while &hash_string(&phrase.replace("\r", "").clone().to_string()) != hash {
println!("Please insert your decryption phrase: ");
std::io::stdin().read_line(&mut phrase).expect("Failed to read line");
let _phrase = phrase.replace("\r", "").clone().to_string();
}
return None;
}
}
The problem is that I get these errors (despite me setting the variable as mutable)
error[E0596]: cannot borrow data in a `&` reference as mutable
--> crypto/crypto.rs:78:40
|
78 | std::io::stdin().read_line(&mut phrase).expect("Failed to read line");
| ^^^^^^^^^^^ cannot borrow as mutable
What can I do to fix this? If this question is bad, please tell me as well, thanks!

Answer 1

mut phrase: &String means that the phrase variable is a mutable object that references an immutable string. What you probably tried to do is phrase: &mut String, which is an immutable variable that references a mutable string.
You can then also remove the &mut reborrow at the read_line function call.
pub fn magic_decrypt(phrase: &mut String, hash: &String, decrypt: String) -> Option<Result<String, MagicCryptError>> {
println!("Please insert your decryption phrase: ");
std::io::stdin().read_line(phrase).expect("Failed to read line");
if &hash_string(&phrase.replace("\r", "").clone().to_string()) == hash {
println!("Success, you've entered the correct phrase, decrypting...");
return Some(new_magic_crypt!(phrase.replace("\r", "").clone().to_string(), 256).decrypt_base64_to_string(&decrypt));
} else {
println!("Failed to enter the correct phrase, please try again.");
while &hash_string(&phrase.replace("\r", "").clone().to_string()) != hash {
println!("Please insert your decryption phrase: ");
std::io::stdin().read_line(phrase).expect("Failed to read line");
let _phrase = phrase.replace("\r", "").clone().to_string();
}
return None;
}
}
Further problems I detected:
.replace() already returns a String, .clone() on it creates the same String again, and to_string() yet again creates the same String. Just leave out the entire .clone().to_string().
use &str instead of &String in your arguments as it is a strict superset of it. This also eliminates all the & borrows you use to compare String with &String, as String is directly comparable with &str.
the let _phrase = phrase.replace(...) does nothing.
return statements in Rust at the end of a {} are not necessary, you can directly write None instead of return None;.
if you replace a single character, it is recommended to specify it as a char instead of a string ('\r' instead of "\r").
You always return None if you enter the else case, even if a correct phrase was entered. This one probably requires structural changes in your if/while constructs.
Your code isn't formatted with cargo fmt. I recommend enabling auto-format.
Some of those fixes come from cargo clippy, which I can recommend to run from time to time as it gives valuable insights for improving your code quality.
Here I fixed some of those.
pub fn magic_decrypt(
phrase: &mut String,
hash: &str,
decrypt: &str,
) -> Option<Result<String, MagicCryptError>> {
println!("Please insert your decryption phrase: ");
std::io::stdin()
.read_line(phrase)
.expect("Failed to read line");
if hash_string(&phrase.replace('\r', "")) == hash {
println!("Success, you've entered the correct phrase, decrypting...");
Some(new_magic_crypt!(phrase.replace('\r', ""), 256).decrypt_base64_to_string(decrypt))
} else {
println!("Failed to enter the correct phrase, please try again.");
while hash_string(&phrase.replace('\r', "")) != hash {
println!("Please insert your decryption phrase: ");
std::io::stdin()
.read_line(phrase)
.expect("Failed to read line");
let _phrase = phrase.replace('\r', "");
}
None
}
}
The last point I mentioned, that you always return None in your else case, seems to indicate that your if/while layout is incorrect.
This is just a wild guess, but I assume you attempted to write something like this:
pub fn magic_decrypt(
phrase: &mut String,
hash: &str,
decrypt: &str,
) -> Result<String, MagicCryptError> {
println!("Please insert your decryption phrase: ");
loop {
std::io::stdin()
.read_line(phrase)
.expect("Failed to read line");
*phrase = phrase.trim_end().to_string();
if hash_string(phrase) == hash {
println!("Success, you've entered the correct phrase, decrypting...");
break new_magic_crypt!(hash, 256).decrypt_base64_to_string(decrypt);
} else {
println!("Failed to enter the correct phrase, please try again.");
}
}
}
A last point I would like to mention because it's quite important: If you use hashing for storing passwords, it's crucial that you use salting.