fix: audit protocol handling

.github/workflows/sqlx.yml

@@ -61,23 +61,55 @@ jobs:
       - run: cargo build --all-features
 
   test:
-    name: Unit Test
+    name: Unit Tests
     runs-on: ubuntu-22.04
-    strategy:
-      matrix:
-        runtime: [async-std, tokio]
-        tls: [native-tls, rustls-aws-lc-rs, rustls-ring, none]
     steps:
       - uses: actions/checkout@v4
 
       - uses: Swatinem/rust-cache@v2
         with:
           key: ${{ runner.os }}-test
 
-      - run: >
+      - name: Install Rust
+        run: rustup update
+
+      - name: Test sqlx-core
+        run: >
+          cargo test
+          -p sqlx-core
+          --all-features      
+
+      - name: Test sqlx-mysql
+        run: >
+          cargo test
+          -p sqlx-mysql
+          --all-features      
+
+      - name: Test sqlx-postgres
+        run: >
+          cargo test
+          -p sqlx-postgres
+          --all-features      
+
+      - name: Test sqlx-sqlite
+        run: >
+          cargo test
+          -p sqlx-sqlite
+          --all-features      
+
+      - name: Test sqlx-macros-core
+        run: >
+          cargo test
+          -p sqlx-macros-core
+          --all-features
+
+      # Note: use `--lib` to not run integration tests that require a DB
+      - name: Test sqlx
+        run: >
           cargo test
-          --manifest-path sqlx-core/Cargo.toml
-          --features json,_rt-${{ matrix.runtime }},_tls-${{ matrix.tls }}
+          -p sqlx
+          --lib
+          --all-features
 
   sqlite:
     name: SQLite
@@ -172,7 +204,7 @@ jobs:
       - run: >
           cargo test
           --no-default-features
-          --features any,postgres,macros,_unstable-all-types,runtime-${{ matrix.runtime }},tls-${{ matrix.tls }}
+          --features any,postgres,macros,migrate,_unstable-all-types,runtime-${{ matrix.runtime }},tls-${{ matrix.tls }}
         env:
           DATABASE_URL: postgres://postgres:password@localhost:5432/sqlx
           SQLX_OFFLINE_DIR: .sqlx
@@ -184,7 +216,7 @@ jobs:
         run: >
           cargo test
           --no-default-features
-          --features any,postgres,macros,_unstable-all-types,runtime-${{ matrix.runtime }},tls-${{ matrix.tls }}
+          --features any,postgres,macros,migrate,_unstable-all-types,runtime-${{ matrix.runtime }},tls-${{ matrix.tls }}
         env:
           DATABASE_URL: postgres://postgres:password@localhost:5432/sqlx?sslmode=verify-ca&sslrootcert=.%2Ftests%2Fcerts%2Fca.crt
           SQLX_OFFLINE_DIR: .sqlx

Cargo.toml

@@ -187,6 +187,15 @@ criterion = { version = "0.5.1", features = ["async_tokio"] }
 # Enable testing with SQLCipher if specifically requested.
 libsqlite3-sys = { version = "0.30.1", features = ["bundled-sqlcipher"] }
 
+# Common lint settings for the workspace
+[workspace.lints.clippy]
+# https://github.com/launchbadge/sqlx/issues/3440
+cast_possible_truncation = 'deny'
+cast_possible_wrap = 'deny'
+cast_sign_loss = 'deny'
+# See `clippy.toml`
+disallowed_methods = 'deny'
+
 #
 # Any
 #
@@ -264,6 +273,11 @@ name = "sqlite-migrate"
 path = "tests/sqlite/migrate.rs"
 required-features = ["sqlite", "macros", "migrate"]
 
+[[test]]
+name = "sqlite-rustsec"
+path = "tests/sqlite/rustsec.rs"
+required-features = ["sqlite"]
+
 [[bench]]
 name = "sqlite-describe"
 path = "benches/sqlite/describe.rs"
