Symbols ![]()
loading...
Files ![]()
loading...
ot::MeshCoP::SecureTransport class
Syntax
class SecureTransport : public InstanceLocator
{
public:
typedef otCoapSecureConnectEvent ConnectEvent;
static constexpr ConnectEvent kConnected = OT_COAP_SECURE_CONNECTED;
static constexpr ConnectEvent kDisconnectedPeerClosed = OT_COAP_SECURE_DISCONNECTED_PEER_CLOSED;
static constexpr ConnectEvent kDisconnectedLocalClosed = OT_COAP_SECURE_DISCONNECTED_LOCAL_CLOSED;
static constexpr ConnectEvent kDisconnectedMaxAttempts = OT_COAP_SECURE_DISCONNECTED_MAX_ATTEMPTS;
static constexpr ConnectEvent kDisconnectedError = OT_COAP_SECURE_DISCONNECTED_ERROR;
static constexpr uint8_t kPskMaxLength = 32;
typedef otHandleCoapSecureClientConnect ConnectedHandler;
explicit SecureTransport(Instance &aInstance, bool aLayerTwoSecurity, bool aDatagramTransport = true);
typedef void (*ReceiveHandler)(void *aContext, uint8_t *aBuf, uint16_t aLength);
typedef Error (*TransportCallback)(void *aContext, ot::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
typedef void (*AutoCloseCallback)(void *aContext);
Error Open(ReceiveHandler aReceiveHandler, ConnectedHandler aConnectedHandler, void *aContext);
Error SetMaxConnectionAttempts(uint16_t aMaxAttempts, AutoCloseCallback aCallback, void *aContext);
Error Bind(uint16_t aPort);
uint16_t GetUdpPort(void) const;
Error Bind(TransportCallback aCallback, void *aContext);
Error Connect(const Ip6::SockAddr &aSockAddr);
bool IsConnectionActive(void) const { return mState >= kStateConnecting; }
bool IsConnected(void) const { return mState == kStateConnected; }
bool IsClosed(void) const { return mState == kStateClosed; }
void Disconnect(void);
void Close(void);
Error SetPsk(const uint8_t *aPsk, uint8_t aPskLength);
#if OPENTHREAD_CONFIG_TLS_API_ENABLE
#ifdef MBEDTLS_KEY_EXCHANGE_PSK_ENABLED
void SetPreSharedKey(const uint8_t *aPsk, uint16_t aPskLength, const uint8_t *aPskIdentity, uint16_t aPskIdLength);
#endif
#ifdef MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED
void SetCertificate(const uint8_t *aX509Certificate,
uint32_t aX509CertLength,
const uint8_t *aPrivateKey,
uint32_t aPrivateKeyLength);
void SetCaCertificateChain(const uint8_t *aX509CaCertificateChain, uint32_t aX509CaCertChainLength);
const mbedtls_asn1_buf &GetOwnPublicKey(void) const { return mOwnCert.pk_raw; }
#endif
#if defined(MBEDTLS_BASE64_C) && defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
Error GetPeerCertificateBase64(unsigned char *aPeerCert, size_t *aCertLength, size_t aCertBufferSize);
#endif
#if defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
Error GetPeerSubjectAttributeByOid(const char *aOid,
size_t aOidLength,
uint8_t *aAttributeBuffer,
size_t *aAttributeLength,
int *aAsn1Type);
Error GetThreadAttributeFromPeerCertificate(int aThreadOidDescriptor,
uint8_t *aAttributeBuffer,
size_t *aAttributeLength);
#endif
Error GetThreadAttributeFromOwnCertificate(int aThreadOidDescriptor,
uint8_t *aAttributeBuffer,
size_t *aAttributeLength);
void SetSslAuthMode(bool aVerifyPeerCertificate) { mVerifyPeerCertificate = aVerifyPeerCertificate; }
#endif
#ifdef MBEDTLS_SSL_SRV_C
Error SetClientId(const uint8_t *aClientId, uint8_t aLength);
#endif
Error Send(Message &aMessage, uint16_t aLength);
void Receive(Message &aMessage);
void SetDefaultMessageSubType(Message::SubType aMessageSubType) { mMessageDefaultSubType = aMessageSubType; }
const Ip6::MessageInfo &GetMessageInfo(void) const { return mMessageInfo; }
void HandleReceive(Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
private:
enum State : uint8_t
{
kStateClosed,
kStateOpen,
kStateInitializing,
kStateConnecting,
kStateConnected,
kStateCloseNotify,
};
static constexpr uint32_t kGuardTimeNewConnectionMilli = 2000;
#if !OPENTHREAD_CONFIG_TLS_API_ENABLE
static constexpr uint16_t kApplicationDataMaxLength = 1152;
#else
static constexpr uint16_t kApplicationDataMaxLength = OPENTHREAD_CONFIG_DTLS_APPLICATION_DATA_MAX_LENGTH;
#endif
static constexpr size_t kSecureTransportKeyBlockSize = 40;
static constexpr size_t kSecureTransportRandomBufferSize = 32;
bool IsStateClosed(void) const { return mState == kStateClosed; }
bool IsStateOpen(void) const { return mState == kStateOpen; }
bool IsStateInitializing(void) const { return mState == kStateInitializing; }
bool IsStateConnecting(void) const { return mState == kStateConnecting; }
bool IsStateConnected(void) const { return mState == kStateConnected; }
bool IsStateCloseNotify(void) const { return mState == kStateCloseNotify; }
bool IsStateConnectingOrConnected(void) const { return mState == kStateConnecting || mState == kStateConnected; }
void SetState(State aState);
void FreeMbedtls(void);
Error Setup(bool aClient);
#if OPENTHREAD_CONFIG_TLS_API_ENABLE
int SetApplicationSecureKeys(void);
Error GetThreadAttributeFromCertificate(const mbedtls_x509_crt *aCert,
int aThreadOidDescriptor,
uint8_t *aAttributeBuffer,
size_t *aAttributeLength);
#endif
static void HandleMbedtlsDebug(void *aContext, int aLevel, const char *aFile, int aLine, const char *aStr);
void HandleMbedtlsDebug(int aLevel, const char *aFile, int aLine, const char *aStr);
static int HandleMbedtlsGetTimer(void *aContext);
int HandleMbedtlsGetTimer(void);
static void HandleMbedtlsSetTimer(void *aContext, uint32_t aIntermediate, uint32_t aFinish);
void HandleMbedtlsSetTimer(uint32_t aIntermediate, uint32_t aFinish);
static int HandleMbedtlsReceive(void *aContext, unsigned char *aBuf, size_t aLength);
int HandleMbedtlsReceive(unsigned char *aBuf, size_t aLength);
static int HandleMbedtlsTransmit(void *aContext, const unsigned char *aBuf, size_t aLength);
int HandleMbedtlsTransmit(const unsigned char *aBuf, size_t aLength);
#ifdef MBEDTLS_SSL_EXPORT_KEYS
#if (MBEDTLS_VERSION_NUMBER >= 0x03000000)
static void HandleMbedtlsExportKeys(void *aContext,
mbedtls_ssl_key_export_type aType,
const unsigned char *aMasterSecret,
size_t aMasterSecretLen,
const unsigned char aClientRandom[32],
const unsigned char aServerRandom[32],
mbedtls_tls_prf_types aTlsPrfType);
void HandleMbedtlsExportKeys(mbedtls_ssl_key_export_type aType,
const unsigned char *aMasterSecret,
size_t aMasterSecretLen,
const unsigned char aClientRandom[32],
const unsigned char aServerRandom[32],
mbedtls_tls_prf_types aTlsPrfType);
#else
static int HandleMbedtlsExportKeys(void *aContext,
const unsigned char *aMasterSecret,
const unsigned char *aKeyBlock,
size_t aMacLength,
size_t aKeyLength,
size_t aIvLength);
int HandleMbedtlsExportKeys(const unsigned char *aMasterSecret,
const unsigned char *aKeyBlock,
size_t aMacLength,
size_t aKeyLength,
size_t aIvLength);
#endif
#endif
static void HandleTimer(Timer &aTimer);
void HandleTimer(void);
void HandleReceive(const uint8_t *aBuf, uint16_t aLength);
Error HandleSecureTransportSend(const uint8_t *aBuf, uint16_t aLength, Message::SubType aMessageSubType);
void Process(void);
void Disconnect(ConnectEvent aEvent);
#if OT_SHOULD_LOG_AT(OT_LOG_LEVEL_INFO)
static const char *StateToString(State aState);
#endif
using TransportSocket = Ip6::Udp::SocketIn<SecureTransport, &SecureTransport::HandleReceive>;
State mState;
int mCipherSuites[2];
uint8_t mPsk[kPskMaxLength];
uint8_t mPskLength;
#if (MBEDTLS_VERSION_NUMBER >= 0x03010000)
static const uint16_t sGroups[];
#else
static const mbedtls_ecp_group_id sCurves[];
#endif
#if defined(MBEDTLS_KEY_EXCHANGE__WITH_CERT__ENABLED) || defined(MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED)
#if (MBEDTLS_VERSION_NUMBER >= 0x03020000)
static const uint16_t sSignatures[];
#else
static const int sHashes[];
#endif
#endif
#if OPENTHREAD_CONFIG_TLS_API_ENABLE
#ifdef MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED
const uint8_t *mCaChainSrc;
uint32_t mCaChainLength;
const uint8_t *mOwnCertSrc;
uint32_t mOwnCertLength;
const uint8_t *mPrivateKeySrc;
uint32_t mPrivateKeyLength;
mbedtls_x509_crt mCaChain;
mbedtls_x509_crt mOwnCert;
mbedtls_pk_context mPrivateKey;
#endif
#ifdef MBEDTLS_KEY_EXCHANGE_PSK_ENABLED
const uint8_t *mPreSharedKey;
const uint8_t *mPreSharedKeyIdentity;
uint16_t mPreSharedKeyLength;
uint16_t mPreSharedKeyIdLength;
#endif
#endif
bool mVerifyPeerCertificate;
mbedtls_ssl_context mSsl;
mbedtls_ssl_config mConf;
#if defined(MBEDTLS_SSL_SRV_C) && defined(MBEDTLS_SSL_COOKIE_C)
mbedtls_ssl_cookie_ctx mCookieCtx;
#endif
TimerMilliContext mTimer;
TimeMilli mTimerIntermediate;
bool mTimerSet : 1;
bool mLayerTwoSecurity : 1;
bool mDatagramTransport : 1;
uint16_t mMaxConnectionAttempts;
uint16_t mRemainingConnectionAttempts;
Callback<AutoCloseCallback> mAutoCloseCallback;
Message *mReceiveMessage;
Callback<ConnectedHandler> mConnectedCallback;
Callback<ReceiveHandler> mReceiveCallback;
void *mContext;
Ip6::MessageInfo mMessageInfo;
TransportSocket mSocket;
Callback<TransportCallback> mTransportCallback;
void *mTransportContext;
Message::SubType mMessageSubType;
Message::SubType mMessageDefaultSubType;
ConnectEvent mConnectEvent;
};
Fields
Field
Declared as
Callback<AutoCloseCallback>
Callback<ConnectedHandler>
Callback<ReceiveHandler>
TransportSocket
Callback<TransportCallback>
References
Code
Location
Scope
Referrer
Class Tree
ot::MeshCoP::SecureTransport is inherited by 1 classes:
Instances
Instance
Scope
Location
Project