nl::Weave::Platform::Security

Cet espace de noms inclut toutes les interfaces de Weave pour le gestionnaire de mémoire du moniteur de sécurité Weave.

Résumé

Les fonctions de cet espace de noms doivent être implémentées par des plates-formes qui utilisent Weave, en fonction des besoins/contraintes de l'environnement concerné.

Énumérations
BlockSetParamFields{
  kBlockSetSizeMask = 0x07,
  kBlockSetSizeShift = 0,
  kBlockSetSizeValueShift = 7,
  kBlockSetCountMask = 0x18,
  kBlockSetCountShift = 3,
  kBlockSetBufferIndexMask = 0x60,
  kBlockSetBufferIndexShift = 5,
  kBlockSetIsLongTermMask = 0x80,
  kBlockSetIsLongTermShift = 7
} 		enum
Emplacement des champs de paramètres de l'ensemble de blocs dans un format encodé sur 8 bits.
BlockSetParams{
  kNumberOfNetworkBuffers = 2,
  kNumberOfBlockSets = 4,
  kNetworkBuffer0BlockAllocationMask = 0x07,
  kNetworkBuffer1BlockAllocationMask = 0x18,
  kBlockSet1Size = 1,
  kBlockSet1Count = 1,
  kBlockSet1BufferIndex = 0,
  kBlockSet1isLongTerm = 1,
  kBlockSet2Size = 4,
  kBlockSet2Count = 1,
  kBlockSet2BufferIndex = 0,
  kBlockSet2isLongTerm = 1,
  kBlockSet3Size = 4,
  kBlockSet3Count = 1,
  kBlockSet3BufferIndex = 0,
  kBlockSet3isLongTerm = 0,
  kBlockSet4Size = 5,
  kBlockSet4Count = 2,
  kBlockSet4BufferIndex = 1,
  kBlockSet4isLongTerm = 0,
  kTotalMemorySize = (kBlockSet1Size * kBlockSet1Count + kBlockSet2Size * kBlockSet2Count + kBlockSet3Size * kBlockSet3Count + kBlockSet4Size * kBlockSet4Count) << kBlockSetSizeValueShift,
  kMaxBlockSize = 600,
  kMinBufferSize = 1240
} 		enum
Définit les paramètres d'un ensemble de blocs.

Typedefs
BlockMark_t typedef
uint8_t
Type utilisé pour indiquer quel bloc est actuellement alloué/non alloué.
BlockSetParams_t typedef
uint8_t
Ce type est utilisé pour encoder les informations sur les ensembles de blocs.

Variables
sBlockSetParams = { ((kBlockSet1Size << kBlockSetSizeShift) & kBlockSetSizeMask) | ((kBlockSet1Count << kBlockSetCountShift) & kBlockSetCountMask) | ((kBlockSet1BufferIndex << kBlockSetBufferIndexShift) & kBlockSetBufferIndexMask) | ((kBlockSet1isLongTerm << kBlockSetIsLongTermShift) & kBlockSetIsLongTermMask), ((kBlockSet2Size << kBlockSetSizeShift) & kBlockSetSizeMask) | ((kBlockSet2Count << kBlockSetCountShift) & kBlockSetCountMask) | ((kBlockSet2BufferIndex << kBlockSetBufferIndexShift) & kBlockSetBufferIndexMask) | ((kBlockSet2isLongTerm << kBlockSetIsLongTermShift) & kBlockSetIsLongTermMask), ((kBlockSet3Size << kBlockSetSizeShift) & kBlockSetSizeMask) | ((kBlockSet3Count << kBlockSetCountShift) & kBlockSetCountMask) | ((kBlockSet3BufferIndex << kBlockSetBufferIndexShift) & kBlockSetBufferIndexMask) | ((kBlockSet3isLongTerm << kBlockSetIsLongTermShift) & kBlockSetIsLongTermMask), ((kBlockSet4Size << kBlockSetSizeShift) & kBlockSetSizeMask) | ((kBlockSet4Count << kBlockSetCountShift) & kBlockSetCountMask) | ((kBlockSet4BufferIndex << kBlockSetBufferIndexShift) & kBlockSetBufferIndexMask) | ((kBlockSet4isLongTerm << kBlockSetIsLongTermShift) & kBlockSetIsLongTermMask), }[kNumberOfBlockSets]
Le bloc encodé définit les paramètres.
sBufferAllocationMask = { kNetworkBuffer0BlockAllocationMask, kNetworkBuffer1BlockAllocationMask, }[kNumberOfNetworkBuffers]
const BlockMark_t
Ensemble de masques de bloc de mémoire tampon
sMemBlocksAllocated = 0
Indique quel bloc est alloué/non alloué.
sMemBufs = { NULL }[kNumberOfNetworkBuffers]
void *
Pointeurs vers des tampons de mémoire initialisés sur NULL.
sNetworkBuffersUsed = true
bool
Booléen indiquant si (true) ou non (false) les tampons réseau sont utilisés par Simple Allocator.