@@ -314,6 +328,11 @@ name = "mysql-migrate"
 path = "tests/mysql/migrate.rs"
 required-features = ["mysql", "macros", "migrate"]
 
+[[test]]
+name = "mysql-rustsec"
+path = "tests/mysql/rustsec.rs"
+required-features = ["mysql"]
+
 #
 # PostgreSQL
 #
@@ -363,3 +382,8 @@ required-features = ["postgres", "macros", "migrate"]
 name = "postgres-query-builder"
 path = "tests/postgres/query_builder.rs"
 required-features = ["postgres"]
+
+[[test]]
+name = "postgres-rustsec"
+path = "tests/postgres/rustsec.rs"
+required-features = ["postgres", "macros", "migrate"]

sqlx-bench/Cargo.toml

@@ -42,3 +42,6 @@ required-features = ["postgres"]
 name = "sqlite_fetch_all"
 harness = false
 required-features = ["sqlite"]
+
+[lints]
+workspace = true

sqlx-cli/Cargo.toml

@@ -68,3 +68,6 @@ completions = ["dep:clap_complete"]
 [dev-dependencies]
 assert_cmd = "2.0.11"
 tempfile = "3.10.1"
+
+[lints]
+workspace = true

sqlx-core/Cargo.toml

@@ -94,3 +94,6 @@ hashbrown = "0.14.5"
 [dev-dependencies]
 sqlx = { workspace = true, features = ["postgres", "sqlite", "mysql", "migrate", "macros", "time", "uuid"] }
 tokio = { version = "1", features = ["rt"] }
+
+[lints]
+workspace = true

sqlx-core/src/error.rs

@@ -312,11 +312,16 @@ impl From<crate::migrate::MigrateError> for Error {
 /// Format an error message as a `Protocol` error
 #[macro_export]
 macro_rules! err_protocol {
-    ($expr:expr) => {
-        $crate::error::Error::Protocol($expr.into())
-    };
-
-    ($fmt:expr, $($arg:tt)*) => {
-        $crate::error::Error::Protocol(format!($fmt, $($arg)*))
+    ($($fmt_args:tt)*) => {
+        $crate::error::Error::Protocol(
+            format!(
+                "{} ({}:{})",
+                // Note: the format string needs to be unmodified (e.g. by `concat!()`)
+                // for implicit formatting arguments to work
+                format_args!($($fmt_args)*),
+                module_path!(),
+                line!(),
+            )
+        )
     };
 }

sqlx-core/src/io/decode.rs

@@ -2,27 +2,27 @@ use bytes::Bytes;
 
 use crate::error::Error;
 
-pub trait Decode<'de, Context = ()>
+pub trait ProtocolDecode<'de, Context = ()>
 where
     Self: Sized,
 {
     fn decode(buf: Bytes) -> Result<Self, Error>
     where
-        Self: Decode<'de, ()>,
+        Self: ProtocolDecode<'de, ()>,
     {
         Self::decode_with(buf, ())
     }
 
     fn decode_with(buf: Bytes, context: Context) -> Result<Self, Error>;
 }
 
-impl Decode<'_> for Bytes {
+impl ProtocolDecode<'_> for Bytes {
     fn decode_with(buf: Bytes, _: ()) -> Result<Self, Error> {
         Ok(buf)
     }
 }
 
-impl Decode<'_> for () {
+impl ProtocolDecode<'_> for () {
     fn decode_with(_: Bytes, _: ()) -> Result<(), Error> {
         Ok(())
     }

sqlx-core/src/io/encode.rs

@@ -1,16 +1,17 @@
-pub trait Encode<'en, Context = ()> {
-    fn encode(&self, buf: &mut Vec<u8>)
+pub trait ProtocolEncode<'en, Context = ()> {
+    fn encode(&self, buf: &mut Vec<u8>) -> Result<(), crate::Error>
     where
-        Self: Encode<'en, ()>,
+        Self: ProtocolEncode<'en, ()>,
     {
-        self.encode_with(buf, ());
+        self.encode_with(buf, ())
     }
 
-    fn encode_with(&self, buf: &mut Vec<u8>, context: Context);
+    fn encode_with(&self, buf: &mut Vec<u8>, context: Context) -> Result<(), crate::Error>;
 }
 
