nl::Weave::Platform::Security

Esse namespace inclui todas as interfaces do Weave para o gerenciador de memória do Weave Security Monitor.

Resumo

As funções neste namespace devem ser implementadas por plataformas que usam o Weave, de acordo com as necessidades/restrições do ambiente específico.

Enumerações
BlockSetParamFields{
  kBlockSetSizeMask = 0x07,
  kBlockSetSizeShift = 0,
  kBlockSetSizeValueShift = 7,
  kBlockSetCountMask = 0x18,
  kBlockSetCountShift = 3,
  kBlockSetBufferIndexMask = 0x60,
  kBlockSetBufferIndexShift = 5,
  kBlockSetIsLongTermMask = 0x80,
  kBlockSetIsLongTermShift = 7
} 		enum
Local dos campos de parâmetro dos conjuntos de blocos em um formato codificado de 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
Define parâmetros do conjunto de blocos.

Typedefs
BlockMark_t typedef
uint8_t
O tipo usado para marcar qual bloco está alocado ou não alocado no momento.
BlockSetParams_t typedef
uint8_t
Esse tipo é usado para codificar informações do conjunto de blocos.

Variáveis
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]
Parâmetros de conjuntos de blocos codificados.
sBufferAllocationMask = { kNetworkBuffer0BlockAllocationMask, kNetworkBuffer1BlockAllocationMask, }[kNumberOfNetworkBuffers]
const BlockMark_t
Conjunto de máscaras de bloco de buffer.
sMemBlocksAllocated = 0
Indica qual bloco está alocado ou não.
sMemBufs = { NULL }[kNumberOfNetworkBuffers]
void *
Ponteiros para buffers de memória inicializados como NULL.
sNetworkBuffersUsed = true
bool
Um booleano que indica se (verdadeiro) ou não (falso) os buffers de rede são usados pelo Allocator simples.

remotas
DecodeBlockSetParams(BlockSetParams_t blockSetParams, uint16_t & blockSize, uint8_t & blockCount, uint8_t & blockBufferIndex, bool & blockIsLongTerm)
void
GetSecureRandomData(uint8_t *buf, uint16_t len)
Essa função é chamada pela camada Weave para gerar dados aleatórios.
InitSecureRandomDataSource(nl::Weave::Crypto::EntropyFunct entropyFunct, uint16_t entropyLen, const uint8_t *personalizationData, uint16_t perDataLen)
Essa função é chamada pela camada Weave para inicializar uma fonte de dados aleatória.
MemoryAlloc(size_t size)
void *
Essa função é chamada pela camada Weave para alocar um bloco de memória de bytes de "tamanho".
MemoryAlloc(size_t size, bool isLongTermAlloc)
void *
Essa função é chamada pela camada Weave para alocar um bloco de memória de bytes de "tamanho".
MemoryFree(void *p)
void
Essa função é chamada pela camada Weave para liberar um bloco de memória alocado pela função MemeoryAlloc().
MemoryInit(void *buf, size_t bufSize)
Essa função é chamada pela camada Weave para inicializar a memória e os recursos necessários para a funcionalidade adequada do alocador de memória do Weave Security Manager.
MemoryShutdown(void)
void
Essa função é chamada pela camada Weave para liberar todos os recursos alocados pela função MemoryInit().
OnTimeConsumingCryptoDone(void)
void
Essa função é chamada para notificar o aplicativo quando uma operação criptográfica demorada é concluída.
OnTimeConsumingCryptoStart(void)
void
Essa função é chamada para notificar o aplicativo quando uma operação criptográfica demorada está prestes a ser iniciada.

Aulas
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

Enumerações

BlockSetParamFields

 BlockSetParamFields

Local dos campos de parâmetro dos conjuntos de blocos em um formato codificado de 8 bits.

Propriedades
kBlockSetBufferIndexMask

Máscara de campo de índice de buffer.

kBlockSetBufferIndexShift

