-- This file is part of the Wire Server implementation.
--
-- Copyright (C) 2022 Wire Swiss GmbH <opensource@wire.com>
--
-- This program is free software: you can redistribute it and/or modify it under
-- the terms of the GNU Affero General Public License as published by the Free
-- Software Foundation, either version 3 of the License, or (at your option) any
-- later version.
--
-- This program is distributed in the hope that it will be useful, but WITHOUT
-- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-- FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
-- details.
--
-- You should have received a copy of the GNU Affero General Public License along
-- with this program. If not, see <https://www.gnu.org/licenses/>.

module Wire.API.MLS.KeyPackage
  ( KeyPackageUpload (..),
    KeyPackageBundle (..),
    KeyPackageBundleEntry (..),
    KeyPackageCount (..),
    KeyPackageData (..),
    DeleteKeyPackages (..),
    KeyPackage (..),
    credentialIdentityAndKey,
    keyPackageIdentity,
    kpRef,
    kpRef',
    KeyPackageTBS (..),
    KeyPackageRef (..),
    sanIdentity,
  )
where

import Cassandra.CQL hiding (Set)
import Control.Applicative
import Control.Lens hiding (set, (.=))
import Data.Aeson (FromJSON, ToJSON)
import Data.Bifunctor
import Data.ByteString.Lazy qualified as LBS
import Data.Id
import Data.Json.Util
import Data.OpenApi qualified as S
import Data.Qualified
import Data.Range
import Data.Schema hiding (HasField)
import Data.Text qualified as T
import Data.Text.Encoding qualified as T
import Data.X509 qualified as X509
import GHC.Records
import Imports
import Test.QuickCheck
import Web.HttpApiData
import Wire.API.MLS.CipherSuite
import Wire.API.MLS.Context
import Wire.API.MLS.Credential
import Wire.API.MLS.Extension
import Wire.API.MLS.HPKEPublicKey
import Wire.API.MLS.LeafNode
import Wire.API.MLS.ProtocolVersion
import Wire.API.MLS.Serialisation
import Wire.Arbitrary

data KeyPackageUpload = KeyPackageUpload
  { KeyPackageUpload -> [RawMLS KeyPackage]
keyPackages :: [RawMLS KeyPackage]
  }
  deriving (Value -> Parser [KeyPackageUpload]
Value -> Parser KeyPackageUpload
(Value -> Parser KeyPackageUpload)
-> (Value -> Parser [KeyPackageUpload])
-> FromJSON KeyPackageUpload
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser KeyPackageUpload
parseJSON :: Value -> Parser KeyPackageUpload
$cparseJSONList :: Value -> Parser [KeyPackageUpload]
parseJSONList :: Value -> Parser [KeyPackageUpload]
FromJSON, [KeyPackageUpload] -> Value
[KeyPackageUpload] -> Encoding
KeyPackageUpload -> Value
KeyPackageUpload -> Encoding
(KeyPackageUpload -> Value)
-> (KeyPackageUpload -> Encoding)
-> ([KeyPackageUpload] -> Value)
-> ([KeyPackageUpload] -> Encoding)
-> ToJSON KeyPackageUpload
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: KeyPackageUpload -> Value
toJSON :: KeyPackageUpload -> Value
$ctoEncoding :: KeyPackageUpload -> Encoding
toEncoding :: KeyPackageUpload -> Encoding
$ctoJSONList :: [KeyPackageUpload] -> Value
toJSONList :: [KeyPackageUpload] -> Value
$ctoEncodingList :: [KeyPackageUpload] -> Encoding
toEncodingList :: [KeyPackageUpload] -> Encoding
ToJSON, Typeable KeyPackageUpload
Typeable KeyPackageUpload =>
(Proxy KeyPackageUpload
 -> Declare (Definitions Schema) NamedSchema)
-> ToSchema KeyPackageUpload
Proxy KeyPackageUpload -> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy KeyPackageUpload -> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy KeyPackageUpload -> Declare (Definitions Schema) NamedSchema
S.ToSchema) via Schema KeyPackageUpload

instance ToSchema KeyPackageUpload where
  schema :: ValueSchema NamedSwaggerDoc KeyPackageUpload
schema =
    Text
-> SchemaP
     SwaggerDoc Object [Pair] KeyPackageUpload KeyPackageUpload
-> ValueSchema NamedSwaggerDoc KeyPackageUpload
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"KeyPackageUpload" (SchemaP SwaggerDoc Object [Pair] KeyPackageUpload KeyPackageUpload
 -> ValueSchema NamedSwaggerDoc KeyPackageUpload)
-> SchemaP
     SwaggerDoc Object [Pair] KeyPackageUpload KeyPackageUpload
-> ValueSchema NamedSwaggerDoc KeyPackageUpload
forall a b. (a -> b) -> a -> b
$
      [RawMLS KeyPackage] -> KeyPackageUpload
KeyPackageUpload
        ([RawMLS KeyPackage] -> KeyPackageUpload)
-> SchemaP
     SwaggerDoc Object [Pair] KeyPackageUpload [RawMLS KeyPackage]
-> SchemaP
     SwaggerDoc Object [Pair] KeyPackageUpload KeyPackageUpload
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> KeyPackageUpload -> [RawMLS KeyPackage]
keyPackages (KeyPackageUpload -> [RawMLS KeyPackage])
-> SchemaP
     SwaggerDoc Object [Pair] [RawMLS KeyPackage] [RawMLS KeyPackage]
-> SchemaP
     SwaggerDoc Object [Pair] KeyPackageUpload [RawMLS KeyPackage]
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP
     SwaggerDoc Value Value [RawMLS KeyPackage] [RawMLS KeyPackage]
-> SchemaP
     SwaggerDoc Object [Pair] [RawMLS KeyPackage] [RawMLS KeyPackage]
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"key_packages" (ValueSchema NamedSwaggerDoc (RawMLS KeyPackage)
-> SchemaP
     SwaggerDoc Value Value [RawMLS KeyPackage] [RawMLS KeyPackage]
forall ndoc doc a.
(HasArray ndoc doc, HasName ndoc) =>
ValueSchema ndoc a -> ValueSchema doc [a]
array ValueSchema NamedSwaggerDoc (RawMLS KeyPackage)
rawKeyPackageSchema)

newtype KeyPackageData = KeyPackageData {KeyPackageData -> ByteString
kpData :: ByteString}
  deriving stock (KeyPackageData -> KeyPackageData -> Bool
(KeyPackageData -> KeyPackageData -> Bool)
-> (KeyPackageData -> KeyPackageData -> Bool) -> Eq KeyPackageData
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: KeyPackageData -> KeyPackageData -> Bool
== :: KeyPackageData -> KeyPackageData -> Bool
$c/= :: KeyPackageData -> KeyPackageData -> Bool
/= :: KeyPackageData -> KeyPackageData -> Bool
Eq, Eq KeyPackageData
Eq KeyPackageData =>
(KeyPackageData -> KeyPackageData -> Ordering)
-> (KeyPackageData -> KeyPackageData -> Bool)
-> (KeyPackageData -> KeyPackageData -> Bool)
-> (KeyPackageData -> KeyPackageData -> Bool)
-> (KeyPackageData -> KeyPackageData -> Bool)
-> (KeyPackageData -> KeyPackageData -> KeyPackageData)
-> (KeyPackageData -> KeyPackageData -> KeyPackageData)
-> Ord KeyPackageData
KeyPackageData -> KeyPackageData -> Bool
KeyPackageData -> KeyPackageData -> Ordering
KeyPackageData -> KeyPackageData -> KeyPackageData
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: KeyPackageData -> KeyPackageData -> Ordering
compare :: KeyPackageData -> KeyPackageData -> Ordering
$c< :: KeyPackageData -> KeyPackageData -> Bool
< :: KeyPackageData -> KeyPackageData -> Bool
$c<= :: KeyPackageData -> KeyPackageData -> Bool
<= :: KeyPackageData -> KeyPackageData -> Bool
$c> :: KeyPackageData -> KeyPackageData -> Bool
> :: KeyPackageData -> KeyPackageData -> Bool
$c>= :: KeyPackageData -> KeyPackageData -> Bool
>= :: KeyPackageData -> KeyPackageData -> Bool
$cmax :: KeyPackageData -> KeyPackageData -> KeyPackageData
max :: KeyPackageData -> KeyPackageData -> KeyPackageData
$cmin :: KeyPackageData -> KeyPackageData -> KeyPackageData
min :: KeyPackageData -> KeyPackageData -> KeyPackageData
Ord, Int -> KeyPackageData -> ShowS
[KeyPackageData] -> ShowS
KeyPackageData -> [Char]
(Int -> KeyPackageData -> ShowS)
-> (KeyPackageData -> [Char])
-> ([KeyPackageData] -> ShowS)
-> Show KeyPackageData
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> KeyPackageData -> ShowS
showsPrec :: Int -> KeyPackageData -> ShowS
$cshow :: KeyPackageData -> [Char]
show :: KeyPackageData -> [Char]
$cshowList :: [KeyPackageData] -> ShowS
showList :: [KeyPackageData] -> ShowS
Show)

instance ToSchema KeyPackageData where
  schema :: ValueSchema NamedSwaggerDoc KeyPackageData