distantes
DecodeBlockSetParams(BlockSetParams_t blockSetParams, uint16_t & blockSize, uint8_t & blockCount, uint8_t & blockBufferIndex, bool & blockIsLongTerm)
void
GetSecureRandomData(uint8_t *buf, uint16_t len)
Cette fonction est appelée par la couche Weave pour générer des données aléatoires.
InitSecureRandomDataSource(nl::Weave::Crypto::EntropyFunct entropyFunct, uint16_t entropyLen, const uint8_t *personalizationData, uint16_t perDataLen)
Cette fonction est appelée par la couche Weave pour initialiser la source de données aléatoire.
MemoryAlloc(size_t size)
void *
Cette fonction est appelée par la couche Weave pour allouer un bloc de mémoire de "taille" octets.
MemoryAlloc(size_t size, bool isLongTermAlloc)
void *
Cette fonction est appelée par la couche Weave pour allouer un bloc de mémoire de "taille" octets.
MemoryFree(void *p)
void
Cette fonction est appelée par la couche Weave pour libérer un bloc de mémoire alloué par la fonction MemeoryAlloc().
MemoryInit(void *buf, size_t bufSize)
Cette fonction est appelée par la couche Weave pour initialiser la mémoire et les ressources nécessaires au bon fonctionnement de l'outil d'allocation de mémoire Security Manager de Weave.
MemoryShutdown(void)
void
Cette fonction est appelée par la couche Weave pour libérer toutes les ressources allouées par la fonction MemoryInit().
OnTimeConsumingCryptoDone(void)
void
Cette fonction est appelée pour avertir l'application lorsqu'une opération de chiffrement chronophage vient de se terminer.
OnTimeConsumingCryptoStart(void)
void
Cette fonction est appelée pour avertir l'application lorsqu'une opération de chiffrement chronophage est sur le point de démarrer.

Classes
nl::Weave::Platform::Security::AES128BlockCipher
nl::Weave::Platform::Security::AES128BlockCipherDec
nl::Weave::Platform::Security::AES128BlockCipherEnc
nl::Weave::Platform::Security::AES256BlockCipher
nl::Weave::Platform::Security::AES256BlockCipherDec
nl::Weave::Platform::Security::AES256BlockCipherEnc
nl::Weave::Platform::Security::SHA1
nl::Weave::Platform::Security::SHA256

Énumérations

BlockSetParamFields

 BlockSetParamFields

Emplacement des champs de paramètres de l'ensemble de blocs dans un format encodé sur 8 bits.

Propriétés
kBlockSetBufferIndexMask

Masque de champ d'index de tampon.

kBlockSetBufferIndexShift

Décalage du champ d'index de tampon.

kBlockSetCountMask

Masque de champ de nombre.

kBlockSetCountShift

Décalage du champ de nombre.

kBlockSetIsLongTermMask

Masque de champ de type.

kBlockSetIsLongTermShift

Saisissez un décalage de champ.

kBlockSetSizeMask

Masque de champ de taille.

kBlockSetSizeShift

Décalage du champ de taille.

kBlockSetSizeValueShift

Changement de décodage du champ de taille (multiplié par 128).

BlockSetParams

 BlockSetParams

Définit les paramètres d'un ensemble de blocs.

Propriétés
kBlockSet1BufferIndex

L'index de tampon défini n° 1 est 0.

kBlockSet1Count

Le nombre de blocs de l'ensemble n° 1 est de 1.

kBlockSet1Size

La taille de l'ensemble n° 1 est de 128 octets.

kBlockSet1isLongTerm

Le type de l'ensemble n° 1 est à long terme.

kBlockSet2BufferIndex

L'index de tampon défini n° 2 est 0.

kBlockSet2Count

Le nombre de blocs de l'ensemble n° 2 est de 1.

kBlockSet2Size

La taille de l'ensemble n° 2 est de 512 octets.

kBlockSet2isLongTerm

Le type de l'ensemble n° 2 est à long terme.

kBlockSet3BufferIndex

L'index de tampon défini n° 3 est 0.

kBlockSet3Count

Le nombre de blocs de l'ensemble n° 3 est de 1.

kBlockSet3Size