-impl<'en, C> Encode<'en, C> for &'_ [u8] {
-    fn encode_with(&self, buf: &mut Vec<u8>, _: C) {
+impl<'en, C> ProtocolEncode<'en, C> for &'_ [u8] {
+    fn encode_with(&self, buf: &mut Vec<u8>, _context: C) -> Result<(), crate::Error> {
         buf.extend_from_slice(self);
+        Ok(())
     }
 }

sqlx-core/src/io/mod.rs

@@ -9,8 +9,8 @@ mod read_buf;
 pub use buf::BufExt;
 pub use buf_mut::BufMutExt;
 //pub use buf_stream::BufStream;
-pub use decode::Decode;
-pub use encode::Encode;
+pub use decode::ProtocolDecode;
+pub use encode::ProtocolEncode;
 pub use read_buf::ReadBuf;
 
 #[cfg(not(feature = "_rt-tokio"))]

sqlx-core/src/lib.rs

@@ -15,8 +15,6 @@
 #![recursion_limit = "512"]
 #![warn(future_incompatible, rust_2018_idioms)]
 #![allow(clippy::needless_doctest_main, clippy::type_complexity)]
-// See `clippy.toml` at the workspace root
-#![deny(clippy::disallowed_methods)]
 // The only unsafe code in SQLx is that necessary to interact with native APIs like with SQLite,
 // and that can live in its own separate driver crate.
 #![forbid(unsafe_code)]

sqlx-core/src/net/socket/buffered.rs

@@ -4,7 +4,7 @@ use std::{cmp, io};
 
 use crate::error::Error;
 
-use crate::io::{AsyncRead, AsyncReadExt, Decode, Encode};
+use crate::io::{AsyncRead, AsyncReadExt, ProtocolDecode, ProtocolEncode};
 
 // Tokio, async-std, and std all use this as the default capacity for their buffered I/O.
 const DEFAULT_BUF_SIZE: usize = 8192;