schema =
    ((Schema -> Identity Schema)
-> ValueSchema NamedSwaggerDoc KeyPackageData
-> Identity (ValueSchema NamedSwaggerDoc KeyPackageData)
forall s a. HasSchema s a => Lens' s a
Lens' (ValueSchema NamedSwaggerDoc KeyPackageData) Schema
S.schema ((Schema -> Identity Schema)
 -> ValueSchema NamedSwaggerDoc KeyPackageData
 -> Identity (ValueSchema NamedSwaggerDoc KeyPackageData))
-> (Schema -> Schema)
-> ValueSchema NamedSwaggerDoc KeyPackageData
-> ValueSchema NamedSwaggerDoc KeyPackageData
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ Schema -> Schema
addKeyPackageSwagger)
      ( ByteString -> KeyPackageData
KeyPackageData
          (ByteString -> KeyPackageData)
-> SchemaP NamedSwaggerDoc Value Value KeyPackageData ByteString
-> ValueSchema NamedSwaggerDoc KeyPackageData
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> KeyPackageData -> ByteString
kpData
            (KeyPackageData -> ByteString)
-> SchemaP NamedSwaggerDoc Value Value ByteString ByteString
-> SchemaP NamedSwaggerDoc Value Value KeyPackageData ByteString
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP SwaggerDoc Value Value ByteString ByteString
-> SchemaP NamedSwaggerDoc Value Value ByteString ByteString
forall doc doc' v m a b.
HasObject doc doc' =>
Text -> SchemaP doc v m a b -> SchemaP doc' v m a b
named Text
"KeyPackage" SchemaP SwaggerDoc Value Value ByteString ByteString
base64Schema
      )

instance Cql KeyPackageData where
  ctype :: Tagged KeyPackageData ColumnType
ctype = ColumnType -> Tagged KeyPackageData ColumnType
forall a b. b -> Tagged a b
Tagged ColumnType
BlobColumn
  toCql :: KeyPackageData -> Value
toCql = ByteString -> Value
CqlBlob (ByteString -> Value)
-> (KeyPackageData -> ByteString) -> KeyPackageData -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
LBS.fromStrict (ByteString -> ByteString)
-> (KeyPackageData -> ByteString) -> KeyPackageData -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyPackageData -> ByteString
kpData
  fromCql :: Value -> Either [Char] KeyPackageData
fromCql (CqlBlob ByteString
b) = KeyPackageData -> Either [Char] KeyPackageData
forall a. a -> Either [Char] a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (KeyPackageData -> Either [Char] KeyPackageData)
-> (ByteString -> KeyPackageData)
-> ByteString
-> Either [Char] KeyPackageData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> KeyPackageData
KeyPackageData (ByteString -> KeyPackageData)
-> (ByteString -> ByteString) -> ByteString -> KeyPackageData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
LBS.toStrict (ByteString -> Either [Char] KeyPackageData)
-> ByteString -> Either [Char] KeyPackageData
forall a b. (a -> b) -> a -> b
$ ByteString
b
  fromCql Value
_ = [Char] -> Either [Char] KeyPackageData
forall a b. a -> Either a b
Left [Char]
"Expected CqlBlob"

data KeyPackageBundleEntry = KeyPackageBundleEntry
  { KeyPackageBundleEntry -> Qualified UserId
user :: Qualified UserId,
    KeyPackageBundleEntry -> ClientId
client :: ClientId,
    KeyPackageBundleEntry -> KeyPackageRef
ref :: KeyPackageRef,
    KeyPackageBundleEntry -> KeyPackageData
keyPackage :: KeyPackageData
  }
  deriving stock (KeyPackageBundleEntry -> KeyPackageBundleEntry -> Bool
(KeyPackageBundleEntry -> KeyPackageBundleEntry -> Bool)
-> (KeyPackageBundleEntry -> KeyPackageBundleEntry -> Bool)
-> Eq KeyPackageBundleEntry
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: KeyPackageBundleEntry -> KeyPackageBundleEntry -> Bool
== :: KeyPackageBundleEntry -> KeyPackageBundleEntry -> Bool
$c/= :: KeyPackageBundleEntry -> KeyPackageBundleEntry -> Bool
/= :: KeyPackageBundleEntry -> KeyPackageBundleEntry -> Bool
Eq, Eq KeyPackageBundleEntry
Eq KeyPackageBundleEntry =>
(KeyPackageBundleEntry -> KeyPackageBundleEntry -> Ordering)
-> (KeyPackageBundleEntry -> KeyPackageBundleEntry -> Bool)
-> (KeyPackageBundleEntry -> KeyPackageBundleEntry -> Bool)
-> (KeyPackageBundleEntry -> KeyPackageBundleEntry -> Bool)
-> (KeyPackageBundleEntry -> KeyPackageBundleEntry -> Bool)
-> (KeyPackageBundleEntry
    -> KeyPackageBundleEntry -> KeyPackageBundleEntry)
-> (KeyPackageBundleEntry
    -> KeyPackageBundleEntry -> KeyPackageBundleEntry)
-> Ord KeyPackageBundleEntry
KeyPackageBundleEntry -> KeyPackageBundleEntry -> Bool
KeyPackageBundleEntry -> KeyPackageBundleEntry -> Ordering
KeyPackageBundleEntry
-> KeyPackageBundleEntry -> KeyPackageBundleEntry
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: KeyPackageBundleEntry -> KeyPackageBundleEntry -> Ordering
compare :: KeyPackageBundleEntry -> KeyPackageBundleEntry -> Ordering
$c< :: KeyPackageBundleEntry -> KeyPackageBundleEntry -> Bool
< :: KeyPackageBundleEntry -> KeyPackageBundleEntry -> Bool
$c<= :: KeyPackageBundleEntry -> KeyPackageBundleEntry -> Bool
<= :: KeyPackageBundleEntry -> KeyPackageBundleEntry -> Bool
$c> :: KeyPackageBundleEntry -> KeyPackageBundleEntry -> Bool
> :: KeyPackageBundleEntry -> KeyPackageBundleEntry -> Bool
$c>= :: KeyPackageBundleEntry -> KeyPackageBundleEntry -> Bool
>= :: KeyPackageBundleEntry -> KeyPackageBundleEntry -> Bool
$cmax :: KeyPackageBundleEntry
-> KeyPackageBundleEntry -> KeyPackageBundleEntry
max :: KeyPackageBundleEntry
-> KeyPackageBundleEntry -> KeyPackageBundleEntry
$cmin :: KeyPackageBundleEntry
-> KeyPackageBundleEntry -> KeyPackageBundleEntry
min :: KeyPackageBundleEntry
-> KeyPackageBundleEntry -> KeyPackageBundleEntry
Ord, Int -> KeyPackageBundleEntry -> ShowS
[KeyPackageBundleEntry] -> ShowS
KeyPackageBundleEntry -> [Char]
(Int -> KeyPackageBundleEntry -> ShowS)
-> (KeyPackageBundleEntry -> [Char])
-> ([KeyPackageBundleEntry] -> ShowS)
-> Show KeyPackageBundleEntry
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> KeyPackageBundleEntry -> ShowS
showsPrec :: Int -> KeyPackageBundleEntry -> ShowS
$cshow :: KeyPackageBundleEntry -> [Char]
show :: KeyPackageBundleEntry -> [Char]
$cshowList :: [KeyPackageBundleEntry] -> ShowS
showList :: [KeyPackageBundleEntry] -> ShowS
Show)

instance ToSchema KeyPackageBundleEntry where
  schema :: ValueSchema NamedSwaggerDoc KeyPackageBundleEntry
schema =
    Text
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     KeyPackageBundleEntry
     KeyPackageBundleEntry
-> ValueSchema NamedSwaggerDoc KeyPackageBundleEntry
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"KeyPackageBundleEntry" (SchemaP
   SwaggerDoc
   Object
   [Pair]
   KeyPackageBundleEntry
   KeyPackageBundleEntry
 -> ValueSchema NamedSwaggerDoc KeyPackageBundleEntry)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     KeyPackageBundleEntry
     KeyPackageBundleEntry
-> ValueSchema NamedSwaggerDoc KeyPackageBundleEntry
forall a b. (a -> b) -> a -> b
$
      Qualified UserId
-> ClientId
-> KeyPackageRef
-> KeyPackageData
-> KeyPackageBundleEntry
KeyPackageBundleEntry
        (Qualified UserId
 -> ClientId
 -> KeyPackageRef
 -> KeyPackageData
 -> KeyPackageBundleEntry)
-> SchemaP
     SwaggerDoc Object [Pair] KeyPackageBundleEntry (Qualified UserId)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     KeyPackageBundleEntry
     (ClientId
      -> KeyPackageRef -> KeyPackageData -> KeyPackageBundleEntry)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (.user) (KeyPackageBundleEntry -> Qualified UserId)
-> SchemaP
     SwaggerDoc Object [Pair] (Qualified UserId) (Qualified UserId)
-> SchemaP
     SwaggerDoc Object [Pair] KeyPackageBundleEntry (Qualified UserId)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> ValueSchema NamedSwaggerDoc UserId
-> SchemaP
     SwaggerDoc Object [Pair] (Qualified UserId) (Qualified UserId)
forall d a.
HasSchemaRef d =>
Text -> ValueSchema d a -> ObjectSchema SwaggerDoc (Qualified a)
qualifiedObjectSchema Text
"user" ValueSchema NamedSwaggerDoc UserId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  KeyPackageBundleEntry
  (ClientId
   -> KeyPackageRef -> KeyPackageData -> KeyPackageBundleEntry)
-> SchemaP SwaggerDoc Object [Pair] KeyPackageBundleEntry ClientId
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     KeyPackageBundleEntry
     (KeyPackageRef -> KeyPackageData -> KeyPackageBundleEntry)
