BlockIoCrypto.h

Go to the documentation of this file.

 
#ifndef __BLOCK_IO_CRYPTO_H__
#define __BLOCK_IO_CRYPTO_H__
 
#include <Protocol/BlockIo.h>
 
#define EFI_BLOCK_IO_CRYPTO_PROTOCOL_GUID \
    { \
      0xa00490ba, 0x3f1a, 0x4b4c, {0xab, 0x90, 0x4f, 0xa9, 0x97, 0x26, 0xa1, 0xe8} \
    }
 
typedef struct _EFI_BLOCK_IO_CRYPTO_PROTOCOL  EFI_BLOCK_IO_CRYPTO_PROTOCOL;
 
typedef struct {
  //
  // If Event is NULL, then blocking I/O is performed. If Event is not NULL and
  // non-blocking I/O is supported, then non-blocking I/O is performed, and
  // Event will be signaled when the read request is completed and data was
  // decrypted  (when Index was specified).
  //
  EFI_EVENT               Event;
  //
  // Defines whether or not the signaled event encountered an error.
  //
  EFI_STATUS              TransactionStatus;
} EFI_BLOCK_IO_CRYPTO_TOKEN;
 
typedef struct {
  //
  // GUID of the algorithm.
  //
  EFI_GUID       Algorithm;
  //
  // Specifies KeySizein bits used with this Algorithm.
  //
  UINT64         KeySize;
  //
  // Specifies bitmask of block sizes supported by this algorithm.
  // Bit j being set means that 2^j bytes crypto block size is supported.
  //
  UINT64         CryptoBlockSizeBitMask;
} EFI_BLOCK_IO_CRYPTO_CAPABILITY;
 
typedef struct {
  UINT64         InputSize;
} EFI_BLOCK_IO_CRYPTO_IV_INPUT;
 
#define EFI_BLOCK_IO_CRYPTO_ALGO_GUID_AES_XTS \
    { \
      0x2f87ba6a, 0x5c04, 0x4385, {0xa7, 0x80, 0xf3, 0xbf, 0x78, 0xa9, 0x7b, 0xec} \
    }
 
extern EFI_GUID gEfiBlockIoCryptoAlgoAesXtsGuid;
 
typedef struct {
  EFI_BLOCK_IO_CRYPTO_IV_INPUT Header;
  UINT64                       CryptoBlockNumber;
  UINT64                       CryptoBlockByteSize;
} EFI_BLOCK_IO_CRYPTO_IV_INPUT_AES_XTS;
 
#define EFI_BLOCK_IO_CRYPTO_ALGO_GUID_AES_CBC_MICROSOFT_BITLOCKER \
    { \
      0x689e4c62, 0x70bf, 0x4cf3, {0x88, 0xbb, 0x33, 0xb3, 0x18, 0x26, 0x86, 0x70} \
    }
 
extern EFI_GUID gEfiBlockIoCryptoAlgoAesCbcMsBitlockerGuid;
 
typedef struct {
  EFI_BLOCK_IO_CRYPTO_IV_INPUT  Header;
  UINT64                        CryptoBlockByteOffset;
  UINT64                        CryptoBlockByteSize;
} EFI_BLOCK_IO_CRYPTO_IV_INPUT_AES_CBC_MICROSOFT_BITLOCKER;
 
#define EFI_BLOCK_IO_CRYPTO_INDEX_ANY 0xFFFFFFFFFFFFFFFF
 
typedef struct {
  //
  // Is inline cryptographic capability supported on this device.
  //
  BOOLEAN                         Supported;
  //
  // Maximum number of keys that can be configured at the same time.
  //
  UINT64                          KeyCount;
  //
  // Number of supported capabilities.
  //
  UINT64                          CapabilityCount;
  //
  // Array of supported capabilities.
  //
  EFI_BLOCK_IO_CRYPTO_CAPABILITY  Capabilities[1];
} EFI_BLOCK_IO_CRYPTO_CAPABILITIES;
 
typedef struct {
  //
  // Configuration table index. A special Index EFI_BLOCK_IO_CRYPTO_INDEX_ANY can be
  // used to set any available entry in the configuration table.
  //
  UINT64                          Index;
  //
  // Identifies the owner of the configuration table entry. Entry can also be used
  // with the Nil value to clear key from the configuration table index.
  //
  EFI_GUID                        KeyOwnerGuid;
  //
  // A supported capability to be used. The CryptoBlockSizeBitMask field of the
  // structure should have only one bit set from the supported mask.
  //
  EFI_BLOCK_IO_CRYPTO_CAPABILITY  Capability;
  //
  // Pointer to the key. The size of the key is defined by the KeySize field of
  // the capability specified by the Capability parameter.
  //
  VOID                            *CryptoKey;
} EFI_BLOCK_IO_CRYPTO_CONFIGURATION_TABLE_ENTRY;
 
