secp-sys: update raw pointer deref syntax in fuzz version of the crate

apoelstra · apoelstra · commit 0d0263e3fdf2 · 2025-08-23T19:24:06.000Z
Rust 1.88.0 introduced a warning, and 1.89.0 made it an error, to dereference
a raw pointer in a way where it is implicitly turned into a reference. This
is probably a good lint but breaking compilation like this is bullshit.

There are many instances of this in our fuzz code (none in the real code).
We just need to change the implicit &amp; and &amp;muts to explicit ones.

We will need to backport some change if we want our CI to keep working on
old versions. Probably just whitelisting the lint for old versions of the
library is fine.
diff --git a/secp256k1-sys/src/lib.rs b/secp256k1-sys/src/lib.rs
@@ -1617,21 +1617,21 @@ mod fuzz_dummy {
     /// Checks that pk != 0xffff...ffff and pk[1..32] == pk[33..64]
     unsafe fn test_pk_validate(cx: *const Context, pk: *const PublicKey) -> c_int {
         check_context_flags(cx, 0);
-        if (*pk).0[1..32] != (*pk).0[33..64]
-            || ((*pk).0[32] != 0 && (*pk).0[32] != 0xff)
-            || secp256k1_ec_seckey_verify(cx, (*pk).0[0..32].as_ptr()) == 0
+        if (&*pk).0[1..32] != (&*pk).0[33..64]
+            || ((*pk).0[32] != 0 && (&*pk).0[32] != 0xff)
+            || secp256k1_ec_seckey_verify(cx, (&*pk).0[0..32].as_ptr()) == 0
         {
             0
         } else {
             1
         }
     }
     unsafe fn test_cleanup_pk(pk: *mut PublicKey) {
-        (*pk).0[32..].copy_from_slice(&(*pk).0[..32]);
-        if (*pk).0[32] <= 0x7f {
-            (*pk).0[32] = 0;
+        (&mut *pk).0[32..].copy_from_slice(&(&*pk).0[..32]);
+        if (&*pk).0[32] <= 0x7f {
+            (&mut *pk).0[32] = 0;
         } else {
-            (*pk).0[32] = 0xff;
+            (&mut *pk).0[32] = 0xff;
         }
     }
 
@@ -1648,8 +1648,8 @@ mod fuzz_dummy {
                 if *input != 2 && *input != 3 {
                     0
                 } else {
-                    ptr::copy(input.offset(1), (*pk).0[0..32].as_mut_ptr(), 32);
-                    ptr::copy(input.offset(2), (*pk).0[33..64].as_mut_ptr(), 31);
+                    ptr::copy(input.offset(1), (&mut *pk).0[0..32].as_mut_ptr(), 32);
+                    ptr::copy(input.offset(2), (&mut *pk).0[33..64].as_mut_ptr(), 31);
                     if *input == 3 {
                         (*pk).0[32] = 0xff;
                     } else {
@@ -1661,7 +1661,7 @@ mod fuzz_dummy {
                 if *input != 4 && *input != 6 && *input != 7 {
                     0
                 } else {
-                    ptr::copy(input.offset(1), (*pk).0.as_mut_ptr(), 64);
+                    ptr::copy(input.offset(1), (&mut *pk).0.as_mut_ptr(), 64);
                     test_cleanup_pk(pk);
                     test_pk_validate(cx, pk)
                 },
@@ -1708,7 +1708,7 @@ mod fuzz_dummy {
         if secp256k1_ec_seckey_verify(cx, sk) != 1 {
             return 0;
         }
-        ptr::copy(sk, (*pk).0[0..32].as_mut_ptr(), 32);
+        ptr::copy(sk, (&mut *pk).0[0..32].as_mut_ptr(), 32);
         test_cleanup_pk(pk);
         assert_eq!(test_pk_validate(cx, pk), 1);
         1
@@ -1717,7 +1717,7 @@ mod fuzz_dummy {
     pub unsafe fn secp256k1_ec_pubkey_negate(cx: *const Context, pk: *mut PublicKey) -> c_int {
         check_context_flags(cx, 0);
         assert_eq!(test_pk_validate(cx, pk), 1);
-        if secp256k1_ec_seckey_negate(cx, (*pk).0[..32].as_mut_ptr()) != 1 {
+        if secp256k1_ec_seckey_negate(cx, (&mut *pk).0[..32].as_mut_ptr()) != 1 {
             return 0;
         }
         test_cleanup_pk(pk);
@@ -1733,7 +1733,7 @@ mod fuzz_dummy {
     ) -> c_int {
         check_context_flags(cx, SECP256K1_START_VERIFY);
         assert_eq!(test_pk_validate(cx, pk), 1);
-        if secp256k1_ec_seckey_tweak_add(cx, (*pk).0[..32].as_mut_ptr(), tweak) != 1 {
+        if secp256k1_ec_seckey_tweak_add(cx, (&mut *pk).0[..32].as_mut_ptr(), tweak) != 1 {
             return 0;
         }
         test_cleanup_pk(pk);
@@ -1749,7 +1749,7 @@ mod fuzz_dummy {
     ) -> c_int {
         check_context_flags(cx, 0);
         assert_eq!(test_pk_validate(cx, pk), 1);
-        if secp256k1_ec_seckey_tweak_mul(cx, (*pk).0[..32].as_mut_ptr(), tweak) != 1 {
+        if secp256k1_ec_seckey_tweak_mul(cx, (&mut *pk).0[..32].as_mut_ptr(), tweak) != 1 {
             return 0;
         }
         test_cleanup_pk(pk);
@@ -1770,8 +1770,8 @@ mod fuzz_dummy {
             assert_eq!(test_pk_validate(cx, *ins.offset(i as isize)), 1);
             if secp256k1_ec_seckey_tweak_add(
                 cx,
-                (*out).0[..32].as_mut_ptr(),
-                (**ins.offset(i as isize)).0[..32].as_ptr(),
+                (&mut *out).0[..32].as_mut_ptr(),
+                (&**ins.offset(i as isize)).0[..32].as_ptr(),
             ) != 1
             {
                 return 0;
@@ -1798,7 +1798,7 @@ mod fuzz_dummy {
         }
 
         let scalar_slice = slice::from_raw_parts(scalar, 32);
-        let pk_slice = &(*point).0[..32];
+        let pk_slice = &(&*point).0[..32];
 
         let mut res_arr = [0u8; 32];
         for i in 0..32 {
@@ -1827,7 +1827,7 @@ mod fuzz_dummy {
         // Actually verify
         let sig_sl = slice::from_raw_parts(sig as *const u8, 64);
         let msg_sl = slice::from_raw_parts(msg32 as *const u8, 32);
-        if &sig_sl[..32] == msg_sl && sig_sl[32..] == (*pk).0[0..32] {
+        if &sig_sl[..32] == msg_sl && sig_sl[32..] == (&*pk).0[0..32] {
             1
         } else {
             0
@@ -1873,7 +1873,7 @@ mod fuzz_dummy {
         // Actually verify
         let sig_sl = slice::from_raw_parts(sig64 as *const u8, 64);
         let msg_sl = slice::from_raw_parts(msg32 as *const u8, msglen);
-        if &sig_sl[..32] == msg_sl && sig_sl[32..] == (*pubkey).0[..32] {
+        if &sig_sl[..32] == msg_sl && sig_sl[32..] == (&*pubkey).0[..32] {
             1
         } else {
             0
@@ -1932,8 +1932,8 @@ mod fuzz_dummy {
         }
 
         let seckey_slice = slice::from_raw_parts(seckey, 32);
-        (*keypair).0[..32].copy_from_slice(seckey_slice);
-        (*keypair).0[32..].copy_from_slice(&pk.0);
+        (&mut *keypair).0[..32].copy_from_slice(seckey_slice);
+        (&mut *keypair).0[32..].copy_from_slice(&pk.0);
         1
     }
 
@@ -1944,8 +1944,8 @@ mod fuzz_dummy {
     ) -> c_int {
         check_context_flags(cx, 0);
         let inslice = slice::from_raw_parts(input32, 32);
-        (*pubkey).0[..32].copy_from_slice(inslice);
-        (*pubkey).0[32..].copy_from_slice(inslice);
+        (&mut *pubkey).0[..32].copy_from_slice(inslice);
+        (&mut *pubkey).0[32..].copy_from_slice(inslice);
         test_cleanup_pk(pubkey as *mut PublicKey);
         test_pk_validate(cx, pubkey as *mut PublicKey)
     }
@@ -1957,7 +1957,7 @@ mod fuzz_dummy {
     ) -> c_int {
         check_context_flags(cx, 0);
         let outslice = slice::from_raw_parts_mut(output32, 32);
-        outslice.copy_from_slice(&(*pubkey).0[..32]);
+        outslice.copy_from_slice(&(&*pubkey).0[..32]);
         1
     }
 
@@ -1971,7 +1971,7 @@ mod fuzz_dummy {
         if !pk_parity.is_null() {
             *pk_parity = ((*pubkey).0[32] == 0).into();
         }
-        (*xonly_pubkey).0.copy_from_slice(&(*pubkey).0);
+        (*xonly_pubkey).0.copy_from_slice(&(&*pubkey).0);
         assert_eq!(test_pk_validate(cx, pubkey), 1);
         1
     }
@@ -1995,9 +1995,9 @@ mod fuzz_dummy {
     ) -> c_int {
         check_context_flags(cx, 0);
         if !pk_parity.is_null() {
-            *pk_parity = ((*keypair).0[64] == 0).into();
+            *pk_parity = ((&*keypair).0[64] == 0).into();
         }
-        (*pubkey).0.copy_from_slice(&(*keypair).0[32..]);
+        (&mut *pubkey).0.copy_from_slice(&(&*keypair).0[32..]);
         1
     }
 
@@ -2008,13 +2008,13 @@ mod fuzz_dummy {
     ) -> c_int {
         check_context_flags(cx, SECP256K1_START_VERIFY);
         let mut pk = PublicKey::new();
-        pk.0.copy_from_slice(&(*keypair).0[32..]);
+        pk.0.copy_from_slice(&(&*keypair).0[32..]);
         let mut sk = [0u8; 32];
-        sk.copy_from_slice(&(*keypair).0[..32]);
+        sk.copy_from_slice(&(&*keypair).0[..32]);
         assert_eq!(secp256k1_ec_pubkey_tweak_add(cx, &mut pk, tweak32), 1);
         assert_eq!(secp256k1_ec_seckey_tweak_add(cx, (&mut sk[..]).as_mut_ptr(), tweak32), 1);
-        (*keypair).0[..32].copy_from_slice(&sk);
-        (*keypair).0[32..].copy_from_slice(&pk.0);
+        (&mut *keypair).0[..32].copy_from_slice(&sk);
+        (&mut *keypair).0[32..].copy_from_slice(&pk.0);
         1
     }
 

Original file line number	Diff line number	Diff line change
`@@ -1617,21 +1617,21 @@ mod fuzz_dummy {`
`1617`	`1617`	`/// Checks that pk != 0xffff...ffff and pk[1..32] == pk[33..64]`
`1618`	`1618`	`unsafe fn test_pk_validate(cx: const Context, pk: const PublicKey) -> c_int {`
`1619`	`1619`	`check_context_flags(cx, 0);`
`1620`		`- if (pk).0[1..32] != (pk).0[33..64]`
`1621`		`- \|\| ((pk).0[32] != 0 && (pk).0[32] != 0xff)`
`1622`		`- \|\| secp256k1_ec_seckey_verify(cx, (*pk).0[0..32].as_ptr()) == 0`
	`1620`	`+ if (&pk).0[1..32] != (&pk).0[33..64]`
	`1621`	`+ \|\| ((pk).0[32] != 0 && (&pk).0[32] != 0xff)`
	`1622`	`+ \|\| secp256k1_ec_seckey_verify(cx, (&*pk).0[0..32].as_ptr()) == 0`
`1623`	`1623`	`{`
`1624`	`1624`	`0`
`1625`	`1625`	`} else {`
`1626`	`1626`	`1`
`1627`	`1627`	`}`
`1628`	`1628`	`}`
`1629`	`1629`	`unsafe fn test_cleanup_pk(pk: *mut PublicKey) {`
`1630`		`- (pk).0[32..].copy_from_slice(&(pk).0[..32]);`
`1631`		`- if (*pk).0[32] <= 0x7f {`
`1632`		`- (*pk).0[32] = 0;`
	`1630`	`+ (&mut pk).0[32..].copy_from_slice(&(&pk).0[..32]);`
	`1631`	`+ if (&*pk).0[32] <= 0x7f {`
	`1632`	`+ (&mut *pk).0[32] = 0;`
`1633`	`1633`	`} else {`
`1634`		`- (*pk).0[32] = 0xff;`
	`1634`	`+ (&mut *pk).0[32] = 0xff;`
`1635`	`1635`	`}`
`1636`	`1636`	`}`
`1637`	`1637`
`@@ -1648,8 +1648,8 @@ mod fuzz_dummy {`
`1648`	`1648`	`if input != 2 && input != 3 {`
`1649`	`1649`	`0`
`1650`	`1650`	`} else {`
`1651`		`- ptr::copy(input.offset(1), (*pk).0[0..32].as_mut_ptr(), 32);`
`1652`		`- ptr::copy(input.offset(2), (*pk).0[33..64].as_mut_ptr(), 31);`
	`1651`	`+ ptr::copy(input.offset(1), (&mut *pk).0[0..32].as_mut_ptr(), 32);`
	`1652`	`+ ptr::copy(input.offset(2), (&mut *pk).0[33..64].as_mut_ptr(), 31);`
`1653`	`1653`	`if *input == 3 {`
`1654`	`1654`	`(*pk).0[32] = 0xff;`
`1655`	`1655`	`} else {`
`@@ -1661,7 +1661,7 @@ mod fuzz_dummy {`
`1661`	`1661`	`if input != 4 && input != 6 && *input != 7 {`
`1662`	`1662`	`0`
`1663`	`1663`	`} else {`
`1664`		`- ptr::copy(input.offset(1), (*pk).0.as_mut_ptr(), 64);`
	`1664`	`+ ptr::copy(input.offset(1), (&mut *pk).0.as_mut_ptr(), 64);`
`1665`	`1665`	`test_cleanup_pk(pk);`
`1666`	`1666`	`test_pk_validate(cx, pk)`
`1667`	`1667`	`},`
`@@ -1708,7 +1708,7 @@ mod fuzz_dummy {`
`1708`	`1708`	`if secp256k1_ec_seckey_verify(cx, sk) != 1 {`
`1709`	`1709`	`return 0;`
`1710`	`1710`	`}`
`1711`		`- ptr::copy(sk, (*pk).0[0..32].as_mut_ptr(), 32);`
	`1711`	`+ ptr::copy(sk, (&mut *pk).0[0..32].as_mut_ptr(), 32);`
`1712`	`1712`	`test_cleanup_pk(pk);`
`1713`	`1713`	`assert_eq!(test_pk_validate(cx, pk), 1);`
`1714`	`1714`	`1`
`@@ -1717,7 +1717,7 @@ mod fuzz_dummy {`
`1717`	`1717`	`pub unsafe fn secp256k1_ec_pubkey_negate(cx: const Context, pk: mut PublicKey) -> c_int {`
`1718`	`1718`	`check_context_flags(cx, 0);`
`1719`	`1719`	`assert_eq!(test_pk_validate(cx, pk), 1);`
`1720`		`- if secp256k1_ec_seckey_negate(cx, (*pk).0[..32].as_mut_ptr()) != 1 {`
	`1720`	`+ if secp256k1_ec_seckey_negate(cx, (&mut *pk).0[..32].as_mut_ptr()) != 1 {`
`1721`	`1721`	`return 0;`
`1722`	`1722`	`}`
`1723`	`1723`	`test_cleanup_pk(pk);`
`@@ -1733,7 +1733,7 @@ mod fuzz_dummy {`
`1733`	`1733`	`) -> c_int {`
`1734`	`1734`	`check_context_flags(cx, SECP256K1_START_VERIFY);`
`1735`	`1735`	`assert_eq!(test_pk_validate(cx, pk), 1);`
`1736`		`- if secp256k1_ec_seckey_tweak_add(cx, (*pk).0[..32].as_mut_ptr(), tweak) != 1 {`
	`1736`	`+ if secp256k1_ec_seckey_tweak_add(cx, (&mut *pk).0[..32].as_mut_ptr(), tweak) != 1 {`
`1737`	`1737`	`return 0;`
`1738`	`1738`	`}`
`1739`	`1739`	`test_cleanup_pk(pk);`
`@@ -1749,7 +1749,7 @@ mod fuzz_dummy {`
`1749`	`1749`	`) -> c_int {`
`1750`	`1750`	`check_context_flags(cx, 0);`
`1751`	`1751`	`assert_eq!(test_pk_validate(cx, pk), 1);`
`1752`		`- if secp256k1_ec_seckey_tweak_mul(cx, (*pk).0[..32].as_mut_ptr(), tweak) != 1 {`
	`1752`	`+ if secp256k1_ec_seckey_tweak_mul(cx, (&mut *pk).0[..32].as_mut_ptr(), tweak) != 1 {`
`1753`	`1753`	`return 0;`
`1754`	`1754`	`}`
`1755`	`1755`	`test_cleanup_pk(pk);`
`@@ -1770,8 +1770,8 @@ mod fuzz_dummy {`
`1770`	`1770`	`assert_eq!(test_pk_validate(cx, *ins.offset(i as isize)), 1);`
`1771`	`1771`	`if secp256k1_ec_seckey_tweak_add(`
`1772`	`1772`	`cx,`
`1773`		`- (*out).0[..32].as_mut_ptr(),`
`1774`		`- (**ins.offset(i as isize)).0[..32].as_ptr(),`
	`1773`	`+ (&mut *out).0[..32].as_mut_ptr(),`
	`1774`	`+ (&**ins.offset(i as isize)).0[..32].as_ptr(),`
`1775`	`1775`	`) != 1`
`1776`	`1776`	`{`
`1777`	`1777`	`return 0;`
`@@ -1798,7 +1798,7 @@ mod fuzz_dummy {`
`1798`	`1798`	`}`
`1799`	`1799`
`1800`	`1800`	`let scalar_slice = slice::from_raw_parts(scalar, 32);`
`1801`		`- let pk_slice = &(*point).0[..32];`
	`1801`	`+ let pk_slice = &(&*point).0[..32];`
`1802`	`1802`
`1803`	`1803`	`let mut res_arr = [0u8; 32];`
`1804`	`1804`	`for i in 0..32 {`
`@@ -1827,7 +1827,7 @@ mod fuzz_dummy {`
`1827`	`1827`	`// Actually verify`
`1828`	`1828`	`let sig_sl = slice::from_raw_parts(sig as *const u8, 64);`
`1829`	`1829`	`let msg_sl = slice::from_raw_parts(msg32 as *const u8, 32);`
`1830`		`- if &sig_sl[..32] == msg_sl && sig_sl[32..] == (*pk).0[0..32] {`
	`1830`	`+ if &sig_sl[..32] == msg_sl && sig_sl[32..] == (&*pk).0[0..32] {`
`1831`	`1831`	`1`
`1832`	`1832`	`} else {`
`1833`	`1833`	`0`
`@@ -1873,7 +1873,7 @@ mod fuzz_dummy {`
`1873`	`1873`	`// Actually verify`
`1874`	`1874`	`let sig_sl = slice::from_raw_parts(sig64 as *const u8, 64);`
`1875`	`1875`	`let msg_sl = slice::from_raw_parts(msg32 as *const u8, msglen);`
`1876`		`- if &sig_sl[..32] == msg_sl && sig_sl[32..] == (*pubkey).0[..32] {`
	`1876`	`+ if &sig_sl[..32] == msg_sl && sig_sl[32..] == (&*pubkey).0[..32] {`
`1877`	`1877`	`1`
`1878`	`1878`	`} else {`
`1879`	`1879`	`0`
`@@ -1932,8 +1932,8 @@ mod fuzz_dummy {`
`1932`	`1932`	`}`
`1933`	`1933`
`1934`	`1934`	`let seckey_slice = slice::from_raw_parts(seckey, 32);`
`1935`		`- (*keypair).0[..32].copy_from_slice(seckey_slice);`
`1936`		`- (*keypair).0[32..].copy_from_slice(&pk.0);`
	`1935`	`+ (&mut *keypair).0[..32].copy_from_slice(seckey_slice);`
	`1936`	`+ (&mut *keypair).0[32..].copy_from_slice(&pk.0);`
`1937`	`1937`	`1`
`1938`	`1938`	`}`
`1939`	`1939`
`@@ -1944,8 +1944,8 @@ mod fuzz_dummy {`
`1944`	`1944`	`) -> c_int {`
`1945`	`1945`	`check_context_flags(cx, 0);`
`1946`	`1946`	`let inslice = slice::from_raw_parts(input32, 32);`
`1947`		`- (*pubkey).0[..32].copy_from_slice(inslice);`
`1948`		`- (*pubkey).0[32..].copy_from_slice(inslice);`
	`1947`	`+ (&mut *pubkey).0[..32].copy_from_slice(inslice);`
	`1948`	`+ (&mut *pubkey).0[32..].copy_from_slice(inslice);`
`1949`	`1949`	`test_cleanup_pk(pubkey as *mut PublicKey);`
`1950`	`1950`	`test_pk_validate(cx, pubkey as *mut PublicKey)`
`1951`	`1951`	`}`
`@@ -1957,7 +1957,7 @@ mod fuzz_dummy {`
`1957`	`1957`	`) -> c_int {`
`1958`	`1958`	`check_context_flags(cx, 0);`
`1959`	`1959`	`let outslice = slice::from_raw_parts_mut(output32, 32);`
`1960`		`- outslice.copy_from_slice(&(*pubkey).0[..32]);`
	`1960`	`+ outslice.copy_from_slice(&(&*pubkey).0[..32]);`
`1961`	`1961`	`1`
`1962`	`1962`	`}`
`1963`	`1963`
`@@ -1971,7 +1971,7 @@ mod fuzz_dummy {`
`1971`	`1971`	`if !pk_parity.is_null() {`
`1972`	`1972`	`pk_parity = ((pubkey).0[32] == 0).into();`
`1973`	`1973`	`}`
`1974`		`- (xonly_pubkey).0.copy_from_slice(&(pubkey).0);`
	`1974`	`+ (xonly_pubkey).0.copy_from_slice(&(&pubkey).0);`
`1975`	`1975`	`assert_eq!(test_pk_validate(cx, pubkey), 1);`
`1976`	`1976`	`1`
`1977`	`1977`	`}`
`@@ -1995,9 +1995,9 @@ mod fuzz_dummy {`
`1995`	`1995`	`) -> c_int {`
`1996`	`1996`	`check_context_flags(cx, 0);`
`1997`	`1997`	`if !pk_parity.is_null() {`
`1998`		`- pk_parity = ((keypair).0[64] == 0).into();`
	`1998`	`+ pk_parity = ((&keypair).0[64] == 0).into();`
`1999`	`1999`	`}`
`2000`		`- (pubkey).0.copy_from_slice(&(keypair).0[32..]);`
	`2000`	`+ (&mut pubkey).0.copy_from_slice(&(&keypair).0[32..]);`
`2001`	`2001`	`1`
`2002`	`2002`	`}`
`2003`	`2003`
`@@ -2008,13 +2008,13 @@ mod fuzz_dummy {`
`2008`	`2008`	`) -> c_int {`
`2009`	`2009`	`check_context_flags(cx, SECP256K1_START_VERIFY);`
`2010`	`2010`	`let mut pk = PublicKey::new();`
`2011`		`- pk.0.copy_from_slice(&(*keypair).0[32..]);`
	`2011`	`+ pk.0.copy_from_slice(&(&*keypair).0[32..]);`
`2012`	`2012`	`let mut sk = [0u8; 32];`
`2013`		`- sk.copy_from_slice(&(*keypair).0[..32]);`
	`2013`	`+ sk.copy_from_slice(&(&*keypair).0[..32]);`
`2014`	`2014`	`assert_eq!(secp256k1_ec_pubkey_tweak_add(cx, &mut pk, tweak32), 1);`
`2015`	`2015`	`assert_eq!(secp256k1_ec_seckey_tweak_add(cx, (&mut sk[..]).as_mut_ptr(), tweak32), 1);`
`2016`		`- (*keypair).0[..32].copy_from_slice(&sk);`
`2017`		`- (*keypair).0[32..].copy_from_slice(&pk.0);`
	`2016`	`+ (&mut *keypair).0[..32].copy_from_slice(&sk);`
	`2017`	`+ (&mut *keypair).0[32..].copy_from_slice(&pk.0);`
`2018`	`2018`	`1`
`2019`	`2019`	`}`
`2020`	`2020`