forall a b.
SchemaP SwaggerDoc Object [Pair] KeyPackageBundleEntry (a -> b)
-> SchemaP SwaggerDoc Object [Pair] KeyPackageBundleEntry a
-> SchemaP SwaggerDoc Object [Pair] KeyPackageBundleEntry b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (.client) (KeyPackageBundleEntry -> ClientId)
-> SchemaP SwaggerDoc Object [Pair] ClientId ClientId
-> SchemaP SwaggerDoc Object [Pair] KeyPackageBundleEntry ClientId
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value ClientId ClientId
-> SchemaP SwaggerDoc Object [Pair] ClientId ClientId
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"client" SchemaP NamedSwaggerDoc Value Value ClientId ClientId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  KeyPackageBundleEntry
  (KeyPackageRef -> KeyPackageData -> KeyPackageBundleEntry)
-> SchemaP
     SwaggerDoc Object [Pair] KeyPackageBundleEntry KeyPackageRef
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     KeyPackageBundleEntry
     (KeyPackageData -> KeyPackageBundleEntry)
forall a b.
SchemaP SwaggerDoc Object [Pair] KeyPackageBundleEntry (a -> b)
-> SchemaP SwaggerDoc Object [Pair] KeyPackageBundleEntry a
-> SchemaP SwaggerDoc Object [Pair] KeyPackageBundleEntry b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (.ref) (KeyPackageBundleEntry -> KeyPackageRef)
-> SchemaP SwaggerDoc Object [Pair] KeyPackageRef KeyPackageRef
-> SchemaP
     SwaggerDoc Object [Pair] KeyPackageBundleEntry KeyPackageRef
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value KeyPackageRef KeyPackageRef
-> SchemaP SwaggerDoc Object [Pair] KeyPackageRef KeyPackageRef
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"key_package_ref" SchemaP NamedSwaggerDoc Value Value KeyPackageRef KeyPackageRef
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  KeyPackageBundleEntry
  (KeyPackageData -> KeyPackageBundleEntry)
-> SchemaP
     SwaggerDoc Object [Pair] KeyPackageBundleEntry KeyPackageData
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     KeyPackageBundleEntry
     KeyPackageBundleEntry
forall a b.
SchemaP SwaggerDoc Object [Pair] KeyPackageBundleEntry (a -> b)
-> SchemaP SwaggerDoc Object [Pair] KeyPackageBundleEntry a
-> SchemaP SwaggerDoc Object [Pair] KeyPackageBundleEntry b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (.keyPackage) (KeyPackageBundleEntry -> KeyPackageData)
-> SchemaP SwaggerDoc Object [Pair] KeyPackageData KeyPackageData
-> SchemaP
     SwaggerDoc Object [Pair] KeyPackageBundleEntry KeyPackageData
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> ValueSchema NamedSwaggerDoc KeyPackageData
-> SchemaP SwaggerDoc Object [Pair] KeyPackageData KeyPackageData
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"key_package" ValueSchema NamedSwaggerDoc KeyPackageData
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema

newtype KeyPackageBundle = KeyPackageBundle {KeyPackageBundle -> Set KeyPackageBundleEntry
entries :: Set KeyPackageBundleEntry}
  deriving stock (KeyPackageBundle -> KeyPackageBundle -> Bool
(KeyPackageBundle -> KeyPackageBundle -> Bool)
-> (KeyPackageBundle -> KeyPackageBundle -> Bool)
-> Eq KeyPackageBundle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: KeyPackageBundle -> KeyPackageBundle -> Bool
== :: KeyPackageBundle -> KeyPackageBundle -> Bool
$c/= :: KeyPackageBundle -> KeyPackageBundle -> Bool
/= :: KeyPackageBundle -> KeyPackageBundle -> Bool
Eq, Int -> KeyPackageBundle -> ShowS
[KeyPackageBundle] -> ShowS
KeyPackageBundle -> [Char]
(Int -> KeyPackageBundle -> ShowS)
-> (KeyPackageBundle -> [Char])
-> ([KeyPackageBundle] -> ShowS)
-> Show KeyPackageBundle
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> KeyPackageBundle -> ShowS
showsPrec :: Int -> KeyPackageBundle -> ShowS
$cshow :: KeyPackageBundle -> [Char]
show :: KeyPackageBundle -> [Char]
$cshowList :: [KeyPackageBundle] -> ShowS
showList :: [KeyPackageBundle] -> ShowS
Show)
  deriving (Value -> Parser [KeyPackageBundle]
Value -> Parser KeyPackageBundle
(Value -> Parser KeyPackageBundle)
-> (Value -> Parser [KeyPackageBundle])
-> FromJSON KeyPackageBundle
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser KeyPackageBundle
parseJSON :: Value -> Parser KeyPackageBundle
$cparseJSONList :: Value -> Parser [KeyPackageBundle]
parseJSONList :: Value -> Parser [KeyPackageBundle]
FromJSON, [KeyPackageBundle] -> Value
[KeyPackageBundle] -> Encoding
KeyPackageBundle -> Value
KeyPackageBundle -> Encoding
(KeyPackageBundle -> Value)
-> (KeyPackageBundle -> Encoding)
-> ([KeyPackageBundle] -> Value)
-> ([KeyPackageBundle] -> Encoding)
-> ToJSON KeyPackageBundle
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: KeyPackageBundle -> Value
toJSON :: KeyPackageBundle -> Value
$ctoEncoding :: KeyPackageBundle -> Encoding
toEncoding :: KeyPackageBundle -> Encoding
$ctoJSONList :: [KeyPackageBundle] -> Value
toJSONList :: [KeyPackageBundle] -> Value
$ctoEncodingList :: [KeyPackageBundle] -> Encoding
toEncodingList :: [KeyPackageBundle] -> Encoding
ToJSON, Typeable KeyPackageBundle
Typeable KeyPackageBundle =>
(Proxy KeyPackageBundle
 -> Declare (Definitions Schema) NamedSchema)
-> ToSchema KeyPackageBundle
Proxy KeyPackageBundle -> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy KeyPackageBundle -> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy KeyPackageBundle -> Declare (Definitions Schema) NamedSchema
S.ToSchema) via Schema KeyPackageBundle

instance ToSchema KeyPackageBundle where
  schema :: ValueSchema NamedSwaggerDoc KeyPackageBundle
schema =
    Text
-> SchemaP
     SwaggerDoc Object [Pair] KeyPackageBundle KeyPackageBundle
-> ValueSchema NamedSwaggerDoc KeyPackageBundle
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"KeyPackageBundle" (SchemaP SwaggerDoc Object [Pair] KeyPackageBundle KeyPackageBundle
 -> ValueSchema NamedSwaggerDoc KeyPackageBundle)
-> SchemaP
     SwaggerDoc Object [Pair] KeyPackageBundle KeyPackageBundle
-> ValueSchema NamedSwaggerDoc KeyPackageBundle
forall a b. (a -> b) -> a -> b
$
      Set KeyPackageBundleEntry -> KeyPackageBundle
KeyPackageBundle
        (Set KeyPackageBundleEntry -> KeyPackageBundle)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     KeyPackageBundle
     (Set KeyPackageBundleEntry)
-> SchemaP
     SwaggerDoc Object [Pair] KeyPackageBundle KeyPackageBundle
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (.entries) (KeyPackageBundle -> Set KeyPackageBundleEntry)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Set KeyPackageBundleEntry)
     (Set KeyPackageBundleEntry)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     KeyPackageBundle
     (Set KeyPackageBundleEntry)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP
     SwaggerDoc
     Value
     Value
     (Set KeyPackageBundleEntry)
     (Set KeyPackageBundleEntry)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Set KeyPackageBundleEntry)
     (Set KeyPackageBundleEntry)
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"key_packages" (ValueSchema NamedSwaggerDoc KeyPackageBundleEntry
-> SchemaP
     SwaggerDoc
     Value
     Value
     (Set KeyPackageBundleEntry)
     (Set KeyPackageBundleEntry)
forall ndoc doc a.
(HasArray ndoc doc, HasName ndoc, Ord a) =>
ValueSchema ndoc a -> ValueSchema doc (Set a)
set ValueSchema NamedSwaggerDoc KeyPackageBundleEntry
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)

