/** @file
|
Device driver for the ChaosKey hardware random number generator.
|
|
Copyright (c) 2016 - 2017, Linaro Ltd. All rights reserved.<BR>
|
|
SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
**/
|
|
#include "ChaosKeyDriver.h"
|
|
#include <Library/BaseMemoryLib.h>
|
#include <Library/DebugLib.h>
|
#include <Library/MemoryAllocationLib.h>
|
|
STATIC
|
BOOLEAN
|
IsBulkInEndpoint (
|
IN EFI_USB_ENDPOINT_DESCRIPTOR *Endpoint
|
)
|
{
|
if ((Endpoint->Attributes & USB_ENDPOINT_TYPE_MASK) == USB_ENDPOINT_BULK) {
|
if (Endpoint->EndpointAddress & USB_ENDPOINT_DIR_IN) {
|
return TRUE;
|
}
|
}
|
return FALSE;
|
}
|
|
|
STATIC
|
EFI_STATUS
|
FindEndpoint (
|
IN CHAOSKEY_DEV *ChaosKey
|
)
|
{
|
EFI_USB_IO_PROTOCOL *UsbIo;
|
EFI_STATUS Status;
|
UINTN Index;
|
EFI_USB_INTERFACE_DESCRIPTOR InterfaceDescriptor;
|
|
UsbIo = ChaosKey->UsbIo;
|
|
//
|
// Get interface & endpoint descriptor
|
//
|
Status = UsbIo->UsbGetInterfaceDescriptor (UsbIo, &InterfaceDescriptor);
|
if (EFI_ERROR (Status)) {
|
return Status;
|
}
|
|
//
|
// The ChaosKey provides two endpoints:
|
// - The first one is the 'cooked' one, to be used as random data input
|
// - The second one is the raw bitstream from the generator, higher
|
// throughput, but lower randomness.
|
// So locate the first bulk IN endpoint and save it for later use.
|
//
|
for (Index = 0; Index < InterfaceDescriptor.NumEndpoints; Index++) {
|
EFI_USB_ENDPOINT_DESCRIPTOR Endpoint;
|
|
Status = UsbIo->UsbGetEndpointDescriptor (UsbIo, Index, &Endpoint);
|
if (EFI_ERROR (Status)) {
|
DEBUG ((DEBUG_ERROR, "UsbGetEndPointDescriptor(%d) failed!\n", Index));
|
return Status;
|
}
|
|
if (IsBulkInEndpoint(&Endpoint)) {
|
ChaosKey->EndpointAddress = Endpoint.EndpointAddress;
|
ChaosKey->EndpointSize = Endpoint.MaxPacketSize;
|
return EFI_SUCCESS;
|
}
|
}
|
|
DEBUG ((DEBUG_ERROR, "Failed to locate suitable BULK IN USB endpoint!\n"));
|
return EFI_DEVICE_ERROR;
|
}
|
|
|
/**
|
Returns information about the random number generation implementation.
|
|
@param[in] This A pointer to the EFI_RNG_PROTOCOL instance.
|
@param[in,out] AlgorithmListSize On input, the size in bytes of AlgorithmList
|
On output with a return code of EFI_SUCCESS,
|
the size in bytes of the data returned in
|
AlgorithmList. On output with a return
|
code of EFI_BUFFER_TOO_SMALL, the size of
|
AlgorithmList required to obtain the list.
|
@param[out] AlgorithmList A caller-allocated memory buffer filled by
|
the driver with one EFI_RNG_ALGORITHM
|
element for each supported RNG algorithm.
|
The list must not change across multiple
|
calls to the same driver. The first
|
algorithm in the list is the default
|
algorithm for the driver.
|
|
@retval EFI_SUCCESS The RNG algorithm list was returned
|
successfully.
|
@retval EFI_UNSUPPORTED The services is not supported by this driver
|
@retval EFI_DEVICE_ERROR The list of algorithms could not be
|
retrieved due to a hardware or firmware
|
error.
|
@retval EFI_INVALID_PARAMETER One or more of the parameters are incorrect.
|
@retval EFI_BUFFER_TOO_SMALL The buffer RNGAlgorithmList is too small to
|
hold the result.
|
|
**/
|
STATIC
|
EFI_STATUS
|
EFIAPI
|
GetInfo (
|
IN EFI_RNG_PROTOCOL *This,
|
IN OUT UINTN *AlgorithmListSize,
|
OUT EFI_RNG_ALGORITHM *AlgorithmList
|
)
|
{
|
UINTN Size;
|
|
//
|
// We only implement the raw algorithm
|
//
|
Size = sizeof gEfiRngAlgorithmRaw;
|
|
if (*AlgorithmListSize < Size) {
|
*AlgorithmListSize = Size;
|
return EFI_BUFFER_TOO_SMALL;
|
}
|
|
gBS->CopyMem (AlgorithmList, &gEfiRngAlgorithmRaw, Size);
|
*AlgorithmListSize = Size;
|
|
return EFI_SUCCESS;
|
}
|
|
|
/**
|
Produces and returns an RNG value using either the default or specified RNG
|
algorithm.
|
|
@param[in] This A pointer to the EFI_RNG_PROTOCOL instance.
|
@param[in] Algorithm A pointer to the EFI_RNG_ALGORITHM that
|
identifies the RNG algorithm to use. May be
|
NULL in which case the function will use its
|
default RNG algorithm.
|
@param[in] ValueLength The length in bytes of the memory buffer
|
pointed to by RNGValue. The driver shall
|
return exactly this numbers of bytes.
|
@param[out] Value A caller-allocated memory buffer filled by the
|
driver with the resulting RNG value.
|
|
@retval EFI_SUCCESS The RNG value was returned successfully.
|
@retval EFI_UNSUPPORTED The algorithm specified by RNGAlgorithm is not
|
supported by this driver.
|
@retval EFI_DEVICE_ERROR An RNG value could not be retrieved due to a
|
hardware or firmware error.
|
@retval EFI_NOT_READY There is not enough random data available to
|
satisfy the length requested by
|
RNGValueLength.
|
@retval EFI_INVALID_PARAMETER RNGValue is NULL or RNGValueLength is zero.
|
|
**/
|
STATIC
|
EFI_STATUS
|
EFIAPI
|
GetRNG (
|
IN EFI_RNG_PROTOCOL *This,
|
IN EFI_RNG_ALGORITHM *Algorithm OPTIONAL,
|
IN UINTN ValueLength,
|
OUT UINT8 *Value
|
)
|
{
|
EFI_STATUS Status;
|
CHAOSKEY_DEV *ChaosKey;
|
UINT8 Buffer[CHAOSKEY_MAX_EP_SIZE];
|
UINT8 *OutPointer;
|
UINTN OutSize;
|
UINT32 Result;
|
|
if (Algorithm != NULL && !CompareGuid (Algorithm, &gEfiRngAlgorithmRaw)) {
|
return EFI_UNSUPPORTED;
|
}
|
|
ChaosKey = CHAOSKEY_DEV_FROM_THIS (This);
|
|
while (ValueLength > 0) {
|
//
|
// If more data is requested than the endpoint can deliver in a single
|
// transfer, put it straight into the caller's buffer.
|
//
|
if (ValueLength >= ChaosKey->EndpointSize) {
|
OutPointer = Value;
|
} else {
|
OutPointer = Buffer;
|
}
|
OutSize = ChaosKey->EndpointSize;
|
|
Status = ChaosKey->UsbIo->UsbBulkTransfer (ChaosKey->UsbIo,
|
ChaosKey->EndpointAddress,
|
OutPointer,
|
&OutSize,
|
CHAOSKEY_TIMEOUT,
|
&Result);
|
|
if (Status == EFI_TIMEOUT) {
|
DEBUG ((DEBUG_ERROR, "Bulk transfer timed out, USB status == %d\n",
|
Result));
|
return EFI_NOT_READY;
|
} else if (EFI_ERROR (Status)) {
|
DEBUG ((DEBUG_ERROR,
|
"Bulk transfer failed, Status == %r, USB status == %d\n",
|
Status, Result));
|
return EFI_DEVICE_ERROR;
|
}
|
|
OutSize = MIN (OutSize, ValueLength);
|
|
if (Value != Buffer) {
|
gBS->CopyMem (Value, Buffer, OutSize);
|
}
|
Value += OutSize;
|
ValueLength -= OutSize;
|
}
|
return EFI_SUCCESS;
|
}
|
|
|
EFI_STATUS
|
ChaosKeyInit (
|
IN EFI_HANDLE DriverBindingHandle,
|
IN EFI_HANDLE ControllerHandle
|
)
|
{
|
EFI_STATUS Status;
|
CHAOSKEY_DEV *ChaosKey;
|
|
Status = gBS->AllocatePool (EfiBootServicesData,
|
sizeof (CHAOSKEY_DEV),
|
(VOID **) &ChaosKey);
|
if (EFI_ERROR (Status)) {
|
return EFI_OUT_OF_RESOURCES;
|
}
|
|
ChaosKey->Signature = CHAOSKEY_DEV_SIGNATURE;
|
ChaosKey->Rng.GetInfo = GetInfo;
|
ChaosKey->Rng.GetRNG = GetRNG;
|
|
//
|
// Open USB I/O Protocol
|
//
|
Status = gBS->OpenProtocol (ControllerHandle,
|
&gEfiUsbIoProtocolGuid,
|
(VOID **)&ChaosKey->UsbIo,
|
DriverBindingHandle,
|
ControllerHandle,
|
EFI_OPEN_PROTOCOL_BY_DRIVER);
|
if (EFI_ERROR (Status)) {
|
goto ErrorFreeDev;
|
}
|
|
Status = FindEndpoint (ChaosKey);
|
if (EFI_ERROR (Status)) {
|
goto ErrorCloseProtocol;
|
}
|
|
//
|
// The following can only occur if the Chaoskey is suddenly reissued
|
// as a high speed or super speed device under the same VID/PID.
|
//
|
ASSERT (ChaosKey->EndpointSize <= CHAOSKEY_MAX_EP_SIZE);
|
|
Status = gBS->InstallProtocolInterface (&ControllerHandle,
|
&gEfiRngProtocolGuid,
|
EFI_NATIVE_INTERFACE,
|
&ChaosKey->Rng);
|
if (EFI_ERROR (Status)) {
|
DEBUG ((DEBUG_ERROR,
|
"Failed to install RNG protocol interface (Status == %r)\n",
|
Status));
|
goto ErrorCloseProtocol;
|
}
|
|
return EFI_SUCCESS;
|
|
ErrorCloseProtocol:
|
gBS->CloseProtocol (ControllerHandle, &gEfiUsbIoProtocolGuid,
|
DriverBindingHandle, ControllerHandle);
|
|
ErrorFreeDev:
|
gBS->FreePool (ChaosKey);
|
|
return Status;
|
}
|
|
EFI_STATUS
|
ChaosKeyRelease (
|
IN EFI_HANDLE DriverBindingHandle,
|
IN EFI_HANDLE ControllerHandle
|
)
|
{
|
EFI_RNG_PROTOCOL *Rng;
|
CHAOSKEY_DEV *ChaosKey;
|
EFI_STATUS Status;
|
|
Status = gBS->HandleProtocol (ControllerHandle,
|
&gEfiRngProtocolGuid,
|
(VOID **)&Rng);
|
ASSERT_EFI_ERROR (Status);
|
if (EFI_ERROR (Status)) {
|
return Status;
|
}
|
|
ChaosKey = CHAOSKEY_DEV_FROM_THIS (Rng);
|
|
Status = gBS->UninstallProtocolInterface (ControllerHandle,
|
&gEfiRngProtocolGuid,
|
Rng);
|
ASSERT_EFI_ERROR (Status);
|
if (EFI_ERROR (Status)) {
|
return Status;
|
}
|
|
Status = gBS->CloseProtocol (ControllerHandle,
|
&gEfiUsbIoProtocolGuid,
|
DriverBindingHandle,
|
ControllerHandle);
|
ASSERT_EFI_ERROR (Status);
|
if (EFI_ERROR (Status)) {
|
return Status;
|
}
|
|
gBS->FreePool (ChaosKey);
|
|
return EFI_SUCCESS;
|
}
|