Shift do campo de índice de buffer.

kBlockSetCountMask

Máscara de campo de contagem.

kBlockSetCountShift

Deslocamento do campo de contagem.

kBlockSetIsLongTermMask

Tipo de máscara de campo.

kBlockSetIsLongTermShift

Digite Shift do campo.

kBlockSetSizeMask

Máscara de campo de tamanho.

kBlockSetSizeShift

Mudança no campo de tamanho.

kBlockSetSizeValueShift

Mudança na decodificação do campo de tamanho (multiplique por 128).

BlockSetParams

 BlockSetParams

Define parâmetros do conjunto de blocos.

Propriedades
kBlockSet1BufferIndex

O índice de buffer 1 definido é 0.

kBlockSet1Count

O número 1 da contagem de blocos definido é 1.

kBlockSet1Size

O tamanho do conjunto 1 é 128 bytes.

kBlockSet1isLongTerm

O tipo definido 1 é de longo prazo.

kBlockSet2BufferIndex

O índice de buffer definido no 2 é 0.

kBlockSet2Count

O número 2 para contagem de blocos é 1.

kBlockSet2Size

O tamanho do conjunto 2 é 512 bytes.

kBlockSet2isLongTerm

O tipo de conjunto no 2 é de longo prazo.

kBlockSet3BufferIndex

O índice de buffer definido no 3 é 0.

kBlockSet3Count

O número 3 para a contagem de blocos é 1.

kBlockSet3Size

O tamanho do conjunto 3 é 512 bytes.

kBlockSet3isLongTerm

O tipo definido 3 é de curto prazo.

kBlockSet4BufferIndex

O índice de buffer 4 definido é 1.

kBlockSet4Count

O número 4 para a contagem de blocos é 2.

kBlockSet4Size

O tamanho do conjunto 4 é 640 bytes.

kBlockSet4isLongTerm

O tipo definido 4 é de curto prazo.

kMaxBlockSize

Tamanho máximo de bloco com suporte no Simple Allocator.

kMinBufferSize

Tamanho mínimo do buffer de rede necessário para oferecer suporte aos casos de uso do Simple Allocator.

Esse parâmetro é derivado dos tamanhos de dois blocos de memória (640 + 600) alocados no buffer de rede no 1.

kNetworkBuffer0BlockAllocationMask

Essa máscara identifica todos os blocos de memória alocados do buffer de rede 0.

kNetworkBuffer1BlockAllocationMask

Essa máscara identifica todos os blocos de memória alocados do buffer de rede 1.

kNumberOfBlockSets

Número de conjuntos de blocos usados pelo Simple Allocator.

kNumberOfNetworkBuffers

Número de buffers de rede usados pelo Simple Allocator.

kTotalMemorySize

Memória total usada pelo Alocador Simples.

Typedefs

BlockMark_t

uint8_t BlockMark_t

O tipo usado para marcar qual bloco está alocado ou não alocado no momento.

uint8_t: compatível com até 8 blocos de memória no total uint16_t; compatível com até 16 blocos de memória no total uint32_t; compatível com até 32 blocos de memória no total

BlockSetParams_t

uint8_t BlockSetParams_t

Esse tipo é usado para codificar informações do conjunto de blocos.

Um conjunto de blocos é um grupo de blocos de memória que têm as mesmas propriedades (tamanho, tipo e pertencem ao mesmo buffer). O diagrama abaixo apresenta como as informações do conjunto de blocos codificadas em um formato de 8 bits:

É de longo prazo Índice de blocos Número de blocos Tamanho do bloco
[7] [6:5] [4:3] [2:0]
[2:0] - Tamanho do bloco de memória em um conjunto. O valor de tamanho é codificado com granularidade de 128 bytes.
[2:0] Decodificação
000 0 byte
001 128 bytes
010 256 bytes
... -
111 896 bytes
[4:3] - Número de blocos em um conjunto.
[4:3] Decodificação
00 4 blocos
01 1 bloco
10 2 blocos
11 3 blocos
[6:5] - Índice do buffer de rede onde residem os blocos de memória. Quando o buffer dedicado é usado, todos os blocos de memória são alocados do buffer dedicado e esse parâmetro de índice é ignorado.
[6:5] Decodificação
00 Buffer de rede 0
... -
11 Buffer de rede 3
[7] - Especifica se os blocos são para armazenamento de longo/curto prazo.
[7] Decodificação
0 Blocos de memória de curto prazo
1 Bloqueios de memória de longo prazo

Variáveis

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),







}

Parâmetros de conjuntos de blocos codificados.

sBufferAllocationMask

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




                                                                                       }

Conjunto de máscaras de bloco de buffer.

Identifica se todos os blocos estão no buffer e não estão alocados e, em seguida, é possível aliviar o buffer.

sMemBlocksAllocated

BlockMark_t sMemBlocksAllocated = 0

Indica qual bloco está alocado ou não.

Inicializado como 0, significa que toda a memória é bloqueada e não está alocada.

sMemBufs

void * sMemBufs[kNumberOfNetworkBuffers] = { NULL }

Ponteiros para buffers de memória inicializados como NULL.

Quando buffers de rede são usados ponto sMemBufs[] para os objetos PackageBuffer. Quando um buffer dedicado é usado, sMemBufs[0] aponta para esse buffer e outros ponteiros sMemBufs[] são ignorados.

sNetworkBuffersUsed

bool sNetworkBuffersUsed = true

Um booleano que indica se (verdadeiro) ou não (falso) os buffers de rede são usados pelo Allocator simples.

Quando falso, o buffer dedicado fornecido com a função MemoryInit() é usado.

remotas

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
)

Essa função é chamada pela camada Weave para gerar dados aleatórios.

Detalhes
Parâmetros
[in] buf
Ponteiro para um buffer de memória, em que os dados aleatórios solicitados devem ser armazenados.
[in] len
Especifica o tamanho dos dados aleatórios solicitados em bytes.
Valores de retorno
WEAVE_ERROR_DRBG_ENTROPY_SOURCE_FAILED
Se a fonte de entropia não gerar a entropia solicitada pelo gerador de dados aleatórios.
WEAVE_ERROR_RANDOM_DATA_UNAVAILABLE
Se a fonte de dados aleatória não gerar dados aleatórios,
WEAVE_ERROR_INCORRECT_STATE
Se uma fonte de dados aleatória for encontrada em um estado incorreto.
WEAVE_NO_ERROR
Se der certo.

InitSecureRandomDataSource

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

Essa função é chamada pela camada Weave para inicializar uma fonte de dados aleatória.

Essa função é específica da plataforma e pode ficar vazia quando a inicialização de uma fonte de dados aleatória não é necessária.

Detalhes
Parâmetros
[in] entropyFunct
Ponteiro para uma função que gera entropia para o gerador de dados aleatórios. Quando a entrada de entropia não é exigida pelo algoritmo, ela pode ser NULL, que é o caso quando a versão OpenSSL do gerador de dados aleatórios é usada.
[in] entropyLen
Especifica o tamanho da entropia em bytes que será gerado pela função de entropia quando for usada.
[in] personalizationData
Ponteiro para um buffer de memória que armazena a entrada de dados de personalização. Essa entrada de dados deve ser específica ao dispositivo e ajuda a melhorar as propriedades estatísticas dos dados aleatórios.
[in] perDataLen
Especifica o tamanho dos dados de personalização em bytes.
Valores de retorno
WEAVE_ERROR_INVALID_ARGUMENT
Se um argumento inválido foi passado para essa função.
WEAVE_NO_ERROR
Se der certo.

MemoryAlloc

void * MemoryAlloc(
  size_t size
)

Essa função é chamada pela camada Weave para alocar um bloco de memória de bytes de "tamanho".

Essa função é equivalente a MemoryAlloc(size, false).