newtype KeyPackageCount = KeyPackageCount {KeyPackageCount -> Int
unKeyPackageCount :: Int}
  deriving newtype (KeyPackageCount -> KeyPackageCount -> Bool
(KeyPackageCount -> KeyPackageCount -> Bool)
-> (KeyPackageCount -> KeyPackageCount -> Bool)
-> Eq KeyPackageCount
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: KeyPackageCount -> KeyPackageCount -> Bool
== :: KeyPackageCount -> KeyPackageCount -> Bool
$c/= :: KeyPackageCount -> KeyPackageCount -> Bool
/= :: KeyPackageCount -> KeyPackageCount -> Bool
Eq, Eq KeyPackageCount
Eq KeyPackageCount =>
(KeyPackageCount -> KeyPackageCount -> Ordering)
-> (KeyPackageCount -> KeyPackageCount -> Bool)
-> (KeyPackageCount -> KeyPackageCount -> Bool)
-> (KeyPackageCount -> KeyPackageCount -> Bool)
-> (KeyPackageCount -> KeyPackageCount -> Bool)
-> (KeyPackageCount -> KeyPackageCount -> KeyPackageCount)
-> (KeyPackageCount -> KeyPackageCount -> KeyPackageCount)
-> Ord KeyPackageCount
KeyPackageCount -> KeyPackageCount -> Bool
KeyPackageCount -> KeyPackageCount -> Ordering
KeyPackageCount -> KeyPackageCount -> KeyPackageCount
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: KeyPackageCount -> KeyPackageCount -> Ordering
compare :: KeyPackageCount -> KeyPackageCount -> Ordering
$c< :: KeyPackageCount -> KeyPackageCount -> Bool
< :: KeyPackageCount -> KeyPackageCount -> Bool
$c<= :: KeyPackageCount -> KeyPackageCount -> Bool
<= :: KeyPackageCount -> KeyPackageCount -> Bool
$c> :: KeyPackageCount -> KeyPackageCount -> Bool
> :: KeyPackageCount -> KeyPackageCount -> Bool
$c>= :: KeyPackageCount -> KeyPackageCount -> Bool
>= :: KeyPackageCount -> KeyPackageCount -> Bool
$cmax :: KeyPackageCount -> KeyPackageCount -> KeyPackageCount
max :: KeyPackageCount -> KeyPackageCount -> KeyPackageCount
$cmin :: KeyPackageCount -> KeyPackageCount -> KeyPackageCount
min :: KeyPackageCount -> KeyPackageCount -> KeyPackageCount
Ord, Integer -> KeyPackageCount
KeyPackageCount -> KeyPackageCount
KeyPackageCount -> KeyPackageCount -> KeyPackageCount
(KeyPackageCount -> KeyPackageCount -> KeyPackageCount)
-> (KeyPackageCount -> KeyPackageCount -> KeyPackageCount)
-> (KeyPackageCount -> KeyPackageCount -> KeyPackageCount)
-> (KeyPackageCount -> KeyPackageCount)
-> (KeyPackageCount -> KeyPackageCount)
-> (KeyPackageCount -> KeyPackageCount)
-> (Integer -> KeyPackageCount)
-> Num KeyPackageCount
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: KeyPackageCount -> KeyPackageCount -> KeyPackageCount
+ :: KeyPackageCount -> KeyPackageCount -> KeyPackageCount
$c- :: KeyPackageCount -> KeyPackageCount -> KeyPackageCount
- :: KeyPackageCount -> KeyPackageCount -> KeyPackageCount
$c* :: KeyPackageCount -> KeyPackageCount -> KeyPackageCount
* :: KeyPackageCount -> KeyPackageCount -> KeyPackageCount
$cnegate :: KeyPackageCount -> KeyPackageCount
negate :: KeyPackageCount -> KeyPackageCount
$cabs :: KeyPackageCount -> KeyPackageCount
abs :: KeyPackageCount -> KeyPackageCount
$csignum :: KeyPackageCount -> KeyPackageCount
signum :: KeyPackageCount -> KeyPackageCount
$cfromInteger :: Integer -> KeyPackageCount
fromInteger :: Integer -> KeyPackageCount
Num, Int -> KeyPackageCount -> ShowS
[KeyPackageCount] -> ShowS
KeyPackageCount -> [Char]
(Int -> KeyPackageCount -> ShowS)
-> (KeyPackageCount -> [Char])
-> ([KeyPackageCount] -> ShowS)
-> Show KeyPackageCount
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> KeyPackageCount -> ShowS
showsPrec :: Int -> KeyPackageCount -> ShowS
$cshow :: KeyPackageCount -> [Char]
show :: KeyPackageCount -> [Char]
$cshowList :: [KeyPackageCount] -> ShowS
showList :: [KeyPackageCount] -> ShowS
Show)
  deriving (Value -> Parser [KeyPackageCount]
Value -> Parser KeyPackageCount
(Value -> Parser KeyPackageCount)
-> (Value -> Parser [KeyPackageCount]) -> FromJSON KeyPackageCount
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser KeyPackageCount
parseJSON :: Value -> Parser KeyPackageCount
$cparseJSONList :: Value -> Parser [KeyPackageCount]
parseJSONList :: Value -> Parser [KeyPackageCount]
FromJSON, [KeyPackageCount] -> Value
[KeyPackageCount] -> Encoding
KeyPackageCount -> Value
KeyPackageCount -> Encoding
(KeyPackageCount -> Value)
-> (KeyPackageCount -> Encoding)
-> ([KeyPackageCount] -> Value)
-> ([KeyPackageCount] -> Encoding)
-> ToJSON KeyPackageCount
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: KeyPackageCount -> Value
toJSON :: KeyPackageCount -> Value
$ctoEncoding :: KeyPackageCount -> Encoding
toEncoding :: KeyPackageCount -> Encoding
$ctoJSONList :: [KeyPackageCount] -> Value
toJSONList :: [KeyPackageCount] -> Value
$ctoEncodingList :: [KeyPackageCount] -> Encoding
toEncodingList :: [KeyPackageCount] -> Encoding
ToJSON, Typeable KeyPackageCount
Typeable KeyPackageCount =>
(Proxy KeyPackageCount -> Declare (Definitions Schema) NamedSchema)
-> ToSchema KeyPackageCount
Proxy KeyPackageCount -> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy KeyPackageCount -> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy KeyPackageCount -> Declare (Definitions Schema) NamedSchema
S.ToSchema) via Schema KeyPackageCount

instance ToSchema KeyPackageCount where
  schema :: ValueSchema NamedSwaggerDoc KeyPackageCount
schema =
    Text
-> SchemaP SwaggerDoc Object [Pair] KeyPackageCount KeyPackageCount
-> ValueSchema NamedSwaggerDoc KeyPackageCount
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"OwnKeyPackages" (SchemaP SwaggerDoc Object [Pair] KeyPackageCount KeyPackageCount
 -> ValueSchema NamedSwaggerDoc KeyPackageCount)
-> SchemaP SwaggerDoc Object [Pair] KeyPackageCount KeyPackageCount
-> ValueSchema NamedSwaggerDoc KeyPackageCount
forall a b. (a -> b) -> a -> b
$
      Int -> KeyPackageCount
KeyPackageCount (Int -> KeyPackageCount)
-> SchemaP SwaggerDoc Object [Pair] KeyPackageCount Int
-> SchemaP SwaggerDoc Object [Pair] KeyPackageCount KeyPackageCount
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> KeyPackageCount -> Int
unKeyPackageCount (KeyPackageCount -> Int)
-> SchemaP SwaggerDoc Object [Pair] Int Int
-> SchemaP SwaggerDoc Object [Pair] KeyPackageCount Int
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value Int Int
-> SchemaP SwaggerDoc Object [Pair] Int Int
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"count" SchemaP NamedSwaggerDoc Value Value Int Int
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema

newtype DeleteKeyPackages = DeleteKeyPackages
  {DeleteKeyPackages -> [KeyPackageRef]
unDeleteKeyPackages :: [KeyPackageRef]}
  deriving newtype (DeleteKeyPackages -> DeleteKeyPackages -> Bool
(DeleteKeyPackages -> DeleteKeyPackages -> Bool)
-> (DeleteKeyPackages -> DeleteKeyPackages -> Bool)
-> Eq DeleteKeyPackages
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DeleteKeyPackages -> DeleteKeyPackages -> Bool
== :: DeleteKeyPackages -> DeleteKeyPackages -> Bool
$c/= :: DeleteKeyPackages -> DeleteKeyPackages -> Bool
/= :: DeleteKeyPackages -> DeleteKeyPackages -> Bool
Eq, Eq DeleteKeyPackages
Eq DeleteKeyPackages =>
(DeleteKeyPackages -> DeleteKeyPackages -> Ordering)
-> (DeleteKeyPackages -> DeleteKeyPackages -> Bool)
-> (DeleteKeyPackages -> DeleteKeyPackages -> Bool)
-> (DeleteKeyPackages -> DeleteKeyPackages -> Bool)
-> (DeleteKeyPackages -> DeleteKeyPackages -> Bool)
-> (DeleteKeyPackages -> DeleteKeyPackages -> DeleteKeyPackages)
-> (DeleteKeyPackages -> DeleteKeyPackages -> DeleteKeyPackages)
-> Ord DeleteKeyPackages
DeleteKeyPackages -> DeleteKeyPackages -> Bool
DeleteKeyPackages -> DeleteKeyPackages -> Ordering
DeleteKeyPackages -> DeleteKeyPackages -> DeleteKeyPackages
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: DeleteKeyPackages -> DeleteKeyPackages -> Ordering
compare :: DeleteKeyPackages -> DeleteKeyPackages -> Ordering
$c< :: DeleteKeyPackages -> DeleteKeyPackages -> Bool
< :: DeleteKeyPackages -> DeleteKeyPackages -> Bool
$c<= :: DeleteKeyPackages -> DeleteKeyPackages -> Bool
<= :: DeleteKeyPackages -> DeleteKeyPackages -> Bool
$c> :: DeleteKeyPackages -> DeleteKeyPackages -> Bool
> :: DeleteKeyPackages -> DeleteKeyPackages -> Bool
$c>= :: DeleteKeyPackages -> DeleteKeyPackages -> Bool
>= :: DeleteKeyPackages -> DeleteKeyPackages -> Bool
$cmax :: DeleteKeyPackages -> DeleteKeyPackages -> DeleteKeyPackages
max :: DeleteKeyPackages -> DeleteKeyPackages -> DeleteKeyPackages
$cmin :: DeleteKeyPackages -> DeleteKeyPackages -> DeleteKeyPackages
min :: DeleteKeyPackages -> DeleteKeyPackages -> DeleteKeyPackages
Ord, Int -> DeleteKeyPackages -> ShowS
[DeleteKeyPackages] -> ShowS
DeleteKeyPackages -> [Char]
(Int -> DeleteKeyPackages -> ShowS)
-> (DeleteKeyPackages -> [Char])
-> ([DeleteKeyPackages] -> ShowS)
-> Show DeleteKeyPackages
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DeleteKeyPackages -> ShowS
showsPrec :: Int -> DeleteKeyPackages -> ShowS
$cshow :: DeleteKeyPackages -> [Char]
show :: DeleteKeyPackages -> [Char]
$cshowList :: [DeleteKeyPackages] -> ShowS
showList :: [DeleteKeyPackages] -> ShowS
Show)
  deriving (Value -> Parser [DeleteKeyPackages]
Value -> Parser DeleteKeyPackages
(Value -> Parser DeleteKeyPackages)
-> (Value -> Parser [DeleteKeyPackages])
-> FromJSON DeleteKeyPackages
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser DeleteKeyPackages
parseJSON :: Value -> Parser DeleteKeyPackages
$cparseJSONList :: Value -> Parser [DeleteKeyPackages]
parseJSONList :: Value -> Parser [DeleteKeyPackages]
FromJSON, [DeleteKeyPackages] -> Value
[DeleteKeyPackages] -> Encoding
DeleteKeyPackages -> Value
DeleteKeyPackages -> Encoding
(DeleteKeyPackages -> Value)
-> (DeleteKeyPackages -> Encoding)
-> ([DeleteKeyPackages] -> Value)
-> ([DeleteKeyPackages] -> Encoding)
-> ToJSON DeleteKeyPackages
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: DeleteKeyPackages -> Value
toJSON :: DeleteKeyPackages -> Value
$ctoEncoding :: DeleteKeyPackages -> Encoding
toEncoding :: DeleteKeyPackages -> Encoding
$ctoJSONList :: [DeleteKeyPackages] -> Value
toJSONList :: [DeleteKeyPackages] -> Value
$ctoEncodingList :: [DeleteKeyPackages] -> Encoding
toEncodingList :: [DeleteKeyPackages] -> Encoding
ToJSON, Typeable DeleteKeyPackages
Typeable DeleteKeyPackages =>
(Proxy DeleteKeyPackages
 -> Declare (Definitions Schema) NamedSchema)
-> ToSchema DeleteKeyPackages
Proxy DeleteKeyPackages -> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy DeleteKeyPackages -> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy DeleteKeyPackages -> Declare (Definitions Schema) NamedSchema
S.ToSchema) via Schema DeleteKeyPackages

