Rename PublicKey to RecipientKey

src/format.rs

@@ -5,7 +5,7 @@ use std::io::{self, Read, Write};
 use x25519_dalek::{x25519, X25519_BASEPOINT_BYTES};
 
 use crate::{
-    keys::{PublicKey, SecretKey},
+    keys::{RecipientKey, SecretKey},
     primitives::{aead_decrypt, aead_encrypt, hkdf, HmacWriter, Stream},
 };
 
@@ -36,9 +36,9 @@ enum Recipient {
 }
 
 impl Recipient {
-    fn encrypt(file_key: &[u8; 16], pubkey: &PublicKey) -> Self {
+    fn encrypt(file_key: &[u8; 16], pubkey: &RecipientKey) -> Self {
         match pubkey {
-            PublicKey::X25519(pk) => {
+            RecipientKey::X25519(pk) => {
                 let mut esk = [0; 32];
                 getrandom(&mut esk).expect("Should not fail");
                 let epk = x25519(esk, X25519_BASEPOINT_BYTES);
@@ -90,11 +90,14 @@ pub struct Header {
 /// Creates a wrapper around a writer that will encrypt its input to the given recipients.
 ///
 /// Returns errors from the underlying writer while writing the header.
-pub fn encrypt_message<W: Write>(mut output: W, pubkeys: &[PublicKey]) -> io::Result<impl Write> {
+pub fn encrypt_message<W: Write>(
+    mut output: W,
+    recipients: &[RecipientKey],
+) -> io::Result<impl Write> {
     let mut file_key = [0; 16];
     getrandom(&mut file_key).expect("Should not fail");
 
-    let recipients = pubkeys
+    let recipients = recipients
         .iter()
         .map(|pk| Recipient::encrypt(&file_key, pk))
         .collect();

src/keys.rs

@@ -44,18 +44,18 @@ impl SecretKey {
         }
     }
 
-    pub fn to_public(&self) -> PublicKey {
+    pub fn to_public(&self) -> RecipientKey {
         match self {
-            SecretKey::X25519(sk) => PublicKey::X25519(x25519(*sk, X25519_BASEPOINT_BYTES)),
+            SecretKey::X25519(sk) => RecipientKey::X25519(x25519(*sk, X25519_BASEPOINT_BYTES)),
         }
     }
 }
 
-pub enum PublicKey {
+pub enum RecipientKey {
     X25519([u8; 32]),
 }
 
-impl PublicKey {
+impl RecipientKey {
     pub fn from_str(s: &str) -> Option<Self> {
         match s.find(PUBLIC_KEY_PREFIX) {
             Some(0) => (),
@@ -68,7 +68,7 @@ impl PublicKey {
                 if buf.len() == 32 {
                     let mut pk = [0; 32];
                     pk.copy_from_slice(&buf);
-                    Some(PublicKey::X25519(pk))
+                    Some(RecipientKey::X25519(pk))
                 } else {
                     println!("Invalid decoded length");
                     None
@@ -78,7 +78,7 @@ impl PublicKey {
 
     pub fn to_str(&self) -> String {
         match self {
-            PublicKey::X25519(pk) => format!(
+            RecipientKey::X25519(pk) => format!(
                 "{}{}",
                 PUBLIC_KEY_PREFIX,
                 base64::encode_config(&pk, base64::URL_SAFE_NO_PAD)
@@ -89,7 +89,7 @@ impl PublicKey {
 
 #[cfg(test)]
 mod tests {
-    use super::{PublicKey, SecretKey};
+    use super::{RecipientKey, SecretKey};
 
     const TEST_SK: &str = "AGE_SECRET_KEY_RQvvHYA29yZk8Lelpiz8lW7QdlxkE4djb1NOjLgeUFg";
     const TEST_PK: &str = "pubkey:X4ZiZYoURuOqC2_GPISYiWbJn1-j_HECyac7BpD6kHU";
@@ -101,7 +101,7 @@ mod tests {
 
     #[test]
     fn pubkey_encoding() {
-        assert_eq!(PublicKey::from_str(TEST_PK).unwrap().to_str(), TEST_PK);
+        assert_eq!(RecipientKey::from_str(TEST_PK).unwrap().to_str(), TEST_PK);
     }
 
     #[test]

src/main.rs

@@ -6,9 +6,9 @@ mod format;
 mod keys;
 mod primitives;
 
-/// Reads a pubkey from a command-line argument.
-fn read_pubkey(arg: String) -> io::Result<keys::PublicKey> {
-    if let Some(pk) = keys::PublicKey::from_str(&arg) {
+/// Reads a recipient from a command-line argument.
+fn read_recipient(arg: String) -> io::Result<keys::RecipientKey> {
+    if let Some(pk) = keys::RecipientKey::from_str(&arg) {
         Ok(pk)
     } else {
         Err(io::Error::new(
@@ -18,8 +18,8 @@ fn read_pubkey(arg: String) -> io::Result<keys::PublicKey> {
     }
 }
 
-/// Reads pubkeys from the provided arguments.
-fn read_pubkeys(arguments: Vec<String>) -> io::Result<Vec<keys::PublicKey>> {
+/// Reads recipients from the provided arguments.
+fn read_recipients(arguments: Vec<String>) -> io::Result<Vec<keys::RecipientKey>> {
     if arguments.is_empty() {
         return Err(io::Error::new(
             io::ErrorKind::InvalidInput,
@@ -29,7 +29,7 @@ fn read_pubkeys(arguments: Vec<String>) -> io::Result<Vec<keys::PublicKey>> {
 
     arguments
         .into_iter()
-        .map(read_pubkey)
+        .map(read_recipient)
         .collect::<Result<_, _>>()
 }
 
@@ -128,8 +128,8 @@ struct AgeOptions {
 }
 
 fn encrypt(opts: AgeOptions) {
-    let pubkeys = match read_pubkeys(opts.arguments) {
-        Ok(pubkeys) => pubkeys,
+    let recipients = match read_recipients(opts.arguments) {
+        Ok(recipients) => recipients,
         Err(e) => {
             eprintln!("Error while reading recipients: {}", e);
             return;
@@ -145,7 +145,7 @@ fn encrypt(opts: AgeOptions) {
     };
 
     let mut encrypted = vec![];
-    match format::encrypt_message(&mut encrypted, &pubkeys) {
+    match format::encrypt_message(&mut encrypted, &recipients) {
         Ok(mut w) => {
             if let Err(e) = w.write_all(&plaintext) {
                 eprintln!("Error while encrypting: {}", e);