openpgp: Make fields of SKESK packet private.

4 files changed, 46 insertions, 31 deletions

diff --git a/openpgp/src/parse/parse.rs b/openpgp/src/parse/parse.rs
index aa088cee..191fdd7e 100644
--- a/openpgp/src/parse/parse.rs
+++ b/openpgp/src/parse/parse.rs
@@ -1669,13 +1669,13 @@ impl SKESK {
         let s2k = php_try!(S2K::parse(&mut php));
         let esk = php_try!(php.parse_bytes_eof("esk"));
 
-        php.ok(Packet::SKESK(SKESK {
-            common: Default::default(),
-            version: version,
-            symm_algo: symm_algo.into(),
-            s2k: s2k,
-            esk: if esk.len() > 0 { Some(esk) } else { None },
-        }))
+        let skesk = php_try!(SKESK::new(
+            version,
+            symm_algo.into(),
+            s2k,
+            if esk.len() > 0 { Some(esk) } else { None },
+        ));
+        php.ok(Packet::SKESK(skesk))
     }
 }
 
@@ -1710,8 +1710,8 @@ fn skesk_parser_test() {
         if let Packet::SKESK(ref skesk) = pp.packet {
             eprintln!("{:?}", skesk);
 
-            assert_eq!(skesk.symm_algo, test.cipher_algo);
-            assert_eq!(skesk.s2k, test.s2k);
+            assert_eq!(skesk.symmetric_algo(), test.cipher_algo);
+            assert_eq!(skesk.s2k(), &test.s2k);
 
             match skesk.decrypt(&test.password) {
                 Ok((_symm_algo, key)) => {
diff --git a/openpgp/src/s2k.rs b/openpgp/src/s2k.rs
index eebf5e8d..4f7d0d71 100644
--- a/openpgp/src/s2k.rs
+++ b/openpgp/src/s2k.rs
@@ -376,12 +376,12 @@ mod tests {
             let path = path_to(test.filename);
             let mut pp = PacketParser::from_file(path).unwrap().unwrap();
             if let Packet::SKESK(ref skesk) = pp.packet {
-                assert_eq!(skesk.symm_algo, test.cipher_algo);
-                assert_eq!(skesk.s2k, test.s2k);
+                assert_eq!(skesk.symmetric_algo(), test.cipher_algo);
+                assert_eq!(skesk.s2k(), &test.s2k);
 
-                let key = skesk.s2k.derive_key(
+                let key = skesk.s2k().derive_key(
                     &test.password,
-                    skesk.symm_algo.key_size().unwrap());
+                    skesk.symmetric_algo().key_size().unwrap());
                 if let Ok(key) = key {
                     let key = to_hex(&key[..], false);
                     assert_eq!(key, test.key_hex);
diff --git a/openpgp/src/serialize/mod.rs b/openpgp/src/serialize/mod.rs
index bb9e3faf..a87477db 100644
--- a/openpgp/src/serialize/mod.rs
+++ b/openpgp/src/serialize/mod.rs
@@ -987,7 +987,7 @@ impl Serialize for SKESK {
     ///
     /// [`Error::InvalidArgument`]: ../enum.Error.html#variant.InvalidArgument
     fn serialize<W: io::Write>(&self, o: &mut W) -> Result<()> {
-        if self.version != 4 {
+        if self.version() != 4 {
             return Err(Error::InvalidArgument(
                 "Don't know how to serialize \
                  non-version 4 packets.".into()).into());
@@ -996,16 +996,16 @@ impl Serialize for SKESK {
         let len =
             1 // Version
             + 1 // Algo
-            + self.s2k.serialized_len() // s2k.
-            + self.esk.as_ref().map(|esk| esk.len()).unwrap_or(0); // ESK.
+            + self.s2k().serialized_len() // s2k.
+            + self.esk().map(|esk| esk.len()).unwrap_or(0); // ESK.
 
         CTB::new(Tag::SKESK).serialize(o)?;
         BodyLength::Full(len as u32).serialize(o)?;
 
-        write_byte(o, self.version)?;
-        write_byte(o, self.symm_algo.into())?;
-        self.s2k.serialize(o)?;
-        if let Some(ref esk) = self.esk {
+        write_byte(o, self.version())?;
+        write_byte(o, self.symmetric_algo().into())?;
+        self.s2k().serialize(o)?;
+        if let Some(ref esk) = self.esk() {
             o.write(&esk[..])?;
         }
 
diff --git a/openpgp/src/skesk.rs b/openpgp/src/skesk.rs
index 0a5674cb..e12625e5 100644
--- a/openpgp/src/skesk.rs
+++ b/openpgp/src/skesk.rs
@@ -19,16 +19,37 @@ pub struct SKESK {
     /// CTB header fields.
     pub(crate) common: packet::Common,
     /// Packet version. Must be 4.
-    pub(crate) version: u8,
+    version: u8,
     /// Symmetric algorithm used to encrypt the session key.
-    pub(crate) symm_algo: SymmetricAlgorithm,
+    symm_algo: SymmetricAlgorithm,
     /// Key derivation method for the symmetric key.
-    pub(crate) s2k: S2K,
+    s2k: S2K,
     /// The encrypted session key.
-    pub(crate) esk: Option<Vec<u8>>,
+    esk: Option<Vec<u8>>,
 }
 
 impl SKESK {
+    /// Creates a new SKESK packet.
+    ///
+    /// The given symmetric algorithm must match the algorithm that is
+    /// used to encrypt the payload, and is also used to encrypt the
+    /// given session key.
+    pub fn new(version: u8, cipher: SymmetricAlgorithm, s2k: S2K,
+               esk: Option<Vec<u8>>) -> Result<SKESK> {
+        if version != 4 {
+            return Err(Error::InvalidArgument(
+                format!("Invalid version: {}", version)).into());
+        }
+
+        Ok(SKESK{
+            common: Default::default(),
+            version: version,
+            symm_algo: cipher,
+            s2k: s2k,
+            esk: esk,
+        })
+    }
+
     /// Creates a new SKESK packet with the given password.
     ///
     /// The given symmetric algorithm must match the algorithm that is
@@ -54,13 +75,7 @@ impl SKESK {
                 cipher.encrypt(&mut iv[..], ct, pt);
         }
 
-        Ok(SKESK{
-            common: Default::default(),
-            version: 4,
-            symm_algo: algo,
-            s2k: s2k,
-            esk: Some(esk),
-        })
+        SKESK::new(4, algo, s2k, Some(esk))
     }
 
     /// Gets the version.