instance ToSchema DeleteKeyPackages where
  schema :: ValueSchema NamedSwaggerDoc DeleteKeyPackages
schema =
    Text
-> SchemaP
     SwaggerDoc Object [Pair] DeleteKeyPackages DeleteKeyPackages
-> ValueSchema NamedSwaggerDoc DeleteKeyPackages
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"DeleteKeyPackages" (SchemaP
   SwaggerDoc Object [Pair] DeleteKeyPackages DeleteKeyPackages
 -> ValueSchema NamedSwaggerDoc DeleteKeyPackages)
-> SchemaP
     SwaggerDoc Object [Pair] DeleteKeyPackages DeleteKeyPackages
-> ValueSchema NamedSwaggerDoc DeleteKeyPackages
forall a b. (a -> b) -> a -> b
$
      [KeyPackageRef] -> DeleteKeyPackages
DeleteKeyPackages
        ([KeyPackageRef] -> DeleteKeyPackages)
-> SchemaP
     SwaggerDoc Object [Pair] DeleteKeyPackages [KeyPackageRef]
-> SchemaP
     SwaggerDoc Object [Pair] DeleteKeyPackages DeleteKeyPackages
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DeleteKeyPackages -> [KeyPackageRef]
unDeleteKeyPackages
          (DeleteKeyPackages -> [KeyPackageRef])
-> SchemaP SwaggerDoc Object [Pair] [KeyPackageRef] [KeyPackageRef]
-> SchemaP
     SwaggerDoc Object [Pair] DeleteKeyPackages [KeyPackageRef]
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP SwaggerDoc Value Value [KeyPackageRef] [KeyPackageRef]
-> SchemaP SwaggerDoc Object [Pair] [KeyPackageRef] [KeyPackageRef]
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field
            Text
"key_packages"
            (Integer
-> Integer
-> SchemaP SwaggerDoc Value Value [KeyPackageRef] [KeyPackageRef]
-> SchemaP SwaggerDoc Value Value [KeyPackageRef] [KeyPackageRef]
forall d v w a b.
HasRangedSchemaDocModifier d b =>
Integer -> Integer -> SchemaP d v w a b -> SchemaP d v w a b
untypedRangedSchema Integer
1 Integer
1000 (SchemaP NamedSwaggerDoc Value Value KeyPackageRef KeyPackageRef
-> SchemaP SwaggerDoc Value Value [KeyPackageRef] [KeyPackageRef]
forall ndoc doc a.
(HasArray ndoc doc, HasName ndoc) =>
ValueSchema ndoc a -> ValueSchema doc [a]
array SchemaP NamedSwaggerDoc Value Value KeyPackageRef KeyPackageRef
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema))

newtype KeyPackageRef = KeyPackageRef {KeyPackageRef -> ByteString
unKeyPackageRef :: ByteString}
  deriving stock (KeyPackageRef -> KeyPackageRef -> Bool
(KeyPackageRef -> KeyPackageRef -> Bool)
-> (KeyPackageRef -> KeyPackageRef -> Bool) -> Eq KeyPackageRef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: KeyPackageRef -> KeyPackageRef -> Bool
== :: KeyPackageRef -> KeyPackageRef -> Bool
$c/= :: KeyPackageRef -> KeyPackageRef -> Bool
/= :: KeyPackageRef -> KeyPackageRef -> Bool
Eq, Eq KeyPackageRef
Eq KeyPackageRef =>
(KeyPackageRef -> KeyPackageRef -> Ordering)
-> (KeyPackageRef -> KeyPackageRef -> Bool)
-> (KeyPackageRef -> KeyPackageRef -> Bool)
-> (KeyPackageRef -> KeyPackageRef -> Bool)
-> (KeyPackageRef -> KeyPackageRef -> Bool)
-> (KeyPackageRef -> KeyPackageRef -> KeyPackageRef)
-> (KeyPackageRef -> KeyPackageRef -> KeyPackageRef)
-> Ord KeyPackageRef
KeyPackageRef -> KeyPackageRef -> Bool
KeyPackageRef -> KeyPackageRef -> Ordering
KeyPackageRef -> KeyPackageRef -> KeyPackageRef
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: KeyPackageRef -> KeyPackageRef -> Ordering
compare :: KeyPackageRef -> KeyPackageRef -> Ordering
$c< :: KeyPackageRef -> KeyPackageRef -> Bool
< :: KeyPackageRef -> KeyPackageRef -> Bool
$c<= :: KeyPackageRef -> KeyPackageRef -> Bool
<= :: KeyPackageRef -> KeyPackageRef -> Bool
$c> :: KeyPackageRef -> KeyPackageRef -> Bool
> :: KeyPackageRef -> KeyPackageRef -> Bool
$c>= :: KeyPackageRef -> KeyPackageRef -> Bool
>= :: KeyPackageRef -> KeyPackageRef -> Bool
$cmax :: KeyPackageRef -> KeyPackageRef -> KeyPackageRef
max :: KeyPackageRef -> KeyPackageRef -> KeyPackageRef
$cmin :: KeyPackageRef -> KeyPackageRef -> KeyPackageRef
min :: KeyPackageRef -> KeyPackageRef -> KeyPackageRef
Ord, Int -> KeyPackageRef -> ShowS
[KeyPackageRef] -> ShowS
KeyPackageRef -> [Char]
(Int -> KeyPackageRef -> ShowS)
-> (KeyPackageRef -> [Char])
-> ([KeyPackageRef] -> ShowS)
-> Show KeyPackageRef
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> KeyPackageRef -> ShowS
showsPrec :: Int -> KeyPackageRef -> ShowS
$cshow :: KeyPackageRef -> [Char]
show :: KeyPackageRef -> [Char]
$cshowList :: [KeyPackageRef] -> ShowS
showList :: [KeyPackageRef] -> ShowS
Show)
  deriving (Text -> Either Text KeyPackageRef
ByteString -> Either Text KeyPackageRef
(Text -> Either Text KeyPackageRef)
-> (ByteString -> Either Text KeyPackageRef)
-> (Text -> Either Text KeyPackageRef)
-> FromHttpApiData KeyPackageRef
forall a.
(Text -> Either Text a)
-> (ByteString -> Either Text a)
-> (Text -> Either Text a)
-> FromHttpApiData a
$cparseUrlPiece :: Text -> Either Text KeyPackageRef
parseUrlPiece :: Text -> Either Text KeyPackageRef
$cparseHeader :: ByteString -> Either Text KeyPackageRef
parseHeader :: ByteString -> Either Text KeyPackageRef
$cparseQueryParam :: Text -> Either Text KeyPackageRef
parseQueryParam :: Text -> Either Text KeyPackageRef
FromHttpApiData, KeyPackageRef -> Text
KeyPackageRef -> ByteString
KeyPackageRef -> Builder
(KeyPackageRef -> Text)
-> (KeyPackageRef -> Builder)
-> (KeyPackageRef -> ByteString)
-> (KeyPackageRef -> Text)
-> (KeyPackageRef -> Builder)
-> ToHttpApiData KeyPackageRef
forall a.
(a -> Text)
-> (a -> Builder)
-> (a -> ByteString)
-> (a -> Text)
-> (a -> Builder)
-> ToHttpApiData a
$ctoUrlPiece :: KeyPackageRef -> Text
toUrlPiece :: KeyPackageRef -> Text
$ctoEncodedUrlPiece :: KeyPackageRef -> Builder
toEncodedUrlPiece :: KeyPackageRef -> Builder
$ctoHeader :: KeyPackageRef -> ByteString
toHeader :: KeyPackageRef -> ByteString
$ctoQueryParam :: KeyPackageRef -> Text
toQueryParam :: KeyPackageRef -> Text
$ctoEncodedQueryParam :: KeyPackageRef -> Builder
toEncodedQueryParam :: KeyPackageRef -> Builder
ToHttpApiData, Proxy KeyPackageRef -> Schema
(Proxy KeyPackageRef -> Schema) -> ToParamSchema KeyPackageRef
forall a. (Proxy a -> Schema) -> ToParamSchema a
$ctoParamSchema :: Proxy KeyPackageRef -> Schema
toParamSchema :: Proxy KeyPackageRef -> Schema
S.ToParamSchema) via Base64ByteString
  deriving ([KeyPackageRef] -> Value
[KeyPackageRef] -> Encoding
KeyPackageRef -> Value
KeyPackageRef -> Encoding
(KeyPackageRef -> Value)
-> (KeyPackageRef -> Encoding)
-> ([KeyPackageRef] -> Value)
-> ([KeyPackageRef] -> Encoding)
-> ToJSON KeyPackageRef
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: KeyPackageRef -> Value
toJSON :: KeyPackageRef -> Value
$ctoEncoding :: KeyPackageRef -> Encoding
toEncoding :: KeyPackageRef -> Encoding
$ctoJSONList :: [KeyPackageRef] -> Value
toJSONList :: [KeyPackageRef] -> Value
$ctoEncodingList :: [KeyPackageRef] -> Encoding
toEncodingList :: [KeyPackageRef] -> Encoding
ToJSON, Value -> Parser [KeyPackageRef]
Value -> Parser KeyPackageRef
(Value -> Parser KeyPackageRef)
-> (Value -> Parser [KeyPackageRef]) -> FromJSON KeyPackageRef
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser KeyPackageRef
parseJSON :: Value -> Parser KeyPackageRef
$cparseJSONList :: Value -> Parser [KeyPackageRef]
parseJSONList :: Value -> Parser [KeyPackageRef]
FromJSON, Typeable KeyPackageRef
Typeable KeyPackageRef =>
(Proxy KeyPackageRef -> Declare (Definitions Schema) NamedSchema)
-> ToSchema KeyPackageRef
Proxy KeyPackageRef -> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy KeyPackageRef -> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy KeyPackageRef -> Declare (Definitions Schema) NamedSchema
S.ToSchema) via (Schema KeyPackageRef)
  deriving newtype (Gen KeyPackageRef
Gen KeyPackageRef
-> (KeyPackageRef -> [KeyPackageRef]) -> Arbitrary KeyPackageRef
KeyPackageRef -> [KeyPackageRef]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen KeyPackageRef
arbitrary :: Gen KeyPackageRef
$cshrink :: KeyPackageRef -> [KeyPackageRef]
shrink :: KeyPackageRef -> [KeyPackageRef]
Arbitrary)

