openpgp: Annotate MPI lengths with the fields name.

  - Fixes #220.

2 files changed, 60 insertions, 41 deletions

diff --git a/openpgp/src/parse/mpis.rs b/openpgp/src/parse/mpis.rs
index 8bf11667..76164be0 100644
--- a/openpgp/src/parse/mpis.rs
+++ b/openpgp/src/parse/mpis.rs
@@ -49,17 +49,17 @@ impl mpis::PublicKey {
         #[allow(deprecated)]
         match algo {
             RSAEncryptSign | RSAEncrypt | RSASign => {
-                let n = MPI::parse("rsa_public_n", php)?;
-                let e = MPI::parse("rsa_public_e", php)?;
+                let n = MPI::parse("rsa_public_n_len", "rsa_public_n", php)?;
+                let e = MPI::parse("rsa_public_e_len", "rsa_public_e", php)?;
 
                 Ok(mpis::PublicKey::RSA { e: e, n: n })
             }
 
             DSA => {
-                let p = MPI::parse("dsa_public_p", php)?;
-                let q = MPI::parse("dsa_public_q", php)?;
-                let g = MPI::parse("dsa_public_g", php)?;
-                let y = MPI::parse("dsa_public_y", php)?;
+                let p = MPI::parse("dsa_public_p_len", "dsa_public_p", php)?;
+                let q = MPI::parse("dsa_public_q_len", "dsa_public_q", php)?;
+                let g = MPI::parse("dsa_public_g_len", "dsa_public_g", php)?;
+                let y = MPI::parse("dsa_public_y_len", "dsa_public_y", php)?;
 
                 Ok(mpis::PublicKey::DSA {
                     p: p,
@@ -70,9 +70,12 @@ impl mpis::PublicKey {
             }
 
             ElgamalEncrypt | ElgamalEncryptSign => {
-                let p = MPI::parse("elgamal_public_p", php)?;
-                let g = MPI::parse("elgamal_public_g", php)?;
-                let y = MPI::parse("elgamal_public_y", php)?;
+                let p = MPI::parse("elgamal_public_p_len", "elgamal_public_p",
+                                   php)?;
+                let g = MPI::parse("elgamal_public_g_len", "elgamal_public_g",
+                                   php)?;
+                let y = MPI::parse("elgamal_public_y_len", "elgamal_public_y",
+                                   php)?;
 
                 Ok(mpis::PublicKey::Elgamal {
                     p: p,
@@ -84,7 +87,7 @@ impl mpis::PublicKey {
             EdDSA => {
                 let curve_len = php.parse_u8("curve_len")? as usize;
                 let curve = php.parse_bytes("curve", curve_len)?;
-                let q = MPI::parse("eddsa_public", php)?;
+                let q = MPI::parse("eddsa_public_len", "eddsa_public", php)?;
 
                 Ok(mpis::PublicKey::EdDSA {
                     curve: Curve::from_oid(&curve),
@@ -95,7 +98,7 @@ impl mpis::PublicKey {
             ECDSA => {
                 let curve_len = php.parse_u8("curve_len")? as usize;
                 let curve = php.parse_bytes("curve", curve_len)?;
-                let q = MPI::parse("ecdsa_public", php)?;
+                let q = MPI::parse("ecdsa_public_len", "ecdsa_public", php)?;
 
                 Ok(mpis::PublicKey::ECDSA {
                     curve: Curve::from_oid(&curve),
@@ -106,7 +109,7 @@ impl mpis::PublicKey {
             ECDH => {
                 let curve_len = php.parse_u8("curve_len")? as usize;
                 let curve = php.parse_bytes("curve", curve_len)?;
-                let q = MPI::parse("ecdh_public", php)?;
+                let q = MPI::parse("ecdh_public_len", "ecdh_public", php)?;
                 let kdf_len = php.parse_u8("kdf_len")?;
 
                 if kdf_len != 3 {
@@ -128,7 +131,8 @@ impl mpis::PublicKey {
 
             Unknown(_) | Private(_) => {
                 let mut mpis = Vec::new();
-                while let Ok(mpi) = MPI::parse("unknown_parameter", php) {
+                while let Ok(mpi) = MPI::parse("unknown_parameter_len",
+                                               "unknown_parameter", php) {
                     mpis.push(mpi);
                 }
                 let mut rest = php.parse_bytes_eof("rest")?;
@@ -210,10 +214,10 @@ impl mpis::SecretKey {
         #[allow(deprecated)]
         match algo {
             RSAEncryptSign | RSAEncrypt | RSASign => {
-                let d = MPI::parse("rsa_secret_d", php)?;
-                let p = MPI::parse("rsa_secret_p", php)?;
-                let q = MPI::parse("rsa_secret_q", php)?;
-                let u = MPI::parse("rsa_secret_u", php)?;
+                let d = MPI::parse("rsa_secret_d_len", "rsa_secret_d", php)?;
+                let p = MPI::parse("rsa_secret_p_len", "rsa_secret_p", php)?;
+                let q = MPI::parse("rsa_secret_q_len", "rsa_secret_q", php)?;
+                let u = MPI::parse("rsa_secret_u_len", "rsa_secret_u", php)?;
 
                 Ok(mpis::SecretKey::RSA {
                     d: d,
@@ -224,7 +228,7 @@ impl mpis::SecretKey {
             }
 
             DSA => {
-                let x = MPI::parse("dsa_secret", php)?;
+                let x = MPI::parse("dsa_secret_len", "dsa_secret", php)?;
 
                 Ok(mpis::SecretKey::DSA {
                     x: x,
@@ -232,7 +236,8 @@ impl mpis::SecretKey {
             }
 
             ElgamalEncrypt | ElgamalEncryptSign => {
-                let x = MPI::parse("elgamal_secret", php)?;
+                let x = MPI::parse("elgamal_secret_len", "elgamal_secret",
+                                   php)?;
 
                 Ok(mpis::SecretKey::Elgamal {
                     x: x,
@@ -241,25 +246,26 @@ impl mpis::SecretKey {
 
             EdDSA => {
                 Ok(mpis::SecretKey::EdDSA {
-                    scalar: MPI::parse("eddsa_secret", php)?
+                    scalar: MPI::parse("eddsa_secret_len", "eddsa_secret", php)?
                 })
             }
 
             ECDSA => {
                 Ok(mpis::SecretKey::ECDSA {
-                    scalar: MPI::parse("ecdsa_secret", php)?
+                    scalar: MPI::parse("ecdsa_secret_len", "ecdsa_secret", php)?
                 })
             }
 
             ECDH => {
                 Ok(mpis::SecretKey::ECDH {
-                    scalar: MPI::parse("ecdh_secret", php)?
+                    scalar: MPI::parse("ecdh_secret_len", "ecdh_secret", php)?
                 })
             }
 
             Unknown(_) | Private(_) => {
                 let mut mpis = Vec::new();
-                while let Ok(mpi) = MPI::parse("unknown_parameter", php) {
+                while let Ok(mpi) = MPI::parse("unknown_parameter_len",
+                                               "unknown_parameter", php) {
                     mpis.push(mpi);
                 }
                 let mut rest = php.parse_bytes_eof("rest")?;
@@ -306,7 +312,8 @@ impl mpis::Ciphertext {
         #[allow(deprecated)]
         match algo {
             RSAEncryptSign | RSAEncrypt => {
-                let c = MPI::parse("rsa_ciphertext", php)?;
+                let c = MPI::parse("rsa_ciphertext_len", "rsa_ciphertext",
+                                   php)?;
 
                 Ok(mpis::Ciphertext::RSA {
                     c: c,
@@ -314,8 +321,8 @@ impl mpis::Ciphertext {
             }
 
             ElgamalEncrypt | ElgamalEncryptSign => {
-                let e = MPI::parse("elgamal_e", php)?;
-                let c = MPI::parse("elgamal_c", php)?;
+                let e = MPI::parse("elgamal_e_len", "elgamal_e", php)?;
+                let c = MPI::parse("elgamal_c_len", "elgamal_c", php)?;
 
                 Ok(mpis::Ciphertext::Elgamal {
                     e: e,
@@ -324,7 +331,7 @@ impl mpis::Ciphertext {
             }
 
             ECDH => {
-                let e = MPI::parse("ecdh_e", php)?;
+                let e = MPI::parse("ecdh_e_len", "ecdh_e", php)?;
                 let key_len = php.parse_u8("ecdh_esk_len")? as usize;
                 let key = Vec::from(&php.parse_bytes("ecdh_esk", key_len)?
                                     [..key_len]);
@@ -336,7 +343,8 @@ impl mpis::Ciphertext {
 
             Unknown(_) | Private(_) => {
                 let mut mpis = Vec::new();
-                while let Ok(mpi) = MPI::parse("unknown_parameter", php) {
+                while let Ok(mpi) = MPI::parse("unknown_parameter_len",
+                                               "unknown_parameter", php) {
                     mpis.push(mpi);
                 }
                 let mut rest = php.parse_bytes_eof("rest")?;
@@ -386,7 +394,7 @@ impl mpis::Signature {
         #[allow(deprecated)]
         match algo {
             RSAEncryptSign | RSASign => {
-                let s = MPI::parse("rsa_signature", php)?;
+                let s = MPI::parse("rsa_signature_len", "rsa_signature", php)?;
 
                 Ok(mpis::Signature::RSA {
                     s: s,
@@ -394,8 +402,10 @@ impl mpis::Signature {
             }
 
             DSA => {
-                let r = MPI::parse("dsa_signature_r", php)?;
-                let s = MPI::parse("dsa_signature_s", php)?;
+                let r = MPI::parse("dsa_signature_r_len", "dsa_signature_r",
+                                   php)?;
+                let s = MPI::parse("dsa_signature_s_len", "dsa_signature_s",
+                                   php)?;
 
                 Ok(mpis::Signature::DSA {
                     r: r,
@@ -404,8 +414,10 @@ impl mpis::Signature {
             }
 
             ElgamalEncryptSign => {
-                let r = MPI::parse("elgamal_signature_r", php)?;
-                let s = MPI::parse("elgamal_signature_s", php)?;
+                let r = MPI::parse("elgamal_signature_r_len",
+                                   "elgamal_signature_r", php)?;
+                let s = MPI::parse("elgamal_signature_s_len",
+                                   "elgamal_signature_s", php)?;
 
                 Ok(mpis::Signature::Elgamal {
                     r: r,
@@ -414,8 +426,10 @@ impl mpis::Signature {
             }
 
             EdDSA => {
-                let r = MPI::parse("eddsa_signature_r", php)?;
-                let s = MPI::parse("eddsa_signature_s", php)?;
+                let r = MPI::parse("eddsa_signature_r_len", "eddsa_signature_r",
+                                   php)?;
+                let s = MPI::parse("eddsa_signature_s_len", "eddsa_signature_s",
+                                   php)?;
 
                 Ok(mpis::Signature::EdDSA {
                     r: r,
@@ -424,8 +438,10 @@ impl mpis::Signature {
             }
 
             ECDSA => {
-                let r = MPI::parse("ecdsa_signature_r", php)?;
-                let s = MPI::parse("ecdsa_signature_s", php)?;
+                let r = MPI::parse("ecdsa_signature_r_len", "ecdsa_signature_r",
+                                   php)?;
+                let s = MPI::parse("ecdsa_signature_s_len", "ecdsa_signature_s",
+                                   php)?;
 
                 Ok(mpis::Signature::ECDSA {
                     r: r,
@@ -435,7 +451,8 @@ impl mpis::Signature {
 
             Unknown(_) | Private(_) => {
                 let mut mpis = Vec::new();
-                while let Ok(mpi) = MPI::parse("unknown_parameter", php) {
+                while let Ok(mpi) = MPI::parse("unknown_parameter_len",
+                                               "unknown_parameter", php) {
                     mpis.push(mpi);
                 }
                 let mut rest = php.parse_bytes_eof("rest")?;
diff --git a/openpgp/src/parse/parse.rs b/openpgp/src/parse/parse.rs
index 54eeab0a..629bba32 100644
--- a/openpgp/src/parse/parse.rs
+++ b/openpgp/src/parse/parse.rs
@@ -2191,8 +2191,10 @@ impl MPI {
     /// See [Section 3.2 of RFC 4880] for details.
     ///
     ///   [Section 3.2 of RFC 4880]: https://tools.ietf.org/html/rfc4880#section-3.2
-    fn parse<'a>(name: &'static str, php: &mut PacketHeaderParser<'a>) -> Result<Self> {
-        let bits = php.parse_be_u16("mpi_len")? as usize;
+    fn parse<'a>(name_len: &'static str, name: &'static str,
+                 php: &mut PacketHeaderParser<'a>)
+                 -> Result<Self> {
+        let bits = php.parse_be_u16(name_len)? as usize;
         if bits == 0 {
             return Ok(MPI{ bits: 0, value: vec![].into_boxed_slice()});
         }
@@ -2312,7 +2314,7 @@ impl<'a> Parse<'a, MPI> for MPI {
         let bio = buffered_reader::Generic::with_cookie(
             reader, None, Cookie::default());
         let mut parser = PacketHeaderParser::new_naked(Box::new(bio));
-        Self::parse("(none)", &mut parser)
+        Self::parse("(none_len)", "(none)", &mut parser)
     }
 }