sui_rpc_api/grpc/v2/
signature_verification_service.rs1use std::collections::HashMap;
5use sui_crypto::Verifier;
6use sui_crypto::zklogin::ZkLoginCircuitMode;
7use sui_sdk_types::Jwk;
8use sui_sdk_types::JwkId;
9use tap::Pipe;
10
11use crate::ErrorReason;
12use crate::Result;
13use crate::RpcError;
14use crate::RpcService;
15use sui_rpc::proto::google::rpc::bad_request::FieldViolation;
16use sui_rpc::proto::sui::rpc::v2::VerifySignatureRequest;
17use sui_rpc::proto::sui::rpc::v2::VerifySignatureResponse;
18use sui_rpc::proto::sui::rpc::v2::signature_verification_service_server::SignatureVerificationService;
19
20#[tonic::async_trait]
21impl SignatureVerificationService for RpcService {
22 async fn verify_signature(
23 &self,
24 request: tonic::Request<VerifySignatureRequest>,
25 ) -> Result<tonic::Response<VerifySignatureResponse>, tonic::Status> {
26 verify_signature(self, request.into_inner())
27 .map(tonic::Response::new)
28 .map_err(Into::into)
29 }
30}
31
32#[tracing::instrument(skip(service))]
33fn verify_signature(
34 service: &RpcService,
35 request: VerifySignatureRequest,
36) -> Result<VerifySignatureResponse> {
37 let signature = request
38 .signature
39 .as_ref()
40 .ok_or_else(|| FieldViolation::new("signature").with_reason(ErrorReason::FieldMissing))?
41 .pipe(sui_sdk_types::UserSignature::try_from)
42 .map_err(|e| {
43 FieldViolation::new("signature")
44 .with_description(format!("invalid signature: {e}"))
45 .with_reason(ErrorReason::FieldInvalid)
46 })?;
47
48 let signing_digest = {
49 let bcs = request
50 .message
51 .ok_or_else(|| FieldViolation::new("message").with_reason(ErrorReason::FieldMissing))?;
52
53 match bcs.name() {
54 "TransactionData" => bcs
55 .deserialize::<sui_sdk_types::Transaction>()?
56 .signing_digest(),
57 "PersonalMessage" => bcs
58 .deserialize::<&[u8]>()
59 .map(|slice| sui_sdk_types::PersonalMessage(slice.into()))?
60 .signing_digest(),
61 _ => {
62 if let Ok(personal_message) = bcs
63 .deserialize::<&[u8]>()
64 .map(|slice| sui_sdk_types::PersonalMessage(slice.into()))
65 {
66 personal_message.signing_digest()
67 } else if let Ok(transaction) = bcs.deserialize::<sui_sdk_types::Transaction>() {
68 transaction.signing_digest()
69 } else {
70 return Err(FieldViolation::new("message")
71 .with_description("invalid message")
72 .with_reason(ErrorReason::FieldInvalid)
73 .into());
74 }
75 }
76 }
77 };
78
79 let check_address_aliases = request.check_address_aliases.unwrap_or(false);
80 if check_address_aliases && request.address.is_none() {
81 return Err(FieldViolation::new("address")
82 .with_description("address is required when check_address_aliases is set")
83 .with_reason(ErrorReason::FieldMissing)
84 .into());
85 }
86
87 let mut message = VerifySignatureResponse::default();
88 message.address_aliases_checked = check_address_aliases.then_some(true);
89
90 if let Some(address) = request
91 .address
92 .map(|address| address.parse::<sui_sdk_types::Address>())
93 .transpose()
94 .map_err(|e| {
95 FieldViolation::new("address")
96 .with_description(format!("invalid address: {e}"))
97 .with_reason(ErrorReason::FieldInvalid)
98 })?
99 {
100 let derived_addresses = match &signature {
102 sui_sdk_types::UserSignature::Simple(simple_signature) => match simple_signature {
103 sui_sdk_types::SimpleSignature::Ed25519 { public_key, .. } => {
104 [Some(public_key.derive_address()), None]
105 }
106 sui_sdk_types::SimpleSignature::Secp256k1 { public_key, .. } => {
107 [Some(public_key.derive_address()), None]
108 }
109 sui_sdk_types::SimpleSignature::Secp256r1 { public_key, .. } => {
110 [Some(public_key.derive_address()), None]
111 }
112 sui_sdk_types::SimpleSignature::MlDsa65 { public_key, .. } => {
113 [Some(public_key.derive_address()), None]
114 }
115 _ => {
116 return Err(RpcError::new(
117 tonic::Code::Internal,
118 "unknown signature scheme",
119 ));
120 }
121 },
122 sui_sdk_types::UserSignature::Multisig(multisig) => {
123 [Some(multisig.committee().derive_address()), None]
124 }
125 sui_sdk_types::UserSignature::ZkLogin(z) => {
126 let id = z.inputs.public_identifier();
127 [
128 Some(id.derive_address_padded()),
129 Some(id.derive_address_unpadded()),
130 ]
131 }
132 sui_sdk_types::UserSignature::Passkey(p) => {
133 [Some(p.public_key().derive_address()), None]
134 }
135 _ => {
136 return Err(RpcError::new(
137 tonic::Code::Internal,
138 "unknown signature scheme",
139 ));
140 }
141 };
142
143 let first_derived_address = derived_addresses[0].unwrap();
144
145 let authorized_addresses = if check_address_aliases {
146 address_aliases(service, address)?
147 } else {
148 vec![address]
149 };
150
151 if !derived_addresses
153 .into_iter()
154 .flatten()
155 .any(|derived_address| authorized_addresses.contains(&derived_address))
156 {
157 message.is_valid = Some(false);
158 message.reason = Some(if check_address_aliases {
159 format!(
160 "derived address `{}` is not an alias of `{}`",
161 first_derived_address, address
162 )
163 } else {
164 format!(
165 "provided address `{}` does not match derived address `{}`",
166 address, first_derived_address
167 )
168 });
169 return Ok(message);
170 }
171 }
172
173 let mut verifier = sui_crypto::UserSignatureVerifier::new();
175 if signature_may_contain_zklogin(&signature) {
176 verifier.with_zklogin_verifier(build_zklogin_verifier(service, &request.jwks)?);
177 }
178
179 match verifier.verify(&signing_digest, &signature) {
180 Ok(()) => message.is_valid = Some(true),
181 Err(error) => {
182 message.is_valid = Some(false);
183 message.reason = Some(error.to_string());
184 }
185 }
186
187 Ok(message)
188}
189
190fn address_aliases(
192 service: &RpcService,
193 address: sui_sdk_types::Address,
194) -> Result<Vec<sui_sdk_types::Address>> {
195 let Some(aliases) = service.reader.get_address_aliases(address.into())? else {
196 return Ok(vec![address]);
197 };
198
199 Ok(aliases
200 .aliases
201 .contents
202 .into_iter()
203 .map(sui_sdk_types::Address::from)
204 .collect())
205}
206
207fn signature_may_contain_zklogin(signature: &sui_sdk_types::UserSignature) -> bool {
208 match signature {
209 sui_sdk_types::UserSignature::ZkLogin(_) => true,
210 sui_sdk_types::UserSignature::Multisig(multisig) => {
211 multisig.committee().members().iter().any(|member| {
212 matches!(
213 member.public_key(),
214 sui_sdk_types::MultisigMemberPublicKey::ZkLogin(_)
215 )
216 })
217 }
218 _ => false,
219 }
220}
221
222fn build_zklogin_verifier(
223 service: &RpcService,
224 request_jwks: &[sui_rpc::proto::sui::rpc::v2::ActiveJwk],
225) -> Result<sui_crypto::zklogin::ZkloginVerifier> {
226 let jwks = {
228 let mut jwks = request_jwks
229 .iter()
230 .enumerate()
231 .map(|(i, jwk)| {
232 let jwk = sui_sdk_types::ActiveJwk::try_from(jwk).map_err(|e| {
233 FieldViolation::new_at("jwks", i)
234 .with_description(e.to_string())
235 .with_reason(ErrorReason::FieldInvalid)
236 })?;
237 Ok((jwk.jwk_id, jwk.jwk))
238 })
239 .collect::<Result<HashMap<JwkId, Jwk>>>()?;
240
241 if jwks.is_empty()
242 && let Some(authenticator_state) = service.reader.get_authenticator_state()?
243 {
244 jwks.extend(
245 authenticator_state
246 .active_jwks
247 .into_iter()
248 .map(sui_sdk_types::ActiveJwk::from)
249 .map(|active_jwk| (active_jwk.jwk_id, active_jwk.jwk)),
250 );
251 }
252
253 jwks
254 };
255
256 let chain = service.chain_id().chain();
257 let mut zklogin_verifier = match chain {
258 sui_protocol_config::Chain::Mainnet | sui_protocol_config::Chain::Testnet => {
259 sui_crypto::zklogin::ZkloginVerifier::new_mainnet()
260 }
261 sui_protocol_config::Chain::Unknown => sui_crypto::zklogin::ZkloginVerifier::new_dev(),
262 };
263
264 zklogin_verifier.set_circuit_mode(ZkLoginCircuitMode::Both);
266 *zklogin_verifier.jwks_mut() = jwks;
267 Ok(zklogin_verifier)
268}