La taille de l'ensemble n° 3 est de 512 octets.

kBlockSet3isLongTerm

Le type de l'ensemble n° 3 est à court terme.

kBlockSet4BufferIndex

L'index de tampon défini n° 4 est 1.

kBlockSet4Count

L'ensemble n° 4 contient 2 blocs.

kBlockSet4Size

La taille de l'ensemble n° 4 est de 640 octets.

kBlockSet4isLongTerm

Le type d'ensemble n° 4 est à court terme.

kMaxBlockSize

Taille de bloc maximale acceptée par Simple Allocator.

kMinBufferSize

Taille minimale de la mémoire tampon réseau requise pour prendre en charge les cas d'utilisation de Simple Allocator.

Ce paramètre est dérivé des tailles de deux blocs de mémoire (640 + 600) alloués au tampon réseau n° 1.

kNetworkBuffer0BlockAllocationMask

Ce masque identifie tous les blocs de mémoire alloués à partir du tampon réseau n° 0.

kNetworkBuffer1BlockAllocationMask

Ce masque identifie tous les blocs de mémoire alloués à partir du tampon réseau n° 1.

kNumberOfBlockSets

Nombre d'ensembles de blocs utilisés par Simple Allocator.

kNumberOfNetworkBuffers

Nombre de tampons réseau utilisés par Simple Allocator.

kTotalMemorySize

Mémoire totale utilisée par Simple Allocator.

Typedefs

BlockMark_t

uint8_t BlockMark_t

Type utilisé pour indiquer quel bloc est actuellement alloué/non alloué.

uint8_t - prend en charge jusqu'à 8 blocs de mémoire au total uint16_t - prend en charge jusqu'à 16 blocs de mémoire au total uint32_t - prend en charge jusqu'à 32 blocs de mémoire au total

BlockSetParams_t

uint8_t BlockSetParams_t

Ce type est utilisé pour encoder les informations sur les ensembles de blocs.

Un ensemble de blocs est un groupe de fragments de mémoire ayant les mêmes propriétés (taille, type et appartenir au même tampon). Le schéma ci-dessous présente comment les informations d'ensemble de blocs sont encodées au format 8 bits:

Est à long terme Bloquer l'index Nombre de blocs Taille du bloc
[7] [6:5] [4:3] [2:0]
[2:0] : taille du bloc de mémoire dans un ensemble. La valeur de taille est encodée avec une précision de 128 octets.
[2:0] Décodage
000 0 octet
001 128 octets
010 256 octets
... -
111 896 octets
[4:3] : nombre de blocs dans un ensemble.
[4:3] Décodage
00 4 blocs
01 1 bloc
10 2 blocs
11 3 blocs
[6:5] : index de tampon réseau où résident les blocs de mémoire. Notez que lorsqu'un tampon dédié est utilisé, tous les blocs de mémoire sont alloués à partir de ce tampon, et ce paramètre d'index est ignoré.
[6:5] Décodage
00 Tampon réseau n° 0
... -
11 Tampon réseau n° 3
[7] : spécifie si les blocs sont destinés au stockage à long/court terme.
[7] Décodage
0 Blocs de mémoire à court terme
1 Blocs de mémoire à long terme

Variables

sBlockSetParams

const BlockSetParams_t sBlockSetParams[kNumberOfBlockSets] = {
    
    ((kBlockSet1Size << kBlockSetSizeShift) & kBlockSetSizeMask) | 
    ((kBlockSet1Count << kBlockSetCountShift) & kBlockSetCountMask) | 
    ((kBlockSet1BufferIndex << kBlockSetBufferIndexShift) & kBlockSetBufferIndexMask) | 
    ((kBlockSet1isLongTerm << kBlockSetIsLongTermShift) & kBlockSetIsLongTermMask),
    
    ((kBlockSet2Size << kBlockSetSizeShift) & kBlockSetSizeMask) | 
    ((kBlockSet2Count << kBlockSetCountShift) & kBlockSetCountMask) | 
    ((kBlockSet2BufferIndex << kBlockSetBufferIndexShift) & kBlockSetBufferIndexMask) | 
    ((kBlockSet2isLongTerm << kBlockSetIsLongTermShift) & kBlockSetIsLongTermMask),
    
    ((kBlockSet3Size << kBlockSetSizeShift) & kBlockSetSizeMask) | 
    ((kBlockSet3Count << kBlockSetCountShift) & kBlockSetCountMask) | 
    ((kBlockSet3BufferIndex << kBlockSetBufferIndexShift) & kBlockSetBufferIndexMask) | 
    ((kBlockSet3isLongTerm << kBlockSetIsLongTermShift) & kBlockSetIsLongTermMask),
    
    ((kBlockSet4Size << kBlockSetSizeShift) & kBlockSetSizeMask) | 
    ((kBlockSet4Count << kBlockSetCountShift) & kBlockSetCountMask) | 
    ((kBlockSet4BufferIndex << kBlockSetBufferIndexShift) & kBlockSetBufferIndexMask) | 
    ((kBlockSet4isLongTerm << kBlockSetIsLongTermShift) & kBlockSetIsLongTermMask),







}

