Bug 1716518 - Upgrade block-padding to v0.1.5. r=emilio (1854b2fc) · Commits · clairehurst / Tor Browser

Cargo.lock

+2 −2

Original line number	Diff line number	Diff line
		@@ -398,9 +398,9 @@ dependencies = [

		[[package]]
		name = "block-padding"
		version = "0.1.2"
		version = "0.1.5"
		source = "registry+https://github.com/rust-lang/crates.io-index"
		checksum = "4fc4358306e344bf9775d0197fd00d2603e5afb0771bb353538630f022068ea3"
		checksum = "fa79dedbb091f449f1f39e53edf88d5dbe95f895dae6135a8d7b881fb5af73f5"
		dependencies = [
		"byte-tools",
		]

third_party/rust/block-padding/.cargo-checksum.json

+1 −1

Original line number	Diff line number	Diff line
		{"files":{"Cargo.toml":"31334ebd0923996ae8fb76ee87f9b2d75cc9e85c5126ef614e184af56dd96403","LICENSE-APACHE":"a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5","LICENSE-MIT":"f7e8ab639afef15573680c97f796166835cbeb3865175882fea41c60d106b733","src/lib.rs":"812d9b3b472539aa4cc78745313d088879aafa8d1baa69872bc1ca8ee5bcfa41"},"package":"4fc4358306e344bf9775d0197fd00d2603e5afb0771bb353538630f022068ea3"}
		No newline at end of file
		{"files":{"Cargo.toml":"f895c4794f1c00f5f01376dae2b66870d939a01b9a366ee4d177b6b7ad99bd4a","LICENSE-APACHE":"a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5","LICENSE-MIT":"d5c22aa3118d240e877ad41c5d9fa232f9c77d757d4aac0c2f943afc0a95e0ef","src/lib.rs":"962c90d43c7c2761b3c96fab2713ae357a7a8d2d048e37ce4f3354941ad41b97"},"package":"fa79dedbb091f449f1f39e53edf88d5dbe95f895dae6135a8d7b881fb5af73f5"}
		No newline at end of file

third_party/rust/block-padding/Cargo.toml

+3 −3

Original line number	Diff line number	Diff line
		@@ -3,7 +3,7 @@
		# When uploading crates to the registry Cargo will automatically
		# "normalize" Cargo.toml files for maximal compatibility
		# with all versions of Cargo and also rewrite `path` dependencies
		# to registry (e.g. crates.io) dependencies
		# to registry (e.g., crates.io) dependencies
		#
		# If you believe there's an error in this file please file an
		# issue against the rust-lang/cargo repository. If you're
		@@ -12,13 +12,13 @@

		[package]
		name = "block-padding"
		version = "0.1.2"
		version = "0.1.5"
		authors = ["RustCrypto Developers"]
		description = "Padding and unpadding of messages divided into blocks."
		documentation = "https://docs.rs/block-padding"
		keywords = ["padding", "pkcs7", "ansix923", "iso7816"]
		categories = ["cryptography", "no-std"]
		license = "MIT/Apache-2.0"
		license = "MIT OR Apache-2.0"
		repository = "https://github.com/RustCrypto/utils"
		[dependencies.byte-tools]
		version = "0.3"

third_party/rust/block-padding/LICENSE-MIT

+1 −1

Original line number	Diff line number	Diff line
		Copyright (c) 2018 Artyom Pavlov
		Copyright (c) 2018-2019 The RustCrypto Project Developers

		Permission is hereby granted, free of charge, to any
		person obtaining a copy of this software and associated

third_party/rust/block-padding/src/lib.rs

+62 −15

Original line number	Diff line number	Diff line
		@@ -31,22 +31,18 @@ pub trait Padding {

		/// Pads message with length `pos` in the provided buffer.
		///
		/// `&buf[..pos]` is percieved as the message, buffer must contain at
		/// least one block of leftover space, i.e. `buf.len() - pos >= block_size`
		/// must be true. Otherwise method will return `PadError`.
		/// `&buf[..pos]` is perceived as the message, the buffer must contain
		/// enough leftover space for padding: `block_size - (pos % block_size)`
		/// extra bytes must be available. Otherwise method will return
		/// `PadError`.
		fn pad(buf: &mut [u8], pos: usize, block_size: usize)
		-> Result<&mut [u8], PadError>
		{
		if buf.len() - pos < block_size { Err(PadError)? }
		if pos % block_size == 0 {
		Self::pad_block(&mut buf[pos..pos + block_size], 0)?;
		Ok(&mut buf[..pos+block_size])
		} else {
		let bs = block_size * (pos / block_size);
		if buf.len() < bs \|\| buf.len() - bs < block_size { Err(PadError)? }
		Self::pad_block(&mut buf[bs..bs+block_size], pos - bs)?;
		Ok(&mut buf[..bs+block_size])
		}
		}

		/// Unpad given `data` by truncating it according to the used padding.
		/// In case of the malformed padding will return `UnpadError`
		@@ -123,7 +119,7 @@ impl Padding for ZeroPadding {
		///
		/// let msg = b"test";
		/// let n = msg.len();
		/// let mut buffer = [0xff; 16];
		/// let mut buffer = [0xff; 8];
		/// buffer[..n].copy_from_slice(msg);
		/// let padded_msg = Pkcs7::pad(&mut buffer, n, 8).unwrap();
		/// assert_eq!(padded_msg, b"test\x04\x04\x04\x04");
		@@ -133,7 +129,7 @@ impl Padding for ZeroPadding {
		/// # use block_padding::{Pkcs7, Padding};
		/// # let msg = b"test";
		/// # let n = msg.len();
		/// # let mut buffer = [0xff; 16];
		/// # let mut buffer = [0xff; 8];
		/// # buffer[..n].copy_from_slice(msg);
		/// let padded_msg = Pkcs7::pad(&mut buffer, n, 2).unwrap();
		/// assert_eq!(padded_msg, b"test\x02\x02");
		@@ -141,6 +137,11 @@ impl Padding for ZeroPadding {
		/// ```
		/// ```
		/// # use block_padding::{Pkcs7, Padding};
		/// let mut buffer = [0xff; 5];
		/// assert!(Pkcs7::pad(&mut buffer, 4, 2).is_err());
		/// ```
		/// ```
		/// # use block_padding::{Pkcs7, Padding};
		/// # let buffer = [0xff; 16];
		/// assert!(Pkcs7::unpad(&buffer).is_err());
		/// ```
		@@ -171,7 +172,7 @@ impl Padding for Pkcs7 {
		}
		}

		/// Pad block with zeros excpet the last byte which will be set to the number
		/// Pad block with zeros except the last byte which will be set to the number
		/// bytes.
		///
		/// ```
		@@ -274,3 +275,49 @@ impl Padding for Iso7816 {
		Ok(&data[..n])
		}
		}

		/// Don't pad the data. Useful for key wrapping. Padding will fail if the data cannot be
		/// fitted into blocks without padding.
		///
		/// ```
		/// use block_padding::{NoPadding, Padding};
		///
		/// let msg = b"test";
		/// let n = msg.len();
		/// let mut buffer = [0xff; 16];
		/// buffer[..n].copy_from_slice(msg);
		/// let padded_msg = NoPadding::pad(&mut buffer, n, 4).unwrap();
		/// assert_eq!(padded_msg, b"test");
		/// assert_eq!(NoPadding::unpad(&padded_msg).unwrap(), msg);
		/// ```
		/// ```
		/// # use block_padding::{NoPadding, Padding};
		/// # let msg = b"test";
		/// # let n = msg.len();
		/// # let mut buffer = [0xff; 16];
		/// # buffer[..n].copy_from_slice(msg);
		/// let padded_msg = NoPadding::pad(&mut buffer, n, 2).unwrap();
		/// assert_eq!(padded_msg, b"test");
		/// assert_eq!(NoPadding::unpad(&padded_msg).unwrap(), msg);
		/// ```
		pub enum NoPadding {}

		impl Padding for NoPadding {
		fn pad_block(block: &mut [u8], pos: usize) -> Result<(), PadError> {
		if pos % block.len() != 0 {
		Err(PadError)?
		}
		Ok(())
		}

		fn pad(buf: &mut [u8], pos: usize, block_size: usize) -> Result<&mut [u8], PadError> {
		if pos % block_size != 0 {
		Err(PadError)?
		}
		Ok(&mut buf[..pos])
		}

		fn unpad(data: &[u8]) -> Result<&[u8], UnpadError> {
		Ok(data)
		}
		}