nl::Weave::Platform::Security

Cet espace de noms inclut toutes les interfaces de Weave pour le gestionnaire de mémoire Security Monitor de Weave.

Résumé

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

Énumérations
BlockSetParamFields{
  kBlockSetSizeMask = 0x07,
  kBlockSetSizeShift = 0,
  kBlockSetSizeValueShift = 7,
  kBlockSetCountMask = 0x18,
  kBlockSetCountShift = 3,
  kBlockSetBufferIndexMask = 0x60,
  kBlockSetBufferIndexShift = 5,
  kBlockSetIsLongTermMask = 0x80,
  kBlockSetIsLongTermShift = 7
} 		énum
Emplacement des champs de paramètres du jeu de blocs sous forme encodée 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
} 		énum
Définit les paramètres de l'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 l'ensemble 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]
Paramètres des ensembles de blocs encodés.
sBufferAllocationMask = { kNetworkBuffer0BlockAllocationMask, kNetworkBuffer1BlockAllocationMask, }[kNumberOfNetworkBuffers]
const BlockMark_t
Ensemble de masques de bloc de 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 les tampons réseau sont utilisés (vrai) ou non (faux) par Simple Allocator.

Fonctions
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 "size" 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 "size" 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 cryptographique chronophage vient de se terminer.
OnTimeConsumingCryptoStart(void)
void
Cette fonction est appelée pour avertir l'application lorsqu'une opération cryptographique 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 du jeu de blocs sous forme encodée 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 comptage.

kBlockSetCountShift

Décalage du champ de comptage.

kBlockSetIsLongTermMask

Masque de champ de type.

kBlockSetIsLongTermShift

Changement de champ de type

kBlockSetSizeMask

Masque de champ de taille.

kBlockSetSizeShift

Décalage du champ de taille.

kBlockSetSizeValueShift

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

BlockSetParams

 BlockSetParams

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

Propriétés
kBlockSet1BufferIndex

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

kBlockSet1Count

Le nombre de blocs n° 1 est égal à 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'ensemble d'index de tampon 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'ensemble d'index de tampon 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'ensemble d'index de tampon n° 4 est 1.

kBlockSet4Count

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

kBlockSet4Size

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

kBlockSet4isLongTerm

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

kMaxBlockSize

Taille de bloc maximale acceptée par Simple Allocator.

kMinBufferSize

Taille minimale du tampon réseau requise pour prendre en charge les cas d'utilisation Simple Allocator.

Ce paramètre est dérivé des tailles de deux blocs de mémoire (640 + 600) alloués dans le 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 - accepte jusqu'à 8 blocs de mémoire au total uint16_t - accepte jusqu'à 16 blocs de mémoire au total uint32_t - accepte jusqu'à 32 blocs de mémoire au total

BlockSetParams_t

uint8_t BlockSetParams_t

Ce type est utilisé pour encoder les informations sur l'ensemble de blocs.

Un ensemble de blocs est un groupe de blocs de mémoire ayant les mêmes propriétés (taille, type et appartenant au même tampon). Le schéma ci-dessous présente la manière dont les informations du jeu de blocs sont encodées au format 8 bits:

Est à long terme Bloquer l'index Nombre de blocages 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 selon 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 du tampon dédié 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),







}

Paramètres des ensembles de blocs encodés.

sBufferAllocationMask

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




                                                                                       }

Ensemble de masques de bloc de tampon.

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

sMemBlocksAllocated

BlockMark_t sMemBlocksAllocated = 0

Indique quel bloc est alloué/non alloué.

Initialisé à 0 : signifie que tous les blocs de mémoire sont présents 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, sMemBufs[] pointe 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 les tampons réseau sont utilisés (vrai) ou non (faux) par Simple Allocator.

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

Fonctions

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 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 (en octets) des données aléatoires demandées.
Valeurs renvoyées
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
En cas de 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 la source de données aléatoire n'est requise.

Détails
Paramètres
[in] entropyFunct
Pointeur visant une fonction qui génère une entropie pour le générateur de données aléatoires. Lorsque l'algorithme n'exige pas d'entrée d'entropie, 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 qui doit être générée par la fonction d'entropie lorsqu'elle est utilisée.
[in] personalizationData
Pointeur vers un tampon de mémoire qui stocke les données de personnalisation saisies. Ces données d'entrée doivent être spécifiques à chaque appareil et permettent d'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 renvoyées
WEAVE_ERROR_INVALID_ARGUMENT
Si un argument non valide a été transmis à cette fonction.
WEAVE_NO_ERROR
En cas de 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 "size" octets.

Cette fonction est équivalente à MemoryAlloc(size, false).

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

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 "size" 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 de la mémoire qui doit rester allouée jusqu'à la fin d'une session ou d'un handshake sécurisé. Les blocs alloués aux objets CASE/PASE et leurs données de contexte sont 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 dont la mémoire est limitée. L'utilisation de ce paramètre est arbitraire et dépend de l'outil d'implémentation des fonctions. Par exemple, ce paramètre est ignoré lorsque malloc() de la bibliothèque standard C est utilisé.
Valeurs renvoyées
Pointer
à un bloc de mémoire en cas de réussite.
NULL-pointer
si l'allocation de mémoire échoue.

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 vers un bloc de mémoire qui doit être libéré.

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é, qui doit être utilisé comme pool de mémoire pour l'allocation de mémoire du gestionnaire de sécurité Security Weave. 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ée. Cette entrée est facultative (0 par défaut) et ne doit pas être utilisée si aucun tampon de mémoire dédié n'est 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 prendre en charge les cas d'utilisation de Weave Security Manager.
Valeurs renvoyées
WEAVE_ERROR_BUFFER_TOO_SMALL
Si la taille du tampon d'entrée dédié n'est pas suffisante pour les cas d'utilisation de Weave Security Manager.
WEAVE_NO_ERROR
En cas de réussite.
other
Erreur générée par la fonction d'initialisation de la 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 par exemple le cas 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 cryptographique chronophage vient de se terminer.

OnTimeConsumingCryptoStart

void OnTimeConsumingCryptoStart(
  void
)

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