typedef struct {
  //
  // Configuration table index.
  //
  UINT64                          Index;
  //
  // Identifies the current owner of the entry.
  //
  EFI_GUID                        KeyOwnerGuid;
  //
  // The capability to be used. The CryptoBlockSizeBitMask field of the structure
  // has only one bit set from the supported mask.
  //
  EFI_BLOCK_IO_CRYPTO_CAPABILITY  Capability;
} EFI_BLOCK_IO_CRYPTO_RESPONSE_CONFIGURATION_ENTRY;
 
typedef
EFI_STATUS
(EFIAPI *EFI_BLOCK_IO_CRYPTO_RESET) (
  IN EFI_BLOCK_IO_CRYPTO_PROTOCOL  *This,
  IN BOOLEAN                       ExtendedVerification
  );
 
typedef
EFI_STATUS
(EFIAPI *EFI_BLOCK_IO_CRYPTO_GET_CAPABILITIES) (
  IN     EFI_BLOCK_IO_CRYPTO_PROTOCOL           *This,
     OUT EFI_BLOCK_IO_CRYPTO_CAPABILITIES       *Capabilities
  );
 
typedef
EFI_STATUS
(EFIAPI *EFI_BLOCK_IO_CRYPTO_SET_CONFIGURATION) (
  IN     EFI_BLOCK_IO_CRYPTO_PROTOCOL                     *This,
  IN     UINT64                                           ConfigurationCount,
  IN     EFI_BLOCK_IO_CRYPTO_CONFIGURATION_TABLE_ENTRY    *ConfigurationTable,
     OUT EFI_BLOCK_IO_CRYPTO_RESPONSE_CONFIGURATION_ENTRY *ResultingTable OPTIONAL
  );
 
typedef
EFI_STATUS
(EFIAPI *EFI_BLOCK_IO_CRYPTO_GET_CONFIGURATION) (
  IN     EFI_BLOCK_IO_CRYPTO_PROTOCOL                     *This,
  IN     UINT64                                           StartIndex,
  IN     UINT64                                           ConfigurationCount,
  IN     EFI_GUID                                         *KeyOwnerGuid OPTIONAL,
     OUT EFI_BLOCK_IO_CRYPTO_RESPONSE_CONFIGURATION_ENTRY *ConfigurationTable
);
 
typedef
EFI_STATUS
(EFIAPI *EFI_BLOCK_IO_CRYPTO_READ_EXTENDED) (
  IN     EFI_BLOCK_IO_CRYPTO_PROTOCOL  *This,
  IN     UINT32                        MediaId,
  IN     EFI_LBA                       LBA,
  IN OUT EFI_BLOCK_IO_CRYPTO_TOKEN     *Token,
  IN     UINT64                        BufferSize,
     OUT VOID                          *Buffer,
  IN     UINT64                        *Index OPTIONAL,
  IN     VOID                          *CryptoIvInput OPTIONAL
  );
 
typedef
EFI_STATUS
(EFIAPI *EFI_BLOCK_IO_CRYPTO_WRITE_EXTENDED) (
  IN     EFI_BLOCK_IO_CRYPTO_PROTOCOL  *This,
  IN     UINT32                        MediaId,
  IN     EFI_LBA                       LBA,
  IN OUT EFI_BLOCK_IO_CRYPTO_TOKEN     *Token,
  IN     UINT64                        BufferSize,
  IN     VOID                          *Buffer,
  IN     UINT64                        *Index OPTIONAL,
  IN     VOID                          *CryptoIvInput OPTIONAL
  );
 
typedef
EFI_STATUS
(EFIAPI *EFI_BLOCK_IO_CRYPTO_FLUSH) (
  IN     EFI_BLOCK_IO_CRYPTO_PROTOCOL  *This,
  IN OUT EFI_BLOCK_IO_CRYPTO_TOKEN     *Token
  );
 
struct _EFI_BLOCK_IO_CRYPTO_PROTOCOL {
  EFI_BLOCK_IO_MEDIA                        *Media;
  EFI_BLOCK_IO_CRYPTO_RESET                 Reset;
  EFI_BLOCK_IO_CRYPTO_GET_CAPABILITIES      GetCapabilities;
  EFI_BLOCK_IO_CRYPTO_SET_CONFIGURATION     SetConfiguration;
  EFI_BLOCK_IO_CRYPTO_GET_CONFIGURATION     GetConfiguration;
  EFI_BLOCK_IO_CRYPTO_READ_EXTENDED         ReadExtended;
  EFI_BLOCK_IO_CRYPTO_WRITE_EXTENDED        WriteExtended;
  EFI_BLOCK_IO_CRYPTO_FLUSH                 FlushBlocks;
};
 
extern EFI_GUID gEfiBlockIoCryptoProtocolGuid;
 
#endif