@@ -59,32 +59,36 @@ impl<S: Socket> BufferedSocket<S> {
 
     pub async fn read<'de, T>(&mut self, byte_len: usize) -> Result<T, Error>
     where
-        T: Decode<'de, ()>,
+        T: ProtocolDecode<'de, ()>,
     {
         self.read_with(byte_len, ()).await
     }
 
     pub async fn read_with<'de, T, C>(&mut self, byte_len: usize, context: C) -> Result<T, Error>
     where
-        T: Decode<'de, C>,
+        T: ProtocolDecode<'de, C>,
     {
         T::decode_with(self.read_buffered(byte_len).await?.freeze(), context)
     }
 
-    pub fn write<'en, T>(&mut self, value: T)
+    #[inline(always)]
+    pub fn write<'en, T>(&mut self, value: T) -> Result<(), Error>
     where
-        T: Encode<'en, ()>,
+        T: ProtocolEncode<'en, ()>,
     {
         self.write_with(value, ())
     }
 
-    pub fn write_with<'en, T, C>(&mut self, value: T, context: C)
+    #[inline(always)]
+    pub fn write_with<'en, T, C>(&mut self, value: T, context: C) -> Result<(), Error>
     where
-        T: Encode<'en, C>,
+        T: ProtocolEncode<'en, C>,
     {
-        value.encode_with(self.write_buf.buf_mut(), context);
+        value.encode_with(self.write_buf.buf_mut(), context)?;
         self.write_buf.bytes_written = self.write_buf.buf.len();
         self.write_buf.sanity_check();
+
+        Ok(())
     }
 
     pub async fn flush(&mut self) -> io::Result<()> {

sqlx-macros/Cargo.toml

@@ -49,3 +49,6 @@ sqlx-macros-core = { workspace = true }
 proc-macro2 = { version = "1.0.36", default-features = false }
 syn = { version = "2.0.52", default-features = false, features = ["parsing", "proc-macro"] }
 quote = { version = "1.0.26", default-features = false }
+
+[lints]
+workspace = true

sqlx-mysql/Cargo.toml

@@ -15,6 +15,13 @@ any = ["sqlx-core/any"]
 offline = ["sqlx-core/offline", "serde/derive"]
 migrate = ["sqlx-core/migrate"]
 
+# Type Integration features
+bigdecimal = ["dep:bigdecimal", "sqlx-core/bigdecimal"]
+chrono = ["dep:chrono", "sqlx-core/chrono"]
+rust_decimal = ["dep:rust_decimal", "rust_decimal/maths", "sqlx-core/rust_decimal"]
+time = ["dep:time", "sqlx-core/time"]
+uuid = ["dep:uuid", "sqlx-core/uuid"]
+
 [dependencies]
 sqlx-core = { workspace = true }
 
@@ -64,3 +71,9 @@ tracing = { version = "0.1.37", features = ["log"] }
 whoami = { version = "1.2.1", default-features = false }
 
 serde = { version = "1.0.144", optional = true }
+
+[dev-dependencies]
+sqlx = { workspace = true, features = ["mysql"] }
+
+[lints]
+workspace = true

sqlx-mysql/src/any.rs

@@ -213,6 +213,8 @@ impl<'a> TryFrom<&'a AnyConnectOptions> for MySqlConnectOptions {
 fn map_result(result: MySqlQueryResult) -> AnyQueryResult {
     AnyQueryResult {
         rows_affected: result.rows_affected,
+        // Don't expect this to be a problem
+        #[allow(clippy::cast_possible_wrap)]
         last_insert_id: Some(result.last_insert_id as i64),
     }
 }

sqlx-mysql/src/connection/auth.rs

@@ -53,7 +53,7 @@ impl AuthPlugin {
                     0x04 => {
                         let payload = encrypt_rsa(stream, 0x02, password, nonce).await?;
 
-                        stream.write_packet(&*payload);
+                        stream.write_packet(&*payload)?;
                         stream.flush().await?;
 
                         Ok(false)
@@ -143,7 +143,7 @@ async fn encrypt_rsa<'s>(
     }
 
     // client sends a public key request
-    stream.write_packet(&[public_key_request_id][..]);
+    stream.write_packet(&[public_key_request_id][..])?;
     stream.flush().await?;
 
     // server sends a public key response

sqlx-mysql/src/connection/establish.rs

@@ -131,7 +131,7 @@ impl<'a> DoHandshake<'a> {
             database: options.database.as_deref(),
             auth_plugin: plugin,
             auth_response: auth_response.as_deref(),
-        });
+        })?;
 
         stream.flush().await?;
 
@@ -160,7 +160,7 @@ impl<'a> DoHandshake<'a> {
                         )
                         .await?;
 
-                    stream.write_packet(AuthSwitchResponse(response));
+                    stream.write_packet(AuthSwitchResponse(response))?;
                     stream.flush().await?;
                 }
 

sqlx-mysql/src/connection/executor.rs

@@ -187,7 +187,9 @@ impl MySqlConnection {
                 // otherwise, this first packet is the start of the result-set metadata,
                 *self.inner.stream.waiting.front_mut().unwrap() = Waiting::Row;
 
-                let num_columns = packet.get_uint_lenenc() as usize; // column count
+                let num_columns = packet.get_uint_lenenc(); // column count
+                let num_columns = usize::try_from(num_columns)
+                    .map_err(|_| err_protocol!("column count overflows usize: {num_columns}"))?;
 
                 if needs_metadata {
                     column_names = Arc::new(recv_result_metadata(&mut self.inner.stream, num_columns, Arc::make_mut(&mut columns)).await?);