Le bloc encodé définit les paramètres.

sBufferAllocationMask

const BlockMark_t sBufferAllocationMask[kNumberOfNetworkBuffers] = {
                                                   kNetworkBuffer0BlockAllocationMask,
                                                   kNetworkBuffer1BlockAllocationMask,




                                                                                       }

Ensemble de masques de bloc de mémoire tampon

Détermine si tous les blocs du tampon et non alloués, le tampon peut être libéré.

sMemBlocksAllocated

BlockMark_t sMemBlocksAllocated = 0

Indique quel bloc est alloué/non alloué.

Initialisé sur 0, tous les blocs de mémoire et non alloués

sMemBufs

void * sMemBufs[kNumberOfNetworkBuffers] = { NULL }

Pointeurs vers des tampons de mémoire initialisés sur NULL.

En cas d'utilisation de tampons réseau, les sMemBufs[] pointent vers les objets PacketBuffer. Lorsqu'un tampon dédié est utilisé, sMemBufs[0] pointe vers ce tampon et les autres pointeurs sMemBufs[] sont ignorés.

sNetworkBuffersUsed

bool sNetworkBuffersUsed = true

Booléen indiquant si (true) ou non (false) les tampons réseau sont utilisés par Simple Allocator.

Si la valeur est "false", un tampon dédié fourni avec la fonction MemoryInit() est utilisé.

distantes

DecodeBlockSetParams

void DecodeBlockSetParams(
  BlockSetParams_t blockSetParams,
  uint16_t & blockSize,
  uint8_t & blockCount,
  uint8_t & blockBufferIndex,
  bool & blockIsLongTerm
)

GetSecureRandomData

WEAVE_ERROR GetSecureRandomData(
  uint8_t *buf,
  uint16_t len
)

Cette fonction est appelée par la couche Weave pour générer des données aléatoires.

Détails
Paramètres
[in] buf
Pointeur pointant vers un tampon de mémoire, dans lequel les données aléatoires demandées doivent être stockées.
[in] len
Spécifie la taille des données aléatoires demandée en octets.
Valeurs de retour
WEAVE_ERROR_DRBG_ENTROPY_SOURCE_FAILED
Si la source d'entropie ne parvient pas à générer l'entropie demandée par le générateur de données aléatoires.
WEAVE_ERROR_RANDOM_DATA_UNAVAILABLE
Si une source de données aléatoire ne parvient pas à générer des données aléatoires.
WEAVE_ERROR_INCORRECT_STATE
Si une source de données aléatoire est détectée dans un état incorrect.
WEAVE_NO_ERROR
Pour la réussite.

InitSecureRandomDataSource

WEAVE_ERROR InitSecureRandomDataSource(
  nl::Weave::Crypto::EntropyFunct entropyFunct,
  uint16_t entropyLen,
  const uint8_t *personalizationData,
  uint16_t perDataLen
)

Cette fonction est appelée par la couche Weave pour initialiser la source de données aléatoire.

Cette fonction est spécifique à la plate-forme et peut être vide si aucune initialisation de source de données aléatoire n'est requise.

Détails
Paramètres
[in] entropyFunct
Pointeur visant une fonction qui génère de l'entropie pour le générateur de données aléatoires. Lorsqu'une entrée d'entropie n'est pas requise par l'algorithme, cette entrée peut être NULL, ce qui est le cas lorsque la version OpenSSL du générateur de données aléatoires est utilisée.
[in] entropyLen
Spécifie la taille d'entropie en octets devant être générée par la fonction d'entropie lorsqu'elle est utilisée.
[in] personalizationData
Pointeur pointant vers un tampon de mémoire qui stocke les données de personnalisation saisies. Ces données doivent être spécifiques à chaque appareil et contribuer à améliorer les propriétés statistiques des données aléatoires.
[in] perDataLen
Spécifie la taille des données de personnalisation en octets.
Valeurs de retour
WEAVE_ERROR_INVALID_ARGUMENT
Si un argument non valide a été transmis à cette fonction.
WEAVE_NO_ERROR
Pour la réussite.

