February 2018 - tor-commits - lists.torproject.org

[tor/master] Avoid a malloc/free pair for each (server-side) ntor handshake
by nickm＠torproject.org 16 Feb '18

16 Feb '18

commit e3d4154486b278e1ee68f97c3445817759b0f73c Author: Nick Mathewson <nickm(a)torproject.org> Date: Mon Feb 5 11:50:16 2018 -0500 Avoid a malloc/free pair for each (server-side) ntor handshake Closes ticket 25150 --- changes/feature25150 | 4 ++++ src/or/onion.c | 5 ++--- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/changes/feature25150 b/changes/feature25150 new file mode 100644 index 000000000..eb65327a8 --- /dev/null +++ b/changes/feature25150 @@ -0,0 +1,4 @@ + o Minor features (performance, allocation): + - Avoid a needless malloc()/free() pair every time we handle an ntor + handshake. Closes ticket 25150. + diff --git a/src/or/onion.c b/src/or/onion.c index bd80c2f50..4fc501383 100644 --- a/src/or/onion.c +++ b/src/or/onion.c @@ -563,20 +563,19 @@ onion_skin_server_handshake(int type, return -1; { size_t keys_tmp_len = keys_out_len + DIGEST_LEN; - uint8_t *keys_tmp = tor_malloc(keys_out_len + DIGEST_LEN); + uint8_t keys_tmp[keys_tmp_len]; if (onion_skin_ntor_server_handshake( onion_skin, keys->curve25519_key_map, keys->junk_keypair, keys->my_identity, reply_out, keys_tmp, keys_tmp_len)<0) { - tor_free(keys_tmp); + /* no need to memwipe here, since the output will never be used */ return -1; } memcpy(keys_out, keys_tmp, keys_out_len); memcpy(rend_nonce_out, keys_tmp+keys_out_len, DIGEST_LEN); memwipe(keys_tmp, 0, keys_tmp_len); - tor_free(keys_tmp); r = NTOR_REPLY_LEN; } break;

1 0

[tor/master] Fix a stack-protector warning: don't use a variable-length buffer
by nickm＠torproject.org 16 Feb '18

16 Feb '18

commit 4d994e7a9c8936c9e33df90b7468e7327f1794e9 Author: Nick Mathewson <nickm(a)torproject.org> Date: Thu Feb 15 20:52:01 2018 -0500 Fix a stack-protector warning: don't use a variable-length buffer Instead, define a maximum size, and enforce it with an assertion. --- src/or/onion.c | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/src/or/onion.c b/src/or/onion.c index 4fc501383..0c88c4d7e 100644 --- a/src/or/onion.c +++ b/src/or/onion.c @@ -521,6 +521,11 @@ onion_skin_create(int type, return r; } +/* This is the maximum value for keys_out_len passed to + * onion_skin_server_handshake, plus 16. We can make it bigger if needed: + * It just defines how many bytes to stack-allocate. */ +#define MAX_KEYS_TMP_LEN 128 + /** Perform the second (server-side) step of a circuit-creation handshake of * type type, responding to the client request in onion_skin * using the keys in keys. On success, write our response into @@ -563,7 +568,8 @@ onion_skin_server_handshake(int type, return -1; { size_t keys_tmp_len = keys_out_len + DIGEST_LEN; - uint8_t keys_tmp[keys_tmp_len]; + tor_assert(keys_tmp_len <= MAX_KEYS_TMP_LEN); + uint8_t keys_tmp[MAX_KEYS_TMP_LEN]; if (onion_skin_ntor_server_handshake( onion_skin, keys->curve25519_key_map, @@ -573,9 +579,10 @@ onion_skin_server_handshake(int type, /* no need to memwipe here, since the output will never be used */ return -1; } + memcpy(keys_out, keys_tmp, keys_out_len); memcpy(rend_nonce_out, keys_tmp+keys_out_len, DIGEST_LEN); - memwipe(keys_tmp, 0, keys_tmp_len); + memwipe(keys_tmp, 0, sizeof(keys_tmp)); r = NTOR_REPLY_LEN; } break;

1 0

[tor/master] Merge branch 'onion_ntor_malloc_less'
by nickm＠torproject.org 16 Feb '18

16 Feb '18

commit ed1d630f0e3d2d733989eefe9fce5c287a7ca6c9 Merge: 28c3f538e e3d415448 Author: Nick Mathewson <nickm(a)torproject.org> Date: Thu Feb 15 20:40:03 2018 -0500 Merge branch 'onion_ntor_malloc_less' changes/feature25150 | 4 ++++ src/or/onion.c | 5 ++--- 2 files changed, 6 insertions(+), 3 deletions(-)

1 0

[tor/master] In relay_digest_matches(), use stack instead of heap.
by nickm＠torproject.org 16 Feb '18

16 Feb '18

commit 91c63aae8497bc9de6533daae8f927ca09f96fd2 Author: Nick Mathewson <nickm(a)torproject.org> Date: Wed Jan 24 12:33:13 2018 -0500 In relay_digest_matches(), use stack instead of heap. We'd been using crypto_digest_dup() and crypto_digest_assign() here, but they aren't necessary. Instead we can just use the stack to store the previous state of the SHA_CTX and avoid a malloc/free pair. Closes ticket 24914. --- changes/bug24914 | 3 +++ configure.ac | 4 ++++ src/common/crypto.c | 28 ++++++++++++++++++++++++++++ src/common/crypto.h | 11 +++++++++++ src/or/relay.c | 16 +++++++++------- 5 files changed, 55 insertions(+), 7 deletions(-) diff --git a/changes/bug24914 b/changes/bug24914 new file mode 100644 index 000000000..ea441fd38 --- /dev/null +++ b/changes/bug24914 @@ -0,0 +1,3 @@ + o Minor features (performance): + - Avoid a needless call to malloc() when processing an incoming + relay cell. Closes ticket 24914. diff --git a/configure.ac b/configure.ac index 3cb187b0e..0ba4c4652 100644 --- a/configure.ac +++ b/configure.ac @@ -834,6 +834,10 @@ AC_CHECK_MEMBERS([SSL.state], , , [#include <openssl/ssl.h> ]) +AC_CHECK_SIZEOF(SHA_CTX, , [AC_INCLUDES_DEFAULT() +#include <openssl/sha.h> +]) + dnl Define the set of checks for KIST scheduler support. AC_DEFUN([CHECK_KIST_SUPPORT],[ dnl KIST needs struct tcp_info and for certain members to exist. diff --git a/src/common/crypto.c b/src/common/crypto.c index 107b53ad2..880f92b4d 100644 --- a/src/common/crypto.c +++ b/src/common/crypto.c @@ -1822,6 +1822,7 @@ crypto_digest_alloc_bytes(digest_algorithm_t alg) /* Gives the length of crypto_digest_t through the end of the field 'd' */ #define END_OF_FIELD(f) (offsetof(crypto_digest_t, f) + \ STRUCT_FIELD_SIZE(crypto_digest_t, f)) + switch (alg) { case DIGEST_SHA1: return END_OF_FIELD(d.sha1); @@ -2007,6 +2008,33 @@ crypto_digest_dup(const crypto_digest_t *digest) return tor_memdup(digest, alloc_bytes); } +/** Temporarily save the state of digest in checkpoint. + * Asserts that digest is a SHA1 digest object. + */ +void +crypto_digest_checkpoint(crypto_digest_checkpoint_t *checkpoint, + const crypto_digest_t *digest) +{ + tor_assert(digest->algorithm == DIGEST_SHA1); + /* The optimizer should turn this into a constant... */ + const size_t bytes = crypto_digest_alloc_bytes(DIGEST_SHA1); + /* ... and remove this assertion entirely. */ + tor_assert(bytes <= sizeof(checkpoint->mem)); + memcpy(checkpoint->mem, digest, bytes); +} + +/** Restore the state of digest from checkpoint. + * Asserts that digest is a SHA1 digest object. Requires that the + * state was previously stored with crypto_digest_checkpoint() */ +void +crypto_digest_restore(crypto_digest_t *digest, + const crypto_digest_checkpoint_t *checkpoint) +{ + tor_assert(digest->algorithm == DIGEST_SHA1); + const size_t bytes = crypto_digest_alloc_bytes(DIGEST_SHA1); + memcpy(digest, checkpoint->mem, bytes); +} + /** Replace the state of the digest object into with the state * of the digest object from. Requires that 'into' and 'from' * have the same digest type. diff --git a/src/common/crypto.h b/src/common/crypto.h index 3caa23773..852ab9ba7 100644 --- a/src/common/crypto.h +++ b/src/common/crypto.h @@ -98,6 +98,13 @@ typedef struct crypto_digest_t crypto_digest_t; typedef struct crypto_xof_t crypto_xof_t; typedef struct crypto_dh_t crypto_dh_t; +#define DIGEST_CHECKPOINT_BYTES (SIZEOF_VOID_P + SIZEOF_SHA_CTX) +/** Structure used to temporarily save the a digest object. Only implemented + * for SHA1 digest for now. */ +typedef struct crypto_digest_checkpoint_t { + uint8_t mem[DIGEST_CHECKPOINT_BYTES]; +} crypto_digest_checkpoint_t; + /* global state */ int crypto_early_init(void) ATTR_WUR; int crypto_global_init(int hardwareAccel, @@ -235,6 +242,10 @@ void crypto_digest_add_bytes(crypto_digest_t *digest, const char *data, void crypto_digest_get_digest(crypto_digest_t *digest, char *out, size_t out_len); crypto_digest_t *crypto_digest_dup(const crypto_digest_t *digest); +void crypto_digest_checkpoint(crypto_digest_checkpoint_t *checkpoint, + const crypto_digest_t *digest); +void crypto_digest_restore(crypto_digest_t *digest, + const crypto_digest_checkpoint_t *checkpoint); void crypto_digest_assign(crypto_digest_t *into, const crypto_digest_t *from); void crypto_hmac_sha256(char *hmac_out, diff --git a/src/or/relay.c b/src/or/relay.c index b1b99526d..aa53cda77 100644 --- a/src/or/relay.c +++ b/src/or/relay.c @@ -151,9 +151,9 @@ relay_digest_matches(crypto_digest_t *digest, cell_t *cell) { uint32_t received_integrity, calculated_integrity; relay_header_t rh; - crypto_digest_t *backup_digest=NULL; + crypto_digest_checkpoint_t backup_digest; - backup_digest = crypto_digest_dup(digest); + crypto_digest_checkpoint(&backup_digest, digest); relay_header_unpack(&rh, cell->payload); memcpy(&received_integrity, rh.integrity, 4); @@ -167,19 +167,21 @@ relay_digest_matches(crypto_digest_t *digest, cell_t *cell) crypto_digest_add_bytes(digest, (char*) cell->payload, CELL_PAYLOAD_SIZE); crypto_digest_get_digest(digest, (char*) &calculated_integrity, 4); + int rv = 1; + if (calculated_integrity != received_integrity) { // log_fn(LOG_INFO,"Recognized=0 but bad digest. Not recognizing."); // (%d vs %d).", received_integrity, calculated_integrity); /* restore digest to its old form */ - crypto_digest_assign(digest, backup_digest); + crypto_digest_restore(digest, &backup_digest); /* restore the relay header */ memcpy(rh.integrity, &received_integrity, 4); relay_header_pack(cell->payload, &rh); - crypto_digest_free(backup_digest); - return 0; + rv = 0; } - crypto_digest_free(backup_digest); - return 1; + + memwipe(&backup_digest, 0, sizeof(backup_digest)); + return rv; } /** Apply cipher to CELL_PAYLOAD_SIZE bytes of in

1 0

[tor/master] Documentation fixes suggested by catalyst.
by nickm＠torproject.org 16 Feb '18

16 Feb '18

commit 28c3f538e50af1b4a10e613856841ea8ca41bc33 Author: Nick Mathewson <nickm(a)torproject.org> Date: Thu Feb 15 20:38:08 2018 -0500 Documentation fixes suggested by catalyst. --- src/rust/tor_util/strings.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/rust/tor_util/strings.rs b/src/rust/tor_util/strings.rs index 4e26e7369..505191d91 100644 --- a/src/rust/tor_util/strings.rs +++ b/src/rust/tor_util/strings.rs @@ -83,10 +83,10 @@ /// # Note /// /// An unfortunate limitation of the rustc compiler (as of 1.25.0-nightly), is -/// that the above code compiles, however if we were to change the assignment of -/// `tuesday` as follows, it will fail to compile, because Rust macros are -/// expanded at parse time, and at parse time there is no symbols table -/// available. +/// that the first example above compiles, but if we were to change the +/// assignment of `tuesday` as follows, it will fail to compile, because Rust +/// macros are expanded at parse time, and at parse time there is no symbol +/// table available. /// /// ```ignore /// tuesday = cstr!(message);

1 0

[tor/master] rust: Use tor_util::strings utils for protover_get_supported_protocols.
by nickm＠torproject.org 16 Feb '18

16 Feb '18

commit 3c4e006e7e9597ef0d478ef63c811c764926bfbe Author: Isis Lovecruft <isis(a)torproject.org> Date: Thu Feb 8 22:08:11 2018 +0000 rust: Use tor_util::strings utils for protover_get_supported_protocols. --- src/rust/protover/ffi.rs | 14 +-------- src/rust/protover/lib.rs | 1 + src/rust/protover/protover.rs | 71 ++++++++++++++++++++++++------------------- 3 files changed, 41 insertions(+), 45 deletions(-) diff --git a/src/rust/protover/ffi.rs b/src/rust/protover/ffi.rs index 2ee0286ec..404b15838 100644 --- a/src/rust/protover/ffi.rs +++ b/src/rust/protover/ffi.rs @@ -15,7 +15,6 @@ use tor_allocate::allocate_and_copy_string; use tor_util::strings::byte_slice_is_c_like; use tor_util::strings::empty_static_cstr; - /// Translate C enums to Rust Proto enums, using the integer value of the C /// enum to map to its associated Rust enum /// @@ -143,18 +142,7 @@ pub extern "C" fn protocol_list_supports_protocol_or_later( pub extern "C" fn protover_get_supported_protocols() -> *const c_char { let supported: &'static CStr; - // If we're going to pass it to C, there cannot be any intermediate NUL - // bytes. An assert is okay here, since changing the const byte slice - // in protover.rs to contain a NUL byte somewhere in the middle would be a - // programming error. - assert!(byte_slice_is_c_like(SUPPORTED_PROTOCOLS)); - - // It's okay to unwrap the result of this function because - // we can see that the bytes we're passing into it 1) are valid UTF-8, - // 2) have no intermediate NUL bytes, and 3) are terminated with a NUL - // byte. - supported = CStr::from_bytes_with_nul(SUPPORTED_PROTOCOLS).unwrap(); - + supported = get_supported_protocols_cstr(); supported.as_ptr() } diff --git a/src/rust/protover/lib.rs b/src/rust/protover/lib.rs index fe8c0f9bb..8e80fcef4 100644 --- a/src/rust/protover/lib.rs +++ b/src/rust/protover/lib.rs @@ -26,6 +26,7 @@ extern crate libc; extern crate smartlist; extern crate external; extern crate tor_allocate; +#[macro_use] extern crate tor_util; mod protover; diff --git a/src/rust/protover/protover.rs b/src/rust/protover/protover.rs index 25f776aed..d354d8e25 100644 --- a/src/rust/protover/protover.rs +++ b/src/rust/protover/protover.rs @@ -5,6 +5,7 @@ use external::c_tor_version_as_new_as; use std::str; use std::str::FromStr; +use std::ffi::CStr; use std::fmt; use std::collections::{HashMap, HashSet}; use std::ops::Range; @@ -25,30 +26,6 @@ const FIRST_TOR_VERSION_TO_ADVERTISE_PROTOCOLS: &'static str = "0.2.9.3-alpha"; /// C_RUST_COUPLED: src/or/protover.c `MAX_PROTOCOLS_TO_EXPAND` const MAX_PROTOCOLS_TO_EXPAND: u32 = 500; -/// Currently supported protocols and their versions, as a byte-slice. -/// -/// # Warning -/// -/// This byte-slice ends in a NUL byte. This is so that we can directly convert -/// it to an `&'static CStr` in the FFI code, in order to hand the static string -/// to C in a way that is compatible with C static strings. -/// -/// Rust code which wishes to accesses this string should use -/// `protover::get_supported_protocols()` instead. -/// -/// C_RUST_COUPLED: src/or/protover.c `protover_get_supported_protocols` -pub(crate) const SUPPORTED_PROTOCOLS: &'static [u8] = - b"Cons=1-2 \ - Desc=1-2 \ - DirCache=1-2 \ - HSDir=1-2 \ - HSIntro=3-4 \ - HSRend=1-2 \ - Link=1-5 \ - LinkAuth=1,3 \ - Microdesc=1-2 \ - Relay=1-2\0"; - /// Known subprotocols in Tor. Indicates which subprotocol a relay supports. /// /// C_RUST_COUPLED: src/or/protover.h `protocol_type_t` @@ -96,21 +73,51 @@ impl FromStr for Proto { } } -/// Get the string representation of current supported protocols +/// Get a CStr representation of current supported protocols, for +/// passing to C, or for converting to a `&str` for Rust. /// /// # Returns /// -/// A `String` whose value is the existing protocols supported by tor. +/// An `&'static CStr` whose value is the existing protocols supported by tor. /// Returned data is in the format as follows: /// /// "HSDir=1-1 LinkAuth=1" /// -pub fn get_supported_protocols() -> &'static str { - // The `len() - 1` is to remove the NUL byte. - // The `unwrap` is safe becauase we SUPPORTED_PROTOCOLS is under - // our control. - str::from_utf8(&SUPPORTED_PROTOCOLS[..SUPPORTED_PROTOCOLS.len() - 1]) - .unwrap_or("") +/// # Note +/// +/// Rust code can use the `&'static CStr` as a normal `&'a str` by +/// calling `protover::get_supported_protocols`. +/// +// C_RUST_COUPLED: src/or/protover.c `protover_get_supported_protocols` +pub(crate) fn get_supported_protocols_cstr() -> &'static CStr { + cstr!("Cons=1-2 \ + Desc=1-2 \ + DirCache=1-2 \ + HSDir=1-2 \ + HSIntro=3-4 \ + HSRend=1-2 \ + Link=1-5 \ + LinkAuth=1,3 \ + Microdesc=1-2 \ + Relay=1-2") +} + +/// Get a string representation of current supported protocols. +/// +/// # Returns +/// +/// An `&'a str` whose value is the existing protocols supported by tor. +/// Returned data is in the format as follows: +/// +/// "HSDir=1-1 LinkAuth=1" +pub fn get_supported_protocols<'a>() -> &'a str { + let supported_cstr: &'static CStr = get_supported_protocols_cstr(); + let supported: &str = match supported_cstr.to_str() { + Ok(x) => x, + Err(_) => "", + }; + + supported } pub struct SupportedProtocols(HashMap<Proto, Versions>);

1 0

[tor/master] rust: Remove empty_static_cstr() in favour of new cstr!() macro.
by nickm＠torproject.org 16 Feb '18

16 Feb '18

commit 081e99c16f754ffd5605acdfddec527a2a426ed8 Author: Isis Lovecruft <isis(a)torproject.org> Date: Sat Feb 10 01:41:06 2018 +0000 rust: Remove empty_static_cstr() in favour of new cstr!() macro. --- src/rust/protover/ffi.rs | 3 +-- src/rust/tor_util/strings.rs | 39 --------------------------------------- 2 files changed, 1 insertion(+), 41 deletions(-) diff --git a/src/rust/protover/ffi.rs b/src/rust/protover/ffi.rs index c86fe7522..1df0b6675 100644 --- a/src/rust/protover/ffi.rs +++ b/src/rust/protover/ffi.rs @@ -13,7 +13,6 @@ use protover::*; use smartlist::*; use tor_allocate::allocate_and_copy_string; use tor_util::strings::byte_slice_is_c_like; -use tor_util::strings::empty_static_cstr; /// Translate C enums to Rust Proto enums, using the integer value of the C /// enum to map to its associated Rust enum @@ -192,7 +191,7 @@ pub extern "C" fn protover_compute_for_old_tor(version: *const c_char) -> *const let supported: &'static CStr; let empty: &'static CStr; - empty = empty_static_cstr(); + empty = cstr!(""); if version.is_null() { return empty.as_ptr(); diff --git a/src/rust/tor_util/strings.rs b/src/rust/tor_util/strings.rs index 659e792a3..dc4919d80 100644 --- a/src/rust/tor_util/strings.rs +++ b/src/rust/tor_util/strings.rs @@ -3,8 +3,6 @@ //! Utilities for working with static strings. -use std::ffi::CStr; - /// A byte-array containing a single NUL byte (`b"\0"`). pub const NUL_BYTE: &'static [u8] = b"\0"; @@ -44,43 +42,6 @@ pub fn byte_slice_is_c_like(bytes: &[u8]) -> bool { false } -/// Get a static `CStr` containing a single `NUL_BYTE`. -/// -/// # Examples -/// -/// When used as follows in a Rust FFI function, which could be called -/// from C: -/// -/// ``` -/// # extern crate libc; -/// # extern crate tor_util; -/// # -/// # use tor_util::strings::empty_static_cstr; -/// use libc::c_char; -/// use std::ffi::CStr; -/// -/// pub extern "C" fn give_c_code_an_empty_static_string() -> *const c_char { -/// let empty: &'static CStr = empty_static_cstr(); -/// -/// empty.as_ptr() -/// } -/// -/// # fn main() { -/// # give_c_code_an_empty_static_string(); -/// # } -/// ``` -/// -/// This equates to an "empty" `const char*` static string in C. -pub fn empty_static_cstr() -> &'static CStr { - let empty: &'static CStr; - - unsafe { - empty = CStr::from_bytes_with_nul_unchecked(NUL_BYTE); - } - - empty -} - /// Create a `CStr` from a literal byte slice, appending a NUL byte to it first. /// /// # Warning

1 0

[tor/master] rust: Add macro for passing static borrowed strings from Rust to C.
by nickm＠torproject.org 16 Feb '18

16 Feb '18

commit 8fff331bb095dc6f5e2fe2ecfc9ab08ea9e2fe97 Author: Isis Lovecruft <isis(a)torproject.org> Date: Thu Feb 8 20:06:19 2018 +0000 rust: Add macro for passing static borrowed strings from Rust to C. * ADD a new macro, tor_util::string::cstr!() which takes Rust strings, concatenates them together, appends a NUL byte, and converts it into a std::ffi::CStr for handing to C. --- src/rust/tor_util/strings.rs | 136 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 136 insertions(+) diff --git a/src/rust/tor_util/strings.rs b/src/rust/tor_util/strings.rs index 9321ce4f8..659e792a3 100644 --- a/src/rust/tor_util/strings.rs +++ b/src/rust/tor_util/strings.rs @@ -80,3 +80,139 @@ pub fn empty_static_cstr() -> &'static CStr { empty } + +/// Create a `CStr` from a literal byte slice, appending a NUL byte to it first. +/// +/// # Warning +/// +/// The literal byte slice which is taken as an argument *MUST NOT* have any NUL +/// bytes (`b"\0"`) in it, anywhere, or else an empty string will be returned +/// (`CStr::from_bytes_with_nul_unchecked(b"\0")`) so as to avoid `panic!()`ing. +/// +/// # Examples +/// +/// ``` +/// #[macro_use] +/// extern crate tor_util; +/// +/// use std::ffi::CStr; +/// +/// # fn do_test() -> Result<&'static CStr, &'static str> { +/// let message: &'static str = "This is a test of the tsunami warning system."; +/// let tuesday: &'static CStr; +/// let original: &str; +/// +/// tuesday = cstr!("This is a test of the tsunami warning system."); +/// original = tuesday.to_str().or(Err("Couldn't unwrap CStr!"))?; +/// +/// assert!(original == message); +/// # +/// # Ok(tuesday) +/// # } +/// # fn main() { +/// # do_test(); // so that we can use the ? operator in the test +/// # } +/// ``` +/// It is also possible to pass several string literals to this macro. They +/// will be concatenated together in the order of the arguments, unmodified, +/// before finally being suffixed with a NUL byte: +/// +/// ``` +/// #[macro_use] +/// extern crate tor_util; +/// # +/// # use std::ffi::CStr; +/// # +/// # fn do_test() -> Result<&'static CStr, &'static str> { +/// +/// let quux: &'static CStr = cstr!("foo", "bar", "baz"); +/// let orig: &'static str = quux.to_str().or(Err("Couldn't unwrap CStr!"))?; +/// +/// assert!(orig == "foobarbaz"); +/// # Ok(quux) +/// # } +/// # fn main() { +/// # do_test(); // so that we can use the ? operator in the test +/// # } +/// ``` +/// This is useful for passing static strings to C from Rust FFI code. To do so +/// so, use the `.as_ptr()` method on the resulting `&'static CStr` to convert +/// it to the Rust equivalent of a C `const char*`: +/// +/// ``` +/// #[macro_use] +/// extern crate tor_util; +/// +/// use std::ffi::CStr; +/// use std::os::raw::c_char; +/// +/// pub extern "C" fn give_static_borrowed_string_to_c() -> *const c_char { +/// let hello: &'static CStr = cstr!("Hello, language my parents wrote."); +/// +/// hello.as_ptr() +/// } +/// # fn main() { +/// # let greetings = give_static_borrowed_string_to_c(); +/// # } +/// ``` +/// Note that the C code this static borrowed string is passed to *MUST NOT* +/// attempt to free the memory for the string. +/// +/// # Note +/// +/// An unfortunate limitation of the rustc compiler (as of 1.25.0-nightly), is +/// that the above code compiles, however if we were to change the assignment of +/// `tuesday` as follows, it will fail to compile, because Rust macros are +/// expanded at parse time, and at parse time there is no symbols table +/// available. +/// +/// ```ignore +/// tuesday = cstr!(message); +/// ``` +/// with the error message `error: expected a literal`. +/// +/// # Returns +/// +/// If the string literals passed as arguments contain no NUL bytes anywhere, +/// then an `&'static CStr` containing the (concatenated) bytes of the string +/// literal(s) passed as arguments, with a NUL byte appended, is returned. +/// Otherwise, an `&'static CStr` containing a single NUL byte is returned (an +/// "empty" string in C). +#[macro_export] +macro_rules! cstr { + ($($bytes:expr),*) => ( + ::std::ffi::CStr::from_bytes_with_nul( + concat!($($bytes),*, "\0").as_bytes() + ).unwrap_or( + unsafe{ + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"\0") + } + ) + ) +} + +#[cfg(test)] +mod test { + use std::ffi::CStr; + + #[test] + fn cstr_macro() { + let _: &'static CStr = cstr!("boo"); + } + + #[test] + fn cstr_macro_multi_input() { + let quux: &'static CStr = cstr!("foo", "bar", "baz"); + + assert!(quux.to_str().unwrap() == "foobarbaz"); + } + + #[test] + fn cstr_macro_bad_input() { + let waving: &'static CStr = cstr!("waving not drowning o/"); + let drowning: &'static CStr = cstr!("\0 drowning not waving"); + + assert!(waving.to_str().unwrap() == "waving not drowning o/"); + assert!(drowning.to_str().unwrap() == "") + } +}

1 0

[tor/master] rust: Remove now unused byte_slice_is_c_like() utility.
by nickm＠torproject.org 16 Feb '18

16 Feb '18

commit a4797a7e62f3f53326b3d33fa72b23f1dc0bc061 Author: Isis Lovecruft <isis(a)torproject.org> Date: Sat Feb 10 02:20:50 2018 +0000 rust: Remove now unused byte_slice_is_c_like() utility. --- src/rust/protover/ffi.rs | 1 - src/rust/tor_util/strings.rs | 39 --------------------------------------- 2 files changed, 40 deletions(-) diff --git a/src/rust/protover/ffi.rs b/src/rust/protover/ffi.rs index 1df0b6675..e4cf0a7e8 100644 --- a/src/rust/protover/ffi.rs +++ b/src/rust/protover/ffi.rs @@ -12,7 +12,6 @@ use std::ffi::CString; use protover::*; use smartlist::*; use tor_allocate::allocate_and_copy_string; -use tor_util::strings::byte_slice_is_c_like; /// Translate C enums to Rust Proto enums, using the integer value of the C /// enum to map to its associated Rust enum diff --git a/src/rust/tor_util/strings.rs b/src/rust/tor_util/strings.rs index dc4919d80..4e26e7369 100644 --- a/src/rust/tor_util/strings.rs +++ b/src/rust/tor_util/strings.rs @@ -3,45 +3,6 @@ //! Utilities for working with static strings. -/// A byte-array containing a single NUL byte (`b"\0"`). -pub const NUL_BYTE: &'static [u8] = b"\0"; - -/// Determine if a byte slice is a C-like string. -/// -/// These checks guarantee that: -/// -/// 1. there are no intermediate NUL bytes -/// 2. the last byte *is* a NUL byte -/// -/// # Warning -/// -/// This function does _not_ guarantee that the bytes represent any valid -/// encoding such as ASCII or UTF-8. -/// -/// # Examples -/// -/// ``` -/// # use tor_util::strings::byte_slice_is_c_like; -/// # -/// let bytes: &[u8] = b"foo bar baz"; -/// -/// assert!(byte_slice_is_c_like(&bytes) == false); -/// -/// let bytes: &[u8] = b"foo\0bar baz"; -/// -/// assert!(byte_slice_is_c_like(&bytes) == false); -/// -/// let bytes: &[u8] = b"foo bar baz\0"; -/// -/// assert!(byte_slice_is_c_like(&bytes) == true); -/// ``` -pub fn byte_slice_is_c_like(bytes: &[u8]) -> bool { - if !bytes[..bytes.len() - 1].contains(&0x00) && bytes[bytes.len() - 1] == 0x00 { - return true; - } - false -} - /// Create a `CStr` from a literal byte slice, appending a NUL byte to it first. /// /// # Warning

1 0

[tor/master] rust: Use tor_util::strings utils for protover_compute_for_old_tor.
by nickm＠torproject.org 16 Feb '18

16 Feb '18

commit 6c77593a57d5a22a2fb3105d1466fb3ed26b1244 Author: Isis Lovecruft <isis(a)torproject.org> Date: Sat Feb 10 01:52:26 2018 +0000 rust: Use tor_util::strings utils for protover_compute_for_old_tor. --- src/rust/protover/ffi.rs | 16 +--------------- src/rust/protover/protover.rs | 24 ++++++++++++------------ 2 files changed, 13 insertions(+), 27 deletions(-) diff --git a/src/rust/protover/ffi.rs b/src/rust/protover/ffi.rs index 404b15838..c86fe7522 100644 --- a/src/rust/protover/ffi.rs +++ b/src/rust/protover/ffi.rs @@ -190,7 +190,6 @@ pub extern "C" fn protover_is_supported_here( #[no_mangle] pub extern "C" fn protover_compute_for_old_tor(version: *const c_char) -> *const c_char { let supported: &'static CStr; - let elder_protocols: &'static [u8]; let empty: &'static CStr; empty = empty_static_cstr(); @@ -208,19 +207,6 @@ pub extern "C" fn protover_compute_for_old_tor(version: *const c_char) -> *const Err(_) => return empty.as_ptr(), }; - elder_protocols = compute_for_old_tor(&version); - - // If we're going to pass it to C, there cannot be any intermediate NUL - // bytes. An assert is okay here, since changing the const byte slice - // in protover.rs to contain a NUL byte somewhere in the middle would be a - // programming error. - assert!(byte_slice_is_c_like(elder_protocols)); - - // It's okay to unwrap the result of this function because - // we can see that the bytes we're passing into it 1) are valid UTF-8, - // 2) have no intermediate NUL bytes, and 3) are terminated with a NUL - // byte. - supported = CStr::from_bytes_with_nul(elder_protocols).unwrap_or(empty); - + supported = compute_for_old_tor(&version); supported.as_ptr() } diff --git a/src/rust/protover/protover.rs b/src/rust/protover/protover.rs index d354d8e25..e9fcdddd9 100644 --- a/src/rust/protover/protover.rs +++ b/src/rust/protover/protover.rs @@ -11,8 +11,6 @@ use std::collections::{HashMap, HashSet}; use std::ops::Range; use std::string::String; -use tor_util::strings::NUL_BYTE; - /// The first version of Tor that included "proto" entries in its descriptors. /// Authorities should use this to decide whether to guess proto lines. /// @@ -744,7 +742,7 @@ pub fn is_supported_here(proto: Proto, vers: Version) -> bool { /// /// # Returns /// -/// A `&'static [u8]` encoding a list of protocol names and supported +/// A `&'static CStr` encoding a list of protocol names and supported /// versions. The string takes the following format: /// /// "HSDir=1-1 LinkAuth=1" @@ -753,27 +751,29 @@ pub fn is_supported_here(proto: Proto, vers: Version) -> bool { /// only for tor versions older than FIRST_TOR_VERSION_TO_ADVERTISE_PROTOCOLS. /// /// C_RUST_COUPLED: src/rust/protover.c `compute_for_old_tor` -pub fn compute_for_old_tor(version: &str) -> &'static [u8] { +pub fn compute_for_old_tor(version: &str) -> &'static CStr { + let empty: &'static CStr = cstr!(""); + if c_tor_version_as_new_as(version, FIRST_TOR_VERSION_TO_ADVERTISE_PROTOCOLS) { - return NUL_BYTE; + return empty; } if c_tor_version_as_new_as(version, "0.2.9.1-alpha") { - return b"Cons=1-2 Desc=1-2 DirCache=1 HSDir=1 HSIntro=3 HSRend=1-2 \ - Link=1-4 LinkAuth=1 Microdesc=1-2 Relay=1-2\0"; + return cstr!("Cons=1-2 Desc=1-2 DirCache=1 HSDir=1 HSIntro=3 HSRend=1-2 \ + Link=1-4 LinkAuth=1 Microdesc=1-2 Relay=1-2"); } if c_tor_version_as_new_as(version, "0.2.7.5") { - return b"Cons=1-2 Desc=1-2 DirCache=1 HSDir=1 HSIntro=3 HSRend=1 \ - Link=1-4 LinkAuth=1 Microdesc=1-2 Relay=1-2\0"; + return cstr!("Cons=1-2 Desc=1-2 DirCache=1 HSDir=1 HSIntro=3 HSRend=1 \ + Link=1-4 LinkAuth=1 Microdesc=1-2 Relay=1-2"); } if c_tor_version_as_new_as(version, "0.2.4.19") { - return b"Cons=1 Desc=1 DirCache=1 HSDir=1 HSIntro=3 HSRend=1 \ - Link=1-4 LinkAuth=1 Microdesc=1 Relay=1-2\0"; + return cstr!("Cons=1 Desc=1 DirCache=1 HSDir=1 HSIntro=3 HSRend=1 \ + Link=1-4 LinkAuth=1 Microdesc=1 Relay=1-2"); } - NUL_BYTE + empty } #[cfg(test)]

1 0