feat(wallet)!: apply FRC-0102 envelope to sign/verify by default

`forest-wallet sign` and `forest-wallet verify` now wrap the decoded
message with the FRC-0102 Filecoin signing envelope
(`\x19Filecoin Signed Message:\n<len>`) before handing it to the signer
/ verifier. This aligns Forest with the Ledger Filecoin app, Filsnap,
iso-filecoin and Lotus (filecoin-project/lotus#13388), so signatures
produced by any of these wallets over the same bytes now round-trip.
A new `--raw` flag restores the prior raw-bytes behaviour on both
commands. `--raw` is also the correct choice when signing on-chain
Filecoin messages, which must not be wrapped.
The envelope is applied client-side only; the Forest and Lotus
`WalletSign` / `WalletVerify` RPCs treat their input as opaque bytes,
so a single wrap here is correct against today's daemons.
BREAKING CHANGE: signatures produced by the default invocation are not
verifiable by pre-FRC-0102 Forest or Lotus releases without `--raw` on
the verifier side.
Refs #6442

Author: 0xDevNinja

.config/forest.dic

@@ -1,4 +1,4 @@
-271
+273
 Algorand/M
 API's
 API/SM
@@ -99,6 +99,7 @@ Filecoin/M
 Filfox
 Filops
 FilOz
+Filsnap
 FIP/S
 FVM
 GC
@@ -121,6 +122,7 @@ implementer/S
 implementor/SM
 infeasible
 interop/S
+interoperating
 ip
 IPFS
 IPLD

CHANGELOG.md

@@ -27,6 +27,8 @@
 
 ### Breaking
 
+-[#6442](https://github.com/ChainSafe/forest/issues/6442): `forest-wallet sign` and `forest-wallet verify` now apply the FRC-0102 signing envelope to the message by default. Pass `--raw` on both sides to reproduce the previous raw-bytes behaviour.
+
 ### Added
 
 ### Changed

src/wallet/subcommands/wallet_cmd.rs

@@ -37,7 +37,6 @@ use crate::{
  rpc::{self, prelude::*},
 };
 use anyhow::{Contextas _, bail};
-use base64::{Engine, prelude::BASE64_STANDARD};
 use clap::Subcommand;
 use dialoguer::{Password, console::Term, theme::ColorfulTheme};
 use directories::ProjectDirs;
@@ -171,17 +170,17 @@ impl WalletBackend {
 }
 }
 
-asyncfnwallet_sign(&self,address:Address,message:String) -> anyhow::Result<Signature>{
+asyncfnwallet_sign(&self,address:Address,message:Vec<u8>) -> anyhow::Result<Signature>{
 ifletSome(keystore) = &self.local{
 let key = crate::key_management::try_find_key(&address, keystore)?;
 
 Ok(crate::key_management::sign(
 *key.key_info.key_type(),
  key.key_info.private_key(),
-&BASE64_STANDARD.decode(message)?,
+&message,
 )?)
 }else{
-Ok(WalletSign::call(&self.remote,(address, message.into_bytes())).await?)
+Ok(WalletSign::call(&self.remote,(address, message)).await?)
 }
 }
 
@@ -264,6 +263,11 @@ pub enum WalletCommands {
 /// The address to be used to sign the message
 #[arg(short)]
 address:String,
+/// Sign the raw message bytes without the FRC-0102 envelope. Use this
+/// for interoperating with pre-FRC-0102 tooling, or when the bytes are
+/// already an on-chain Filecoin message (which must not be wrapped).
+#[arg(long)]
+raw:bool,
 },
 /// Validates whether a given string can be decoded as a well-formed address
 ValidateAddress{
@@ -282,6 +286,12 @@ pub enum WalletCommands {
 /// The signature of the message to verify
 #[arg(short)]
 signature:String,
+/// Verify against the raw message bytes without applying the
+/// FRC-0102 envelope. Use this for signatures produced by
+/// pre-FRC-0102 tooling or for on-chain Filecoin messages (which are
+/// signed raw, without the envelope).
+#[arg(long)]
+raw:bool,
 },
 /// Deletes the wallet associated with the given address.
 Delete{
@@ -461,12 +471,16 @@ impl WalletCommands {
 
  backend.wallet_set_default(key).await
 }
-Self::Sign{ address, message } => {
+Self::Sign{
+ address,
+ message,
+ raw,
+} => {
 letStrictAddress(address) = StrictAddress::from_str(&address)
 .with_context(|| format!("Invalid address: {address}"))?;
 
 let message = hex::decode(message).context("Message has to be a hex string")?;
-let message = BASE64_STANDARD.encode(message);
+let message = if raw { message }else{wrap_frc0102(&message)};
 
 let signature = backend.wallet_sign(address, message).await?;
 println!("{}", hex::encode(signature.to_bytes()));
@@ -481,12 +495,14 @@ impl WalletCommands {
  message,
  address,
  signature,
+ raw,
 } => {
 let sig_bytes =
  hex::decode(signature).context("Signature has to be a hex string")?;
 letStrictAddress(address) = StrictAddress::from_str(&address)
 .with_context(|| format!("Invalid address: {address}"))?;
 let msg = hex::decode(message).context("Message has to be a hex string")?;
+let msg = if raw { msg }else{wrap_frc0102(&msg)};
 
 let signature = Signature::from_bytes(sig_bytes)?;
 let is_valid = backend.wallet_verify(address, msg, signature).await?;
@@ -635,6 +651,15 @@ fn resolve_target_address(target_address: &str) -> anyhow::Result<(Address, bool
 }
 }
 
+/// FRC-0102 envelope prefix format: `0x19 || "Filecoin Signed Message:\n" || ascii(len(msg)) || msg`.
+constFRC_0102_FILECOIN_PREFIX:&[u8] = b"\x19Filecoin Signed Message:\n";
+
+/// Wraps `msg` with the FRC-0102 Filecoin signing envelope.
+fnwrap_frc0102(msg:&[u8]) -> Vec<u8>{
+let len = msg.len().to_string();
+[FRC_0102_FILECOIN_PREFIX, len.as_bytes(), msg].concat()
+}
+
 fnresolve_method_num(from:&Address,to:&Address,is_0x_recipient:bool) -> u64{
 if !is_eth_address(from) && !is_0x_recipient {
 returnMETHOD_SEND;
@@ -655,7 +680,7 @@ mod tests {
 usecrate::shim::address::{Address,CurrentNetwork,Network};
 usecrate::shim::message::METHOD_SEND;
 
-usesuper::{resolve_method_num, resolve_target_address};
+usesuper::{SignatureType,resolve_method_num, resolve_target_address, wrap_frc0102};
 
 #[test]
 fntest_resolve_target_address_id(){
@@ -773,4 +798,82 @@ mod tests {
 let method = resolve_method_num(&from,&to,true);
 assert_eq!(method,EVMMethod::InvokeContractasu64);
 }
+
+#[test]
+fntest_wrap_frc0102_empty(){
+let wrapped = wrap_frc0102(&[]);
+assert_eq!(wrapped,b"\x19Filecoin Signed Message:\n0");
+}
+
+#[test]
+fntest_wrap_frc0102_short(){
+let wrapped = wrap_frc0102(b"hello");
+assert_eq!(wrapped,b"\x19Filecoin Signed Message:\n5hello");
+}
+
+#[test]
+fntest_wrap_frc0102_longer(){
+let msg = b"this is a longer test message";
+let wrapped = wrap_frc0102(msg);
+letmut expected = Vec::new();
+ expected.extend_from_slice(b"\x19Filecoin Signed Message:\n");
+ expected.extend_from_slice(msg.len().to_string().as_bytes());
+ expected.extend_from_slice(msg);
+assert_eq!(wrapped, expected);
+}
+
+#[test]
+fntest_wrap_frc0102_binary_msg(){
+// Non-UTF-8 bytes must pass through unchanged.
+let msg:&[u8] = &[0x00,0xFF,0x10,0x80];
+let wrapped = wrap_frc0102(msg);
+assert_eq!(&wrapped[..26],b"\x19Filecoin Signed Message:\n");
+assert_eq!(&wrapped[26..27],b"4");
+assert_eq!(&wrapped[27..], msg);
+}
+
+#[test]
+fntest_wrap_frc0102_length_boundaries(){
+// Length is encoded as decimal ASCII; check 1-, 2-, 3- and 4-digit boundaries.
+for len in[0,9,10,99,100,999,1000]{
+let msg = vec![0xABu8; len];
+let wrapped = wrap_frc0102(&msg);
+let digits = len.to_string();
+assert_eq!(&wrapped[..26],b"\x19Filecoin Signed Message:\n");
+assert_eq!(&wrapped[26..26 + digits.len()], digits.as_bytes());
+assert_eq!(&wrapped[26 + digits.len()..], msg.as_slice());
+}
+}
+
+#[test]
+fntest_wrap_frc0102_contains_newline(){
+// The spec does not require any escaping; embedded newlines pass through.
+let msg = b"line1\nline2";
+let wrapped = wrap_frc0102(msg);
+assert_eq!(wrapped,b"\x19Filecoin Signed Message:\n11line1\nline2");
+}
+
+#[test]
+fntest_frc0102_roundtrip_sign_verify_secp256k1(){
+usecrate::key_management::generate_key;
+let key = generate_key(SignatureType::Secp256k1).unwrap();
+let raw_msg = b"hello world";
+let wrapped = wrap_frc0102(raw_msg);
+
+// Sign the wrapped bytes (what `forest-wallet sign` does by default).
+let signature = crate::key_management::sign(
+*key.key_info.key_type(),
+ key.key_info.private_key(),
+&wrapped,
+)
+.unwrap();
+
+// `verify` on the wrapped bytes must succeed.
+ signature.verify(&wrapped,&key.address).unwrap();
+
+assert!(
+ signature.verify(raw_msg,&key.address).is_err(),
+"raw-bytes verify should fail when the signature was produced over the FRC-0102 envelope"
+);
+}
 }