instance ToSchema KeyPackageRef where
  schema :: SchemaP NamedSwaggerDoc Value Value KeyPackageRef KeyPackageRef
schema = Text
-> SchemaP SwaggerDoc Value Value KeyPackageRef KeyPackageRef
-> SchemaP NamedSwaggerDoc Value Value KeyPackageRef KeyPackageRef
forall doc doc' v m a b.
HasObject doc doc' =>
Text -> SchemaP doc v m a b -> SchemaP doc' v m a b
named Text
"KeyPackageRef" (SchemaP SwaggerDoc Value Value KeyPackageRef KeyPackageRef
 -> SchemaP NamedSwaggerDoc Value Value KeyPackageRef KeyPackageRef)
-> SchemaP SwaggerDoc Value Value KeyPackageRef KeyPackageRef
-> SchemaP NamedSwaggerDoc Value Value KeyPackageRef KeyPackageRef
forall a b. (a -> b) -> a -> b
$ KeyPackageRef -> ByteString
unKeyPackageRef (KeyPackageRef -> ByteString)
-> SchemaP SwaggerDoc Value Value ByteString KeyPackageRef
-> SchemaP SwaggerDoc Value Value KeyPackageRef KeyPackageRef
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= (ByteString -> KeyPackageRef)
-> SchemaP SwaggerDoc Value Value ByteString ByteString
-> SchemaP SwaggerDoc Value Value ByteString KeyPackageRef
forall a b.
(a -> b)
-> SchemaP SwaggerDoc Value Value ByteString a
-> SchemaP SwaggerDoc Value Value ByteString b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> KeyPackageRef
KeyPackageRef SchemaP SwaggerDoc Value Value ByteString ByteString
base64Schema

instance ParseMLS KeyPackageRef where
  parseMLS :: Get KeyPackageRef
parseMLS = ByteString -> KeyPackageRef
KeyPackageRef (ByteString -> KeyPackageRef)
-> Get ByteString -> Get KeyPackageRef
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall w. (Binary w, Integral w) => Get ByteString
parseMLSBytes @VarInt

instance SerialiseMLS KeyPackageRef where
  serialiseMLS :: KeyPackageRef -> Put
serialiseMLS = forall w. (Binary w, Integral w) => ByteString -> Put
serialiseMLSBytes @VarInt (ByteString -> Put)
-> (KeyPackageRef -> ByteString) -> KeyPackageRef -> Put
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyPackageRef -> ByteString
unKeyPackageRef

instance Cql KeyPackageRef where
  ctype :: Tagged KeyPackageRef ColumnType
ctype = ColumnType -> Tagged KeyPackageRef ColumnType
forall a b. b -> Tagged a b
Tagged ColumnType
BlobColumn
  toCql :: KeyPackageRef -> Value
toCql = ByteString -> Value
CqlBlob (ByteString -> Value)
-> (KeyPackageRef -> ByteString) -> KeyPackageRef -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
LBS.fromStrict (ByteString -> ByteString)
-> (KeyPackageRef -> ByteString) -> KeyPackageRef -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyPackageRef -> ByteString
unKeyPackageRef
  fromCql :: Value -> Either [Char] KeyPackageRef
fromCql (CqlBlob ByteString
b) = KeyPackageRef -> Either [Char] KeyPackageRef
forall a. a -> Either [Char] a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (KeyPackageRef -> Either [Char] KeyPackageRef)
-> (ByteString -> KeyPackageRef)
-> ByteString
-> Either [Char] KeyPackageRef
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> KeyPackageRef
KeyPackageRef (ByteString -> KeyPackageRef)
-> (ByteString -> ByteString) -> ByteString -> KeyPackageRef
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
LBS.toStrict (ByteString -> Either [Char] KeyPackageRef)
-> ByteString -> Either [Char] KeyPackageRef
forall a b. (a -> b) -> a -> b
$ ByteString
b
  fromCql Value
_ = [Char] -> Either [Char] KeyPackageRef
forall a b. a -> Either a b
Left [Char]
"Expected CqlBlob"

-- | Compute key package ref given a ciphersuite and the raw key package data.
kpRef :: CipherSuiteTag -> KeyPackageData -> KeyPackageRef
kpRef :: CipherSuiteTag -> KeyPackageData -> KeyPackageRef
kpRef CipherSuiteTag
cs =
  ByteString -> KeyPackageRef
KeyPackageRef
    (ByteString -> KeyPackageRef)
-> (KeyPackageData -> ByteString)
-> KeyPackageData
-> KeyPackageRef
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CipherSuiteTag -> ByteString -> RawMLS () -> ByteString
forall a. CipherSuiteTag -> ByteString -> RawMLS a -> ByteString
csHash CipherSuiteTag
cs ByteString
keyPackageContext
    (RawMLS () -> ByteString)
-> (KeyPackageData -> RawMLS ()) -> KeyPackageData -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ByteString -> () -> RawMLS ()) -> () -> ByteString -> RawMLS ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip ByteString -> () -> RawMLS ()
forall a. ByteString -> a -> RawMLS a
RawMLS ()
    (ByteString -> RawMLS ())
-> (KeyPackageData -> ByteString) -> KeyPackageData -> RawMLS ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyPackageData -> ByteString
kpData

-- | Compute ref of a key package. Return 'Nothing' if the key package cipher
-- suite is invalid or unsupported.
kpRef' :: RawMLS KeyPackage -> Maybe KeyPackageRef
kpRef' :: RawMLS KeyPackage -> Maybe KeyPackageRef
kpRef' RawMLS KeyPackage
kp =
  CipherSuiteTag -> KeyPackageData -> KeyPackageRef
kpRef
    (CipherSuiteTag -> KeyPackageData -> KeyPackageRef)
-> Maybe CipherSuiteTag -> Maybe (KeyPackageData -> KeyPackageRef)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CipherSuite -> Maybe CipherSuiteTag
cipherSuiteTag (RawMLS KeyPackage
kp.value.cipherSuite)
    Maybe (KeyPackageData -> KeyPackageRef)
-> Maybe KeyPackageData -> Maybe KeyPackageRef
forall a b. Maybe (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> KeyPackageData -> Maybe KeyPackageData
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ByteString -> KeyPackageData
KeyPackageData (RawMLS KeyPackage -> ByteString
forall a. RawMLS a -> ByteString
raw RawMLS KeyPackage
kp))

--------------------------------------------------------------------------------