MemoryAlloc

void * MemoryAlloc(
  size_t size
)

Cette fonction est appelée par la couche Weave pour allouer un bloc de mémoire de "taille" octets.

Cette fonction équivaut à MemoryAlloc(size, false).

Détails
Paramètres
[in] size
Spécifie la taille de mémoire demandée en octets.
Valeurs de retour
Pointer
à un bloc de mémoire en cas de réussite.
NULL-pointer
en cas d'échec de l'allocation de mémoire.

MemoryAlloc

void * MemoryAlloc(
  size_t size,
  bool isLongTermAlloc
)

Cette fonction est appelée par la couche Weave pour allouer un bloc de mémoire de "taille" octets.

Détails
Paramètres
[in] size
Spécifie la taille de mémoire demandée en octets.
[in] isLongTermAlloc
Booléen indiquant si (true) ou non (false) le bloc de mémoire demandé est destiné à une utilisation à long terme. Une allocation à long terme est une mémoire qui doit rester allouée jusqu'à la fin de la session sécurisée ou du handshake. Les blocs alloués aux objets CASE/PASE et leurs données contextuelles constituent des exemples d'allocation à long terme. Une allocation à court terme est une mémoire nécessaire pour effectuer une opération spécifique et peut être libérée immédiatement après. Cette entrée permet d'optimiser l'utilisation de la mémoire dans un système à mémoire limitée. L'utilisation de ce paramètre est arbitraire et dépend de l'outil d'implémentation de la fonction. Par exemple, ce paramètre est ignoré lorsque la fonction malloc() de la bibliothèque standard C est utilisée.
Valeurs de retour
Pointer
à un bloc de mémoire en cas de réussite.
NULL-pointer
en cas d'échec de l'allocation de mémoire.

MemoryFree

void MemoryFree(
  void *p
)

Cette fonction est appelée par la couche Weave pour libérer un bloc de mémoire alloué par la fonction MemeoryAlloc().

Détails
Paramètres
[in] p
Pointeur pointant vers un bloc de mémoire à libérer.

MemoryInit

WEAVE_ERROR MemoryInit(
  void *buf,
  size_t bufSize
)

Cette fonction est appelée par la couche Weave pour initialiser la mémoire et les ressources nécessaires au bon fonctionnement de l'outil d'allocation de mémoire Security Manager de Weave.

Cette fonction est spécifique à la plate-forme et peut être vide dans certains cas. Par exemple, cette fonction n'a aucun effet lorsque les fonctions malloc() et free() de la bibliothèque standard C sont utilisées pour l'allocation de mémoire.

Détails
Paramètres
[in] buf
Pointeur vers un tampon de mémoire dédié, à utiliser comme pool de mémoire pour l'allocation de mémoire de Weave Security Manager. Cette entrée est facultative (valeur par défaut : NULL) et ne doit pas être utilisée si aucun tampon de mémoire dédié n'est utilisé.
[in] bufSize
Taille d'un tampon de mémoire dédié. Cette entrée est facultative (valeur par défaut : 0) et ne doit pas être utilisée si un tampon de mémoire dédié n'est pas utilisé. Lorsqu'un tampon de mémoire dédié est utilisé, la fonction vérifie et génère une erreur si la taille de la mémoire tampon n'est pas suffisante pour les cas d'utilisation de Weave Security Manager.
Valeurs de retour
WEAVE_ERROR_BUFFER_TOO_SMALL
Si la taille de la mémoire tampon d'entrée dédiée n'est pas suffisante pour les cas d'utilisation de Weave Security Manager.
WEAVE_NO_ERROR
Pour la réussite.
other
Erreur générée par la fonction d'initialisation de mémoire spécifique à la plate-forme.

MemoryShutdown

void MemoryShutdown(
  void
)

Cette fonction est appelée par la couche Weave pour libérer toutes les ressources allouées par la fonction MemoryInit().

Cette fonction peut être un appel vide s'il n'est pas nécessaire de libérer des ressources. C'est le cas, par exemple, lorsque les fonctions malloc() et free() de la bibliothèque standard C sont utilisées pour l'allocation de mémoire.

OnTimeConsumingCryptoDone

void OnTimeConsumingCryptoDone(
  void
)

Cette fonction est appelée pour avertir l'application lorsqu'une opération de chiffrement chronophage vient de se terminer.

OnTimeConsumingCryptoStart

void OnTimeConsumingCryptoStart(
  void
)

Cette fonction est appelée pour avertir l'application lorsqu'une opération de chiffrement chronophage est sur le point de démarrer.