O Google tem o compromisso de promover a igualdade racial para as comunidades negras. Saiba como.
Esta página foi traduzida pela API Cloud Translation.
Switch to English

nl :: Tecer:: Plataforma:: Segurança

Este namespace inclui todas as interfaces dentro 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
Localização dos campos de parâmetros do conjunto de blocos em 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 os parâmetros do conjunto de blocos.

Typedefs

BlockMark_t typedef
uint8_t
O tipo usado para marcar qual bloco está atualmente alocado / não alocado.
BlockSetParams_t typedef
uint8_t
Este 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]
Conjunto de máscaras de bloco de buffer.
sMemBlocksAllocated = 0
Indica qual bloco está alocado / não alocado.
sMemBufs = { NULL }[kNumberOfNetworkBuffers]
void *
Ponteiros para buffers de memória inicializados com NULL.
sNetworkBuffersUsed = true
bool
Um booleano que indica se (verdadeiro) ou não (falso) os buffers de rede são usados ​​pelo Simple Allocator.

Funções

DecodeBlockSetParams ( BlockSetParams_t blockSetParams, uint16_t & blockSize, uint8_t & blockCount, uint8_t & blockBufferIndex, bool & blockIsLongTerm)
void
GetSecureRandomData (uint8_t *buf, uint16_t len)
Esta 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)
Esta função é chamada pela camada Weave para inicializar a fonte de dados aleatória.
MemoryAlloc (size_t size)
void *
Esta função é chamada pela camada Weave para alocar um bloco de memória de bytes de "tamanho".
MemoryAlloc (size_t size, bool isLongTermAlloc)
void *
Esta função é chamada pela camada Weave para alocar um bloco de memória de bytes de "tamanho".
MemoryFree (void *p)
void
Esta 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 do 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
Esta função é chamada pela camada Weave para liberar todos os recursos que foram alocados pela função MemoryInit () .
OnTimeConsumingCryptoDone (void)
void
Esta função é chamada para notificar o aplicativo quando uma operação criptográfica demorada acaba de ser concluída.
OnTimeConsumingCryptoStart (void)
void
Essa função é chamada para notificar o aplicativo quando uma operação criptográfica demorada está prestes a começar.

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

Localização dos campos de parâmetros do conjunto de blocos em um formato codificado de 8 bits.

Propriedades
kBlockSetBufferIndexMask

Máscara de campo de índice de buffer.

kBlockSetBufferIndexShift

Mudança de campo de índice de buffer.

kBlockSetCountMask

Máscara de campo de contagem.

kBlockSetCountShift

Mudança de campo de contagem.

kBlockSetIsLongTermMask

Digite máscara de campo.

kBlockSetIsLongTermShift

Digite deslocamento de campo.

kBlockSetSizeMask

Máscara de campo de tamanho.

kBlockSetSizeShift

Mudança de campo de tamanho.

kBlockSetSizeValueShift

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

BlockSetParams

 BlockSetParams

Define os parâmetros do conjunto de blocos.

Propriedades
kBlockSet1BufferIndex

O índice de buffer # 1 definido é 0.

kBlockSet1Count

A contagem de blocos do conjunto # 1 é 1.

kBlockSet1Size

O tamanho do conjunto # 1 é 128 bytes.

kBlockSet1isLongTerm

O tipo de conjunto # 1 é de longo prazo.

kBlockSet2BufferIndex

Definir o índice de buffer # 2 é 0.

kBlockSet2Count

A contagem de blocos do conjunto # 2 é 1.

kBlockSet2Size

O tamanho do conjunto # 2 é 512 bytes.

kBlockSet2isLongTerm

O tipo de conjunto # 2 é de longo prazo.

kBlockSet3BufferIndex

O índice de buffer definido # 3 é 0.

kBlockSet3Count

A contagem de blocos do conjunto # 3 é 1.

kBlockSet3Size

O tamanho do conjunto # 3 é 512 bytes.

kBlockSet3isLongTerm

O tipo de conjunto # 3 é de curto prazo.

kBlockSet4BufferIndex

O índice de buffer # 4 definido é 1.

kBlockSet4Count

A contagem de blocos do conjunto # 4 é 2.

kBlockSet4Size

O tamanho do conjunto # 4 é de 640 bytes.

kBlockSet4isLongTerm

O tipo do conjunto # 4 é de curto prazo.

kMaxBlockSize

Tamanho máximo do bloco suportado pelo Simple Allocator.

kMinBufferSize

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

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

kNetworkBuffer0BlockAllocationMask

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

kNetworkBuffer1BlockAllocationMask

Esta 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 Simple Allocator.

Typedefs