-- | https://messaginglayersecurity.rocks/mls-protocol/draft-ietf-mls-protocol-20/draft-ietf-mls-protocol.html#section-10-6
data KeyPackageTBS = KeyPackageTBS
  { KeyPackageTBS -> ProtocolVersion
protocolVersion :: ProtocolVersion,
    KeyPackageTBS -> CipherSuite
cipherSuite :: CipherSuite,
    KeyPackageTBS -> HPKEPublicKey
initKey :: HPKEPublicKey,
    KeyPackageTBS -> LeafNode
leafNode :: LeafNode,
    KeyPackageTBS -> [Extension]
extensions :: [Extension]
  }
  deriving stock (KeyPackageTBS -> KeyPackageTBS -> Bool
(KeyPackageTBS -> KeyPackageTBS -> Bool)
-> (KeyPackageTBS -> KeyPackageTBS -> Bool) -> Eq KeyPackageTBS
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: KeyPackageTBS -> KeyPackageTBS -> Bool
== :: KeyPackageTBS -> KeyPackageTBS -> Bool
$c/= :: KeyPackageTBS -> KeyPackageTBS -> Bool
/= :: KeyPackageTBS -> KeyPackageTBS -> Bool
Eq, Int -> KeyPackageTBS -> ShowS
[KeyPackageTBS] -> ShowS
KeyPackageTBS -> [Char]
(Int -> KeyPackageTBS -> ShowS)
-> (KeyPackageTBS -> [Char])
-> ([KeyPackageTBS] -> ShowS)
-> Show KeyPackageTBS
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> KeyPackageTBS -> ShowS
showsPrec :: Int -> KeyPackageTBS -> ShowS
$cshow :: KeyPackageTBS -> [Char]
show :: KeyPackageTBS -> [Char]
$cshowList :: [KeyPackageTBS] -> ShowS
showList :: [KeyPackageTBS] -> ShowS
Show, (forall x. KeyPackageTBS -> Rep KeyPackageTBS x)
-> (forall x. Rep KeyPackageTBS x -> KeyPackageTBS)
-> Generic KeyPackageTBS
forall x. Rep KeyPackageTBS x -> KeyPackageTBS
forall x. KeyPackageTBS -> Rep KeyPackageTBS x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. KeyPackageTBS -> Rep KeyPackageTBS x
from :: forall x. KeyPackageTBS -> Rep KeyPackageTBS x
$cto :: forall x. Rep KeyPackageTBS x -> KeyPackageTBS
to :: forall x. Rep KeyPackageTBS x -> KeyPackageTBS
Generic)
  deriving (Gen KeyPackageTBS
Gen KeyPackageTBS
-> (KeyPackageTBS -> [KeyPackageTBS]) -> Arbitrary KeyPackageTBS
KeyPackageTBS -> [KeyPackageTBS]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen KeyPackageTBS
arbitrary :: Gen KeyPackageTBS
$cshrink :: KeyPackageTBS -> [KeyPackageTBS]
shrink :: KeyPackageTBS -> [KeyPackageTBS]
Arbitrary) via GenericUniform KeyPackageTBS

instance ParseMLS KeyPackageTBS where
  parseMLS :: Get KeyPackageTBS
parseMLS =
    ProtocolVersion
-> CipherSuite
-> HPKEPublicKey
-> LeafNode
-> [Extension]
-> KeyPackageTBS
KeyPackageTBS
      (ProtocolVersion
 -> CipherSuite
 -> HPKEPublicKey
 -> LeafNode
 -> [Extension]
 -> KeyPackageTBS)
-> Get ProtocolVersion
-> Get
     (CipherSuite
      -> HPKEPublicKey -> LeafNode -> [Extension] -> KeyPackageTBS)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get ProtocolVersion
forall a. ParseMLS a => Get a
parseMLS
      Get
  (CipherSuite
   -> HPKEPublicKey -> LeafNode -> [Extension] -> KeyPackageTBS)
