zkgroup/api/auth/
auth_credential_with_pni.rs

1//
2// Copyright 2022 Signal Messenger, LLC.
3// SPDX-License-Identifier: AGPL-3.0-only
4//
5
6use libsignal_core::{Aci, Pni};
7use partial_default::PartialDefault;
8use serde::Serialize;
9
10use crate::auth::AnyAuthCredentialPresentation;
11use crate::groups::GroupSecretParams;
12use crate::{
13    RandomnessBytes, ServerPublicParams, ZkGroupDeserializationFailure, ZkGroupVerificationFailure,
14};
15
16mod zkc;
17pub use zkc::{
18    AuthCredentialWithPniZkc, AuthCredentialWithPniZkcPresentation,
19    AuthCredentialWithPniZkcResponse,
20};
21
22#[derive(Clone, PartialDefault, derive_more::From)]
23pub enum AuthCredentialWithPni {
24    #[partial_default]
25    Zkc(AuthCredentialWithPniZkc),
26}
27
28#[derive(Clone, PartialDefault, derive_more::From)]
29pub enum AuthCredentialWithPniResponse {
30    #[partial_default]
31    Zkc(AuthCredentialWithPniZkcResponse),
32}
33
34#[repr(u8)]
35#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialDefault, derive_more::TryFrom)]
36#[try_from(repr)]
37pub enum AuthCredentialWithPniVersion {
38    #[partial_default]
39    Zkc = 3,
40}
41
42impl AuthCredentialWithPni {
43    pub fn new(bytes: &[u8]) -> Result<Self, ZkGroupDeserializationFailure> {
44        let first = bytes
45            .first()
46            .ok_or_else(ZkGroupDeserializationFailure::new::<Self>)?;
47        let version = AuthCredentialWithPniVersion::try_from(*first)
48            .map_err(|_| ZkGroupDeserializationFailure::new::<Self>())?;
49        match version {
50            AuthCredentialWithPniVersion::Zkc => {
51                crate::common::serialization::deserialize(bytes).map(Self::Zkc)
52            }
53        }
54    }
55
56    pub fn present(
57        &self,
58        public_params: &ServerPublicParams,
59        group_secret_params: &GroupSecretParams,
60        randomness: RandomnessBytes,
61    ) -> AnyAuthCredentialPresentation {
62        match self {
63            Self::Zkc(credential) => AnyAuthCredentialPresentation::V4(credential.present(
64                public_params,
65                group_secret_params,
66                randomness,
67            )),
68        }
69    }
70}
71
72impl AuthCredentialWithPniResponse {
73    pub fn new(bytes: &[u8]) -> Result<Self, ZkGroupDeserializationFailure> {
74        let first = bytes
75            .first()
76            .ok_or_else(ZkGroupDeserializationFailure::new::<Self>)?;
77        let version = AuthCredentialWithPniVersion::try_from(*first)
78            .map_err(|_| ZkGroupDeserializationFailure::new::<Self>())?;
79        match version {
80            AuthCredentialWithPniVersion::Zkc => {
81                crate::common::serialization::deserialize(bytes).map(Self::Zkc)
82            }
83        }
84    }
85
86    pub fn receive(
87        self,
88        public_params: &ServerPublicParams,
89        aci: Aci,
90        pni: Pni,
91        redemption_time: crate::Timestamp,
92    ) -> Result<AuthCredentialWithPni, ZkGroupVerificationFailure> {
93        match self {
94            Self::Zkc(credential) => credential
95                .receive(aci, pni, redemption_time, public_params)
96                .map(AuthCredentialWithPni::Zkc),
97        }
98    }
99}
100
101impl Serialize for AuthCredentialWithPni {
102    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
103    where
104        S: serde::Serializer,
105    {
106        match self {
107            Self::Zkc(z) => z.serialize(serializer),
108        }
109    }
110}
111
112impl Serialize for AuthCredentialWithPniResponse {
113    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
114    where
115        S: serde::Serializer,
116    {
117        match self {
118            Self::Zkc(z) => z.serialize(serializer),
119        }
120    }
121}
zkgroup/api/auth/auth_credential_with_pni.rs

zkgroup/api/auth/
auth_credential_with_pni.rs
