Skip to main content

sui_rpc_api/grpc/v2/
signature_verification_service.rs

1// Copyright (c) Mysten Labs, Inc.
2// SPDX-License-Identifier: Apache-2.0
3
4use 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        //TODO add function in sui_sdk_types crate to do this
101        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 none of the possible derived addresses match we need to return that this is invalid
152        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    // Building the zklogin verifier when the signature can actually contain a zklogin signature.
174    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
190/// A configured alias set replaces `address`; without one, `address` is its own sole alias.
191fn 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    // If jwks from the request is empty we load the current set of active jwks that are onchain
227    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    // RPC may receive historical signatures, so support both circuits.
265    zklogin_verifier.set_circuit_mode(ZkLoginCircuitMode::Both);
266    *zklogin_verifier.jwks_mut() = jwks;
267    Ok(zklogin_verifier)
268}