-> Get CipherSuite
-> Get (HPKEPublicKey -> LeafNode -> [Extension] -> KeyPackageTBS)
forall a b. Get (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get CipherSuite
forall a. ParseMLS a => Get a
parseMLS
      Get (HPKEPublicKey -> LeafNode -> [Extension] -> KeyPackageTBS)
-> Get HPKEPublicKey
-> Get (LeafNode -> [Extension] -> KeyPackageTBS)
forall a b. Get (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get HPKEPublicKey
forall a. ParseMLS a => Get a
parseMLS
      Get (LeafNode -> [Extension] -> KeyPackageTBS)
-> Get LeafNode -> Get ([Extension] -> KeyPackageTBS)
forall a b. Get (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get LeafNode
forall a. ParseMLS a => Get a
parseMLS
      Get ([Extension] -> KeyPackageTBS)
-> Get [Extension] -> Get KeyPackageTBS
forall a b. Get (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall w a. (Binary w, Integral w) => Get a -> Get [a]
parseMLSVector @VarInt Get Extension
forall a. ParseMLS a => Get a
parseMLS

instance SerialiseMLS KeyPackageTBS where
  serialiseMLS :: KeyPackageTBS -> Put
serialiseMLS KeyPackageTBS
tbs = do
    ProtocolVersion -> Put
forall a. SerialiseMLS a => a -> Put
serialiseMLS KeyPackageTBS
tbs.protocolVersion
    CipherSuite -> Put
forall a. SerialiseMLS a => a -> Put
serialiseMLS KeyPackageTBS
tbs.cipherSuite
    HPKEPublicKey -> Put
forall a. SerialiseMLS a => a -> Put
serialiseMLS KeyPackageTBS
tbs.initKey
    LeafNode -> Put
forall a. SerialiseMLS a => a -> Put
serialiseMLS KeyPackageTBS
tbs.leafNode
    forall w a. (Binary w, Integral w) => (a -> Put) -> [a] -> Put
serialiseMLSVector @VarInt Extension -> Put
forall a. SerialiseMLS a => a -> Put
serialiseMLS KeyPackageTBS
tbs.extensions

-- | https://messaginglayersecurity.rocks/mls-protocol/draft-ietf-mls-protocol-20/draft-ietf-mls-protocol.html#section-10-6
data KeyPackage = KeyPackage
  { KeyPackage -> RawMLS KeyPackageTBS
tbs :: RawMLS KeyPackageTBS,
    KeyPackage -> ByteString
signature_ :: ByteString
  }
  deriving stock (KeyPackage -> KeyPackage -> Bool
(KeyPackage -> KeyPackage -> Bool)
-> (KeyPackage -> KeyPackage -> Bool) -> Eq KeyPackage
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: KeyPackage -> KeyPackage -> Bool
== :: KeyPackage -> KeyPackage -> Bool
$c/= :: KeyPackage -> KeyPackage -> Bool
/= :: KeyPackage -> KeyPackage -> Bool
Eq, Int -> KeyPackage -> ShowS
[KeyPackage] -> ShowS
KeyPackage -> [Char]
(Int -> KeyPackage -> ShowS)
-> (KeyPackage -> [Char])
-> ([KeyPackage] -> ShowS)
-> Show KeyPackage
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> KeyPackage -> ShowS
showsPrec :: Int -> KeyPackage -> ShowS
$cshow :: KeyPackage -> [Char]
show :: KeyPackage -> [Char]
$cshowList :: [KeyPackage] -> ShowS
showList :: [KeyPackage] -> ShowS
Show, (forall x. KeyPackage -> Rep KeyPackage x)
-> (forall x. Rep KeyPackage x -> KeyPackage) -> Generic KeyPackage
forall x. Rep KeyPackage x -> KeyPackage
forall x. KeyPackage -> Rep KeyPackage x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. KeyPackage -> Rep KeyPackage x
from :: forall x. KeyPackage -> Rep KeyPackage x
$cto :: forall x. Rep KeyPackage x -> KeyPackage
to :: forall x. Rep KeyPackage x -> KeyPackage
Generic)
  deriving (Gen KeyPackage
Gen KeyPackage
-> (KeyPackage -> [KeyPackage]) -> Arbitrary KeyPackage
KeyPackage -> [KeyPackage]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen KeyPackage
arbitrary :: Gen KeyPackage
$cshrink :: KeyPackage -> [KeyPackage]
shrink :: KeyPackage -> [KeyPackage]
Arbitrary) via (GenericUniform KeyPackage)

instance S.ToSchema KeyPackage where
  declareNamedSchema :: Proxy KeyPackage -> Declare (Definitions Schema) NamedSchema
declareNamedSchema Proxy KeyPackage
_ = NamedSchema -> Declare (Definitions Schema) NamedSchema
forall a. a -> DeclareT (Definitions Schema) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> NamedSchema
mlsSwagger Text
"KeyPackage")

instance HasField "protocolVersion" KeyPackage ProtocolVersion where
  getField :: KeyPackage -> ProtocolVersion
getField = (.tbs.value.protocolVersion)

instance HasField "cipherSuite" KeyPackage CipherSuite where
  getField :: KeyPackage -> CipherSuite
getField = (.tbs.value.cipherSuite)

instance HasField "initKey" KeyPackage HPKEPublicKey where
  getField :: KeyPackage -> HPKEPublicKey
getField = (.tbs.value.initKey)

instance HasField "extensions" KeyPackage [Extension] where
  getField :: KeyPackage -> [Extension]
getField = (.tbs.value.extensions)

instance HasField "leafNode" KeyPackage LeafNode where
  getField :: KeyPackage -> LeafNode
getField = (.tbs.value.leafNode)

credentialIdentityAndKey :: Credential -> Either Text (ClientIdentity, Maybe X509.PubKey)
credentialIdentityAndKey :: Credential -> Either Text (ClientIdentity, Maybe PubKey)
credentialIdentityAndKey (BasicCredential ByteString
i) = (,) (ClientIdentity -> Maybe PubKey -> (ClientIdentity, Maybe PubKey))
-> Either Text ClientIdentity
-> Either Text (Maybe PubKey -> (ClientIdentity, Maybe PubKey))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ByteString -> Either Text ClientIdentity
forall a. ParseMLS a => ByteString -> Either Text a
decodeMLS' ByteString
i Either Text (Maybe PubKey -> (ClientIdentity, Maybe PubKey))
-> Either Text (Maybe PubKey)
-> Either Text (ClientIdentity, Maybe PubKey)
forall a b. Either Text (a -> b) -> Either Text a -> Either Text b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe PubKey -> Either Text (Maybe PubKey)
forall a. a -> Either Text a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe PubKey
forall a. Maybe a
Nothing
credentialIdentityAndKey (X509Credential [ByteString]
certs) = do
  ByteString
bs <- case [ByteString]
certs of
    [] -> Text -> Either Text ByteString
forall a b. a -> Either a b
Left Text
"Invalid x509 certificate chain"
    (ByteString
c : [ByteString]
_) -> ByteString -> Either Text ByteString
forall a. a -> Either Text a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ByteString
c
  SignedCertificate
signed <-
    ([Char] -> Text)
-> Either [Char] SignedCertificate -> Either Text SignedCertificate
forall a b c. (a -> b) -> Either a c -> Either b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (\[Char]
e -> Text
"Failed to decode x509 certificate: " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
T.pack [Char]
e) (Either [Char] SignedCertificate -> Either Text SignedCertificate)
-> Either [Char] SignedCertificate -> Either Text SignedCertificate
forall a b. (a -> b) -> a -> b
$
      ByteString -> Either [Char] SignedCertificate
X509.decodeSignedCertificate ByteString
bs
  -- FUTUREWORK: verify signature
  let cert :: Certificate
cert = SignedCertificate -> Certificate
X509.getCertificate SignedCertificate
signed
  Certificate -> Either Text (ClientIdentity, Maybe PubKey)
certificateIdentityAndKey Certificate
cert

keyPackageIdentity :: KeyPackage -> Either Text ClientIdentity
keyPackageIdentity :: KeyPackage -> Either Text ClientIdentity
keyPackageIdentity KeyPackage
kp = (ClientIdentity, Maybe PubKey) -> ClientIdentity
forall a b. (a, b) -> a
fst ((ClientIdentity, Maybe PubKey) -> ClientIdentity)
-> Either Text (ClientIdentity, Maybe PubKey)
-> Either Text ClientIdentity
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Credential -> Either Text (ClientIdentity, Maybe PubKey)
credentialIdentityAndKey KeyPackage
kp.leafNode.credential

certificateIdentityAndKey :: X509.Certificate -> Either Text (ClientIdentity, Maybe X509.PubKey)
certificateIdentityAndKey :: Certificate -> Either Text (ClientIdentity, Maybe PubKey)
certificateIdentityAndKey Certificate
cert =
  let getNames :: ExtSubjectAltName -> [AltName]
getNames (X509.ExtSubjectAltName [AltName]
names) = [AltName]
names
      getURI :: AltName -> Maybe [Char]
getURI (X509.AltNameURI [Char]
u) = [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just [Char]
u
      getURI AltName
_ = Maybe [Char]
forall a. Maybe a
Nothing
      altNames :: [AltName]
altNames = [AltName]
-> (ExtSubjectAltName -> [AltName])
-> Maybe ExtSubjectAltName
-> [AltName]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] ExtSubjectAltName -> [AltName]
getNames (Extensions -> Maybe ExtSubjectAltName
forall a. Extension a => Extensions -> Maybe a
X509.extensionGet (Certificate -> Extensions
X509.certExtensions Certificate
cert))
      ids :: [Either Text ClientIdentity]
ids = ([Char] -> Either Text ClientIdentity)
-> [[Char]] -> [Either Text ClientIdentity]
forall a b. (a -> b) -> [a] -> [b]
map [Char] -> Either Text ClientIdentity
sanIdentity ((AltName -> Maybe [Char]) -> [AltName] -> [[Char]]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe AltName -> Maybe [Char]
getURI [AltName]
altNames)
   in case [Either Text ClientIdentity] -> ([Text], [ClientIdentity])
forall a b. [Either a b] -> ([a], [b])
partitionEithers [Either Text ClientIdentity]
ids of
        ([Text]
_, (ClientIdentity
cid : [ClientIdentity]
_)) -> (ClientIdentity, Maybe PubKey)
-> Either Text (ClientIdentity, Maybe PubKey)
forall a. a -> Either Text a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ClientIdentity
cid, PubKey -> Maybe PubKey
forall a. a -> Maybe a
Just (Certificate -> PubKey
X509.certPubKey Certificate
cert))
        ((Text
e : [Text]
_), []) -> Text -> Either Text (ClientIdentity, Maybe PubKey)
forall a b. a -> Either a b
Left Text
e
        ([Text], [ClientIdentity])
_ -> Text -> Either Text (ClientIdentity, Maybe PubKey)
forall a b. a -> Either a b
Left Text
"No SAN URIs found"

-- client identity format: wireapp://{userid}!{deviceid}@{host}
sanIdentity :: String -> Either Text ClientIdentity
sanIdentity :: [Char] -> Either Text ClientIdentity
sanIdentity [Char]
s = case (Char -> Bool) -> [Char] -> ([Char], [Char])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
':') [Char]
s of
  ([Char]
"wireapp", Char
':' : Char
'/' : Char
'/' : [Char]
s') ->
    (Text -> Text)
-> Either Text ClientIdentity -> Either Text ClientIdentity
forall a b c. (a -> b) -> Either a c -> Either b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (\Text
e -> Text
e Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" (while parsing identity string " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
T.pack (ShowS
forall a. Show a => a -> [Char]
show [Char]
s') Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
")")
      (Either Text ClientIdentity -> Either Text ClientIdentity)
-> ([Char] -> Either Text ClientIdentity)
-> [Char]
-> Either Text ClientIdentity
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Get ClientIdentity -> ByteString -> Either Text ClientIdentity
forall a. Get a -> ByteString -> Either Text a
decodeMLSWith' Get ClientIdentity
parseX509ClientIdentity
      (ByteString -> Either Text ClientIdentity)
-> ([Char] -> ByteString) -> [Char] -> Either Text ClientIdentity
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> ByteString
T.encodeUtf8
      (Text -> ByteString) -> ([Char] -> Text) -> [Char] -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> Text
T.pack
      ([Char] -> Either Text ClientIdentity)
-> [Char] -> Either Text ClientIdentity
forall a b. (a -> b) -> a -> b
$ [Char]
s'
  ([Char], [Char])
_ -> Text -> Either Text ClientIdentity
forall a b. a -> Either a b
Left Text
"No wireapp label found"

rawKeyPackageSchema :: ValueSchema NamedSwaggerDoc (RawMLS KeyPackage)
rawKeyPackageSchema :: ValueSchema NamedSwaggerDoc (RawMLS KeyPackage)
rawKeyPackageSchema =
  Text
-> (ByteString -> Either Text KeyPackage)
-> ValueSchema NamedSwaggerDoc (RawMLS KeyPackage)
forall a.
Text
-> (ByteString -> Either Text a)
-> ValueSchema NamedSwaggerDoc (RawMLS a)
rawMLSSchema Text
"KeyPackage" ByteString -> Either Text KeyPackage
forall a. ParseMLS a => ByteString -> Either Text a
decodeMLS'
    ValueSchema NamedSwaggerDoc (RawMLS KeyPackage)
-> (ValueSchema NamedSwaggerDoc (RawMLS KeyPackage)
    -> ValueSchema NamedSwaggerDoc (RawMLS KeyPackage))
-> ValueSchema NamedSwaggerDoc (RawMLS KeyPackage)
forall a b. a -> (a -> b) -> b
& (Schema -> Identity Schema)
-> ValueSchema NamedSwaggerDoc (RawMLS KeyPackage)
-> Identity (ValueSchema NamedSwaggerDoc (RawMLS KeyPackage))
forall s a. HasSchema s a => Lens' s a
Lens' (ValueSchema NamedSwaggerDoc (RawMLS KeyPackage)) Schema
S.schema ((Schema -> Identity Schema)
 -> ValueSchema NamedSwaggerDoc (RawMLS KeyPackage)
 -> Identity (ValueSchema NamedSwaggerDoc (RawMLS KeyPackage)))
-> (Schema -> Schema)
-> ValueSchema NamedSwaggerDoc (RawMLS KeyPackage)
-> ValueSchema NamedSwaggerDoc (RawMLS KeyPackage)
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ Schema -> Schema
addKeyPackageSwagger

addKeyPackageSwagger :: S.Schema -> S.Schema
addKeyPackageSwagger :: Schema -> Schema
addKeyPackageSwagger = (Maybe Value -> Identity (Maybe Value))
-> Schema -> Identity Schema
forall s a. HasExample s a => Lens' s a
Lens' Schema (Maybe Value)
S.example ((Maybe Value -> Identity (Maybe Value))
 -> Schema -> Identity Schema)
-> Value -> Schema -> Schema
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Value
"a2V5IHBhY2thZ2UgZGF0YQo="

instance ParseMLS KeyPackage where
  parseMLS :: Get KeyPackage
parseMLS =
    RawMLS KeyPackageTBS -> ByteString -> KeyPackage
KeyPackage
      (RawMLS KeyPackageTBS -> ByteString -> KeyPackage)
-> Get (RawMLS KeyPackageTBS) -> Get (ByteString -> KeyPackage)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get KeyPackageTBS -> Get (RawMLS KeyPackageTBS)
forall a. Get a -> Get (RawMLS a)
parseRawMLS Get KeyPackageTBS
forall a. ParseMLS a => Get a
parseMLS
      Get (ByteString -> KeyPackage) -> Get ByteString -> Get KeyPackage
forall a b. Get (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall w. (Binary w, Integral w) => Get ByteString
parseMLSBytes @VarInt

instance SerialiseMLS KeyPackage where
  serialiseMLS :: KeyPackage -> Put
serialiseMLS KeyPackage
kp = do
    RawMLS KeyPackageTBS -> Put
forall a. SerialiseMLS a => a -> Put
serialiseMLS KeyPackage
kp.tbs
    forall w. (Binary w, Integral w) => ByteString -> Put
serialiseMLSBytes @VarInt KeyPackage
kp.signature_