🥮 mooncakes.io
    Sign in

    moonbit-community/rtc/dtls does not have a README file

    DtlsError

    source
    pub(all) suberror DtlsError {
      InvalidRecord(String)
      InvalidHandshake(String)
      UnsupportedVersion
      UnsupportedCipherSuite(UInt16)
      UnsupportedSrtpProfile(UInt16)
      HandshakeFailed(String)
      FingerprintMismatch
      ReplayRejected
      CryptoUnavailable(String)
      Time(
    TimeError    )
      Closed
    } derive(Eq, 
    Debug    )

    AlertDescription

    source
    pub(all) enum AlertDescription {
      CloseNotify
      UnexpectedMessage
      BadRecordMac
      HandshakeFailure
      BadCertificate
      IllegalParameter
      DecodeError
      DecryptError
      ProtocolVersionAlert
      InternalError
      UnsupportedExtension
      UnknownAlert(Byte)
    } derive(Eq, 
    Debug    )

    AlertLevel

    source
    pub(all) enum AlertLevel {
      WarningAlert
      FatalAlert
    } derive(Eq, 
    Debug    )

    CertificateIdentity

    source

    CertificateIdentity::certificate_der

    source
    fn CertificateIdentity::certificate_der(self : CertificateIdentity) -> Bytes

    CertificateIdentity::fingerprint

    source

    CertificateIdentity::generate

    source

    CertificateIdentity::key_type

    source

    CertificateKeyType

    source
    pub(all) enum CertificateKeyType {
      EcdsaCertificate
      RsaCertificate
    } derive(Eq, 
    Debug    )

    CertificateMessage

    source
    pub struct CertificateMessage {
      certificates : Array[Bytes]
    } derive(Eq, 
    Debug    )

    CertificateRequestMessage

    source
    pub struct CertificateRequestMessage {
      certificate_types : Array[Byte]
      signature_algorithms : Array[UInt16]
    } derive(Eq, 
    Debug    )

    CertificateVerifyMessage

    source
    pub struct CertificateVerifyMessage {
      signature_algorithm : UInt16
      signature : Bytes
    } derive(Eq, 
    Debug    )

    CipherSuite

    source
    pub(all) enum CipherSuite {
      EcdheEcdsaAes128Ccm
      EcdheEcdsaAes128Ccm8
      EcdheEcdsaAes128GcmSha256
      EcdheRsaAes128GcmSha256
      EcdheEcdsaAes256CbcSha
      EcdheRsaAes256CbcSha
      PskAes128Ccm
      PskAes128Ccm8
      PskAes128GcmSha256
      EcdheRsaChacha20Poly1305Sha256
      EcdheEcdsaChacha20Poly1305Sha256
    } derive(Eq, 
    Debug    )

    CipherSuite::code

    source
    fn CipherSuite::code(self : CipherSuite) -> UInt16

    CipherSuite::from_code

    source
    fn CipherSuite::from_code(code : UInt16) -> CipherSuite raise DtlsError

    CipherSuite::is_psk

    source
    fn CipherSuite::is_psk(self : CipherSuite) -> Bool

    CipherSuite::maximum_record_expansion

    source
    fn CipherSuite::maximum_record_expansion(self : CipherSuite) -> Int

    CipherSuite::uses_rsa

    source
    fn CipherSuite::uses_rsa(self : CipherSuite) -> Bool

    ClientHelloMessage

    source
    pub struct ClientHelloMessage {
      random : Bytes
      session_id : Bytes
      cookie : Bytes
      cipher_suites : Array[UInt16]
      compression_methods : Array[Byte]
      extensions : HelloExtensions
    } derive(Eq, 
    Debug    )

    ClientHelloMessage::cipher_suites

    source
    fn ClientHelloMessage::cipher_suites(self : ClientHelloMessage) -> Array[UInt16]

    ClientHelloMessage::cookie

    source
    fn ClientHelloMessage::cookie(self : ClientHelloMessage) -> Bytes

    ClientHelloMessage::extensions

    source

    ClientHelloMessage::new

    source
    fn ClientHelloMessage::new(random~ : Bytes, cookie? : Bytes, cipher_suites? : Array[CipherSuite], extensions~ : HelloExtensions) -> ClientHelloMessage raise DtlsError

    ClientHelloMessage::random

    source
    fn ClientHelloMessage::random(self : ClientHelloMessage) -> Bytes

    ClientKeyExchangeMessage

    source
    pub struct ClientKeyExchangeMessage {
      public_key : Bytes
      identity_hint : Bytes?
    } derive(Eq, 
    Debug    )

    Config

    source
    pub struct Config {
      role : Role
      identity : CertificateIdentity
      expected_peer_fingerprint : Fingerprint
      wall_time : 
    WallTime
      cipher_suites : Array[CipherSuite]
      psk : Bytes?
      psk_identity : Bytes?
      srtp_profiles : Array[SrtpProtectionProfile]
      flight_interval : 
    Duration
      mtu : Int
      replay_window : Int
      verify_peer_fingerprint : Bool
    }

    Config::cipher_suites

    source
    fn Config::cipher_suites(self : Config) -> Array[CipherSuite]

    Config::local_fingerprint

    source
    fn Config::local_fingerprint(self : Config) -> Fingerprint raise DtlsError

    Config::new

    source
    fn Config::new(role~ : Role, identity~ : CertificateIdentity, expected_peer_fingerprint~ : Fingerprint, wall_time~ : 
    WallTime    , cipher_suites? : Array[CipherSuite], psk? : Bytes, psk_identity? : Bytes, srtp_profiles? : Array[SrtpProtectionProfile], flight_interval? : 
    Duration    , mtu? : Int, replay_window? : Int, verify_peer_fingerprint? : Bool) -> Config raise DtlsError

    Config::psk_identity

    source
    fn Config::psk_identity(self : Config) -> Bytes?

    Config::role

    source
    fn Config::role(self : Config) -> Role

    Config::srtp_profiles

    source
    fn Config::srtp_profiles(self : Config) -> Array[SrtpProtectionProfile]

    ContentType

    source
    pub(all) enum ContentType {
      ChangeCipherSpec
      Alert
      Handshake
      ApplicationData
    } derive(Eq, 
    Debug    )

    ContentType::code

    source
    fn ContentType::code(self : ContentType) -> Byte

    DtlsEvent

    source
    pub(all) enum DtlsEvent {
      StateChanged(State)
      ConnectedWithSrtp(SrtpProtectionProfile?)
      ApplicationDataReceived(Bytes)
      AlertReceived(AlertLevel, AlertDescription)
    } derive(Eq, 
    Debug    )

    Endpoint

    source
    pub struct Endpoint {
      config : Config
      provider : 
    Provider
      outputs : 
    Queue    [Bytes]
      events : 
    Queue    [DtlsEvent]
      state : State
      phase : HandshakePhase
      fragments : FragmentBuffer
      transcript : Array[Bytes]
      local_handshake_sequence : UInt16
      epoch_zero_sequence : UInt64
      epoch_one_sequence : UInt64
      client_random : Bytes?
      server_random : Bytes?
      initial_client_hello : Bytes?
      cookie : Bytes?
      local_ephemeral : 
    PrivateKey    ?
      peer_ephemeral : 
    PublicKey    ?
      peer_certificate_key : 
    PublicKey    ?
      master_secret : 
    Secret    ?
      cipher : RecordCipher?
      selected_cipher_suite : CipherSuite?
      selected_srtp_profile : SrtpProtectionProfile?
      certificate_requested : Bool
      client_server_stage : Int
      server_client_stage : Int
      peer_changed_cipher_spec : Bool
      last_flight : Array[Bytes]
      retransmit_deadline : 
    Instant    ?
      retransmit_interval_milliseconds : Int64
      retransmissions : Int
    }

    Endpoint::close

    source
    fn Endpoint::close(self : Endpoint) -> Unit raise DtlsError

    Endpoint::export_keying_material

    source
    fn Endpoint::export_keying_material(self : Endpoint, label : String, length : Int) -> Bytes raise DtlsError

    Endpoint::handle_datagram

    source
    fn Endpoint::handle_datagram(self : Endpoint, now : 
    Instant    , datagram : Bytes) -> Unit raise DtlsError

    Endpoint::handle_timeout

    source
    fn Endpoint::handle_timeout(self : Endpoint, now : 
    Instant    ) -> Unit raise DtlsError

    Endpoint::new

    source
    fn Endpoint::new(config : Config) -> Endpoint

    Endpoint::poll_datagram

    source
    fn Endpoint::poll_datagram(self : Endpoint) -> Bytes?

    Endpoint::poll_event

    source
    fn Endpoint::poll_event(self : Endpoint) -> DtlsEvent?

    Endpoint::poll_timeout

    source

    Endpoint::role

    source
    fn Endpoint::role(self : Endpoint) -> Role

    Endpoint::selected_cipher_suite

    source
    fn Endpoint::selected_cipher_suite(self : Endpoint) -> CipherSuite?

    Endpoint::selected_srtp_profile

    source
    fn Endpoint::selected_srtp_profile(self : Endpoint) -> SrtpProtectionProfile?

    Endpoint::send_application_data

    source
    fn Endpoint::send_application_data(self : Endpoint, payload : Bytes) -> Unit raise DtlsError

    Endpoint::start

    source

    Endpoint::state

    source
    fn Endpoint::state(self : Endpoint) -> State

    Fingerprint

    source
    pub struct Fingerprint {
      algorithm : FingerprintAlgorithm
      value : Bytes
    } derive(Eq, 
    Debug    )

    Fingerprint::algorithm

    source

    Fingerprint::new

    source
    fn Fingerprint::new(algorithm~ : FingerprintAlgorithm, value~ : Bytes) -> Fingerprint raise DtlsError

    Fingerprint::value

    source
    fn Fingerprint::value(self : Fingerprint) -> Bytes

    FingerprintAlgorithm

    source
    pub(all) enum FingerprintAlgorithm {
      Sha256
      Sha384
      Sha512
    } derive(Eq, 
    Debug    )

    FinishedMessage

    source
    pub struct FinishedMessage {
      verify_data : Bytes
    } derive(Eq, 
    Debug    )

    FragmentBuffer

    source
    type FragmentBuffer

    HandshakeFragment

    source
    pub struct HandshakeFragment {
      handshake_type : HandshakeType
      total_length : UInt
      message_sequence : UInt16
      fragment_offset : UInt
      body : Bytes
    } derive(Eq, 
    Debug    )

    HandshakeFragment::body

    source
    fn HandshakeFragment::body(self : HandshakeFragment) -> Bytes

    HandshakeFragment::encode

    source
    fn HandshakeFragment::encode(self : HandshakeFragment) -> Bytes raise DtlsError

    HandshakeFragment::fragment_offset

    source
    fn HandshakeFragment::fragment_offset(self : HandshakeFragment) -> UInt

    HandshakeFragment::handshake_type

    source
    fn HandshakeFragment::handshake_type(self : HandshakeFragment) -> HandshakeType

    HandshakeFragment::is_complete

    source
    fn HandshakeFragment::is_complete(self : HandshakeFragment) -> Bool

    HandshakeFragment::message_sequence

    source
    fn HandshakeFragment::message_sequence(self : HandshakeFragment) -> UInt16

    HandshakeFragment::new

    source
    fn HandshakeFragment::new(handshake_type~ : HandshakeType, total_length~ : UInt, message_sequence~ : UInt16, fragment_offset~ : UInt, body~ : Bytes) -> HandshakeFragment raise DtlsError

    HandshakeFragment::total_length

    source
    fn HandshakeFragment::total_length(self : HandshakeFragment) -> UInt

    HandshakeMessage

    source
    pub(all) enum HandshakeMessage {
      ClientHelloHandshake(ClientHelloMessage)
      ServerHelloHandshake(ServerHelloMessage)
      HelloVerifyRequestHandshake(HelloVerifyRequestMessage)
      CertificateHandshake(CertificateMessage)
      ServerKeyExchangeHandshake(ServerKeyExchangeMessage)
      CertificateRequestHandshake(CertificateRequestMessage)
      ServerHelloDoneHandshake
      CertificateVerifyHandshake(CertificateVerifyMessage)
      ClientKeyExchangeHandshake(ClientKeyExchangeMessage)
      FinishedHandshake(FinishedMessage)
    } derive(Eq, 
    Debug    )

    HandshakeMessage::decode

    source

    HandshakeMessage::encode_body

    source
    fn HandshakeMessage::encode_body(self : HandshakeMessage) -> Bytes raise DtlsError

    HandshakeMessage::handshake_type

    source
    fn HandshakeMessage::handshake_type(self : HandshakeMessage) -> HandshakeType

    HandshakeMessage::to_fragment

    source
    fn HandshakeMessage::to_fragment(self : HandshakeMessage, message_sequence : UInt16) -> HandshakeFragment raise DtlsError

    HandshakePhase

    source
    type HandshakePhase derive(Eq, 
    Debug    )

    HandshakeType

    source
    pub(all) enum HandshakeType {
      HelloRequest
      ClientHello
      ServerHello
      HelloVerifyRequest
      Certificate
      ServerKeyExchange
      CertificateRequest
      ServerHelloDone
      CertificateVerify
      ClientKeyExchange
      Finished
      UnknownHandshake(Byte)
    } derive(Eq, 
    Debug    )

    HandshakeType::code

    source
    fn HandshakeType::code(self : HandshakeType) -> Byte

    HelloExtensions

    source
    pub struct HelloExtensions {
      supported_groups : Array[UInt16]
      point_formats : Array[Byte]
      signature_algorithms : Array[UInt16]
      srtp_profiles : Array[UInt16]
      extended_master_secret : Bool
      renegotiation_info : Bool
      unknown : Array[(UInt16, Bytes)]
    } derive(Eq, 
    Debug    )

    HelloExtensions::signature_algorithms

    source
    fn HelloExtensions::signature_algorithms(self : HelloExtensions) -> Array[UInt16]

    HelloExtensions::srtp_profile_codes

    source
    fn HelloExtensions::srtp_profile_codes(self : HelloExtensions) -> Array[UInt16]

    HelloExtensions::supports_group

    source
    fn HelloExtensions::supports_group(self : HelloExtensions, group : UInt16) -> Bool

    HelloExtensions::uses_extended_master_secret

    source
    fn HelloExtensions::uses_extended_master_secret(self : HelloExtensions) -> Bool

    HelloExtensions::webrtc

    source

    HelloVerifyRequestMessage

    source
    pub struct HelloVerifyRequestMessage {
      cookie : Bytes
    } derive(Eq, 
    Debug    )

    ProtocolVersion

    source
    pub(all) enum ProtocolVersion {
      Dtls10
      Dtls12
    } derive(Eq, 
    Debug    )

    ProtocolVersion::major

    source
    fn ProtocolVersion::major(_self : ProtocolVersion) -> Byte

    ProtocolVersion::minor

    source
    fn ProtocolVersion::minor(self : ProtocolVersion) -> Byte

    Record

    source
    pub struct Record {
      header : RecordHeader
      payload : Bytes
    } derive(Eq, 
    Debug    )

    Record::encode

    source
    fn Record::encode(self : Record) -> Bytes raise DtlsError

    Record::header

    source
    fn Record::header(self : Record) -> RecordHeader

    Record::new

    source
    fn Record::new(content_type~ : ContentType, version? : ProtocolVersion, epoch~ : UInt16, sequence_number~ : UInt64, payload~ : Bytes) -> Record raise DtlsError

    Record::payload

    source
    fn Record::payload(self : Record) -> Bytes

    RecordCipher

    source
    type RecordCipher

    RecordHeader

    source
    pub struct RecordHeader {
      content_type : ContentType
      version : ProtocolVersion
      epoch : UInt16
      sequence_number : UInt64
      content_length : UInt16
    } derive(Eq, 
    Debug    )

    RecordHeader::content_length

    source
    fn RecordHeader::content_length(self : RecordHeader) -> UInt16

    RecordHeader::content_type

    source
    fn RecordHeader::content_type(self : RecordHeader) -> ContentType

    RecordHeader::epoch

    source
    fn RecordHeader::epoch(self : RecordHeader) -> UInt16

    RecordHeader::new

    source
    fn RecordHeader::new(content_type~ : ContentType, version? : ProtocolVersion, epoch~ : UInt16, sequence_number~ : UInt64, content_length~ : UInt16) -> RecordHeader raise DtlsError

    RecordHeader::sequence_number

    source
    fn RecordHeader::sequence_number(self : RecordHeader) -> UInt64

    RecordHeader::version

    source

    Role

    source
    pub(all) enum Role {
      Auto
      Client
      Server
    } derive(Eq, 
    Debug    )

    ServerHelloMessage

    source
    pub struct ServerHelloMessage {
      random : Bytes
      session_id : Bytes
      cipher_suite : UInt16
      compression_method : Byte
      extensions : HelloExtensions
    } derive(Eq, 
    Debug    )

    ServerHelloMessage::cipher_suite

    source
    fn ServerHelloMessage::cipher_suite(self : ServerHelloMessage) -> UInt16

    ServerHelloMessage::extensions

    source

    ServerHelloMessage::new

    source
    fn ServerHelloMessage::new(random~ : Bytes, cipher_suite? : CipherSuite, selected_srtp_profile? : UInt16) -> ServerHelloMessage raise DtlsError

    ServerHelloMessage::random

    source
    fn ServerHelloMessage::random(self : ServerHelloMessage) -> Bytes

    ServerKeyExchangeMessage

    source
    pub struct ServerKeyExchangeMessage {
      named_curve : UInt16
      public_key : Bytes
      signature_algorithm : UInt16
      signature : Bytes
      identity_hint : Bytes?
    } derive(Eq, 
    Debug    )

    SrtpProtectionProfile

    source
    pub(all) enum SrtpProtectionProfile {
      SrtpAes128CmHmacSha1_80
      SrtpAes128CmHmacSha1_32
      SrtpAeadAes128Gcm
      SrtpAeadAes256Gcm
    } derive(Eq, 
    Debug    )

    SrtpProtectionProfile::aead_aes128_gcm

    source

    SrtpProtectionProfile::aead_aes256_gcm

    source

    SrtpProtectionProfile::aes128_cm_hmac_sha1_32

    source
    fn SrtpProtectionProfile::aes128_cm_hmac_sha1_32() -> SrtpProtectionProfile

    SrtpProtectionProfile::aes128_cm_hmac_sha1_80

    source
    fn SrtpProtectionProfile::aes128_cm_hmac_sha1_80() -> SrtpProtectionProfile

    SrtpProtectionProfile::code

    source
    fn SrtpProtectionProfile::code(self : SrtpProtectionProfile) -> UInt16

    State

    source
    pub(all) enum State {
      New
      Connecting
      Connected
      Closing
      Closed
      Failed
    } derive(Eq, 
    Debug    )

    decode_handshakes

    source
    fn decode_handshakes(payload : Bytes) -> Array[HandshakeFragment] raise DtlsError

    decode_records

    source
    fn decode_records(datagram : Bytes) -> Array[Record] raise DtlsError

    encode_records

    source
    fn encode_records(records : Array[Record]) -> Bytes raise DtlsError

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io