BlockMark_t

uint8_t BlockMark_t

O tipo usado para marcar qual bloco está atualmente alocado / não alocado.

uint8_t - suporta até 8 blocos de memória no total uint16_t - suporta até 16 blocos de memória no total uint32_t - suporta até 32 blocos de memória no total

BlockSetParams_t

uint8_t BlockSetParams_t

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

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

É de longo prazo Índice de Bloco 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 do tamanho é codificado com granularidade de 128 bytes.
[2: 0] Decodificação
000 0 bytes
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 de buffer de rede onde residem os blocos de memória. Observe que quando o buffer dedicado é usado, todos os blocos de memória são alocados do buffer dedicado e este 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 Blocos 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 no buffer e não alocados e, em seguida, o buffer pode ser reativado.

sMemBlocksAllocated

BlockMark_t sMemBlocksAllocated = 0

Indica qual bloco está alocado / não alocado.

Inicializado em 0 - significa que todos os blocos de memória e não alocados.

sMemBufs

void * sMemBufs[kNumberOfNetworkBuffers] = { NULL }

Ponteiros para buffers de memória inicializados com NULL.

Quando buffers de rede são usados, sMemBufs [] aponta para os objetos PacketBuffer. 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 Simple Allocator.

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

Funções

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
)

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

Detalhes
Parâmetros
[in] buf
Ponteiro para um buffer de memória, onde os dados aleatórios solicitados devem ser armazenados.
[in] len
Especifica o tamanho dos dados aleatórios solicitados em bytes.
Valores Retornados
WEAVE_ERROR_DRBG_ENTROPY_SOURCE_FAILED
Se a fonte de entropia falhar em gerar entropia solicitada pelo gerador de dados aleatórios.
WEAVE_ERROR_RANDOM_DATA_UNAVAILABLE
Se a fonte de dados aleatória falhar em gerar dados aleatórios.
WEAVE_ERROR_INCORRECT_STATE
Se a fonte de dados aleatória for encontrada em um estado errado.
WEAVE_NO_ERROR
Com sucesso.

InitSecureRandomDataSource

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

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

Esta função é específica da plataforma e pode estar vazia quando nenhuma inicialização de fonte de dados aleatória é 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, essa entrada 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 deve ser gerado pela função de entropia quando ela é usada.
[in] personalizationData
Ponteiro para um buffer de memória que armazena a entrada de dados de personalização. Esta entrada de dados deve ser específica do 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 Retornados
WEAVE_ERROR_INVALID_ARGUMENT
Se um argumento inválido foi passado para esta função.
WEAVE_NO_ERROR
Com sucesso.

MemoryAlloc

void * MemoryAlloc(
  size_t size
)

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

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

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

MemoryAlloc

void * MemoryAlloc(
  size_t size,
  bool isLongTermAlloc
)

Esta 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 deve permanecer alocada até que a sessão segura / handshake seja concluída. 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 pode ser liberada imediatamente após isso. Essa entrada ajuda a otimizar a utilização da memória em um sistema com restrição de memória. O uso deste parâmetro é arbitrário e depende do implementador da função. Por exemplo, este parâmetro é ignorado quando a Biblioteca Padrão C malloc () é usada.
Valores Retornados
Pointer
para um bloco de memória em caso de sucesso.
NULL-pointer
se a alocação de memória falhar.

MemoryFree

void MemoryFree(
  void *p
)

Esta 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 deve ser liberado.

MemoryInit

WEAVE_ERROR MemoryInit(
  void *buf,
  size_t bufSize
)

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

Esta função é específica da plataforma e pode estar vazia em certos casos. Por exemplo, esta função não faz nada quando as funções malloc () e free () da Biblioteca Padrão C 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 Weave Security Manager. Esta 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. Esta 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 for grande o suficiente para suportar os casos de uso do Weave Security Manager.
Valores Retornados
WEAVE_ERROR_BUFFER_TOO_SMALL
Se o tamanho do buffer de entrada dedicado não for suficiente para dar suporte aos casos de uso do Weave Security Manager.
WEAVE_NO_ERROR
Com sucesso.
other
Um erro gerado pela função de inicialização de memória específica da plataforma.

MemoryShutdown

void MemoryShutdown(
  void
)

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

Esta função pode ser uma chamada vazia se não houver necessidade de liberar recursos. Por exemplo, este é o caso quando as funções malloc () e free () da Biblioteca Padrão C são usadas para alocação de memória.

OnTimeConsumingCryptoDone

void OnTimeConsumingCryptoDone(
  void
)

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

OnTimeConsumingCryptoStart

void OnTimeConsumingCryptoStart(
  void
)

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