Detalhes
Parâmetros
[in] size
Especifica o tamanho da memória solicitada em bytes.
Valores de retorno
Pointer
a um bloco de memória em caso de êxito.
NULL-pointer
se a alocação de memória falhar.

MemoryAlloc

void * MemoryAlloc(
  size_t size,
  bool isLongTermAlloc
)

Essa função é chamada pela camada Weave para alocar um bloco de memória de bytes de "tamanho".

Detalhes
Parâmetros
[in] size
Especifica o tamanho da memória solicitada em bytes.
[in] isLongTermAlloc
Um booleano que indica se (verdadeiro) ou não (falso) o bloco de memória solicitado é para uso de longo prazo. Uma alocação de longo prazo é a memória que precisa permanecer alocada até que a sessão segura/o handshake seja concluído. Exemplos de uma alocação de longo prazo incluem blocos alocados para objetos CASE/PASE e seus dados de contexto. Uma alocação de curto prazo é uma memória necessária para realizar uma operação específica e que pode ser liberada imediatamente depois disso. Essa entrada ajuda a otimizar a utilização da memória em um sistema com limitação. O uso desse parâmetro é arbitrário e depende do implementador da função. Por exemplo, esse parâmetro é ignorado quando a biblioteca C Standard Malloc() é usada.
Valores de retorno
Pointer
a um bloco de memória em caso de êxito.
NULL-pointer
se a alocação de memória falhar.

MemoryFree

void MemoryFree(
  void *p
)

Essa função é chamada pela camada Weave para liberar um bloco de memória alocado pela função MemeoryAlloc().

Detalhes
Parâmetros
[in] p
Ponteiro para um bloco de memória que precisa ser liberado.

MemoryInit

WEAVE_ERROR MemoryInit(
  void *buf,
  size_t bufSize
)

Essa função é chamada pela camada Weave para inicializar a memória e os recursos necessários para a funcionalidade adequada do alocador de memória do Weave Security Manager.

Essa função é específica da plataforma e pode ficar vazia em alguns casos. Por exemplo, essa função não faz nada quando as funções Malloc() e free() da Biblioteca C padrão são usadas para alocação de memória.

Detalhes
Parâmetros
[in] buf
Um ponteiro para um buffer de memória dedicado, que deve ser usado como um pool de memória para a alocação de memória do gerenciador de segurança do Weave. Essa entrada é opcional (o padrão é NULL) e não deve ser usada se um buffer de memória dedicado não for usado.
[in] bufSize
Tamanho de um buffer de memória dedicado. Essa entrada é opcional (o padrão é 0) e não deve ser usada se o buffer de memória dedicado não for usado. Quando um buffer de memória dedicado é usado, a função verifica e gera um erro se o tamanho do buffer não é grande o suficiente para os casos de uso do Gerenciador de segurança do Weave.
Valores de retorno
WEAVE_ERROR_BUFFER_TOO_SMALL
Se o tamanho do buffer de entrada dedicado não for suficiente para os casos de uso do Security Manager do Weave.
WEAVE_NO_ERROR
Se der certo.
other
Erro gerado pela função de inicialização de memória específica da plataforma.

MemoryShutdown

void MemoryShutdown(
  void
)

Essa função é chamada pela camada Weave para liberar todos os recursos alocados pela função MemoryInit().

Essa função pode ser uma chamada vazia se não for necessário liberar recursos. Por exemplo, esse é o caso quando as funções Malloc() e free() da Biblioteca C padrão são usadas para alocação de memória.

OnTimeConsumingCryptoDone

void OnTimeConsumingCryptoDone(
  void
)

Essa função é chamada para notificar o aplicativo quando uma operação criptográfica demorada é concluída.

OnTimeConsumingCryptoStart

void OnTimeConsumingCryptoStart(
  void
)

Essa função é chamada para notificar o aplicativo quando uma operação criptográfica demorada está prestes a ser iniciada.