[mirror_edk2.git] / MdePkg / Library / BaseSafeIntLib / SafeIntLibEbc.c

/** @file\r
  This library provides helper functions to prevent integer overflow during\r
  type conversion, addition, subtraction, and multiplication.\r
\r
  Copyright (c) 2017, Microsoft Corporation\r
\r
  All rights reserved.\r
  Redistribution and use in source and binary forms, with or without\r
  modification, are permitted provided that the following conditions are met:\r
  1. Redistributions of source code must retain the above copyright notice,\r
  this list of conditions and the following disclaimer.\r
  2. Redistributions in binary form must reproduce the above copyright notice,\r
  this list of conditions and the following disclaimer in the documentation\r
  and/or other materials provided with the distribution.\r
\r
  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND\r
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\r
  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,\r
  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,\r
  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF\r
  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE\r
  OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF\r
  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
\r
**/\r
\r
#include <Base.h>\r
#include <Library/SafeIntLib.h>\r
\r
/**\r
  INT32 -> UINTN conversion\r
\r
  Converts the value specified by Operand to a value specified by Result type\r
  and stores the converted value into the caller allocated output buffer\r
  specified by Result.  The caller must pass in a Result buffer that is at\r
  least as large as the Result type.\r
\r
  If Result is NULL, RETURN_INVALID_PARAMETER is returned.\r
\r
  If the conversion results in an overflow or an underflow condition, then\r
  Result is set to UINTN_ERROR and RETURN_BUFFER_TOO_SMALL is returned.\r
\r
  @param[in]   Operand  Operand to be converted to new type\r
  @param[out]  Result   Pointer to the result of conversion\r
\r
  @retval  RETURN_SUCCESS            Successful conversion\r
  @retval  RETURN_BUFFER_TOO_SMALL   Overflow\r
  @retval  RETURN_INVALID_PARAMETER  Result is NULL\r
**/\r
RETURN_STATUS\r
EFIAPI\r
SafeInt32ToUintn (\r
  IN  INT32  Operand,\r
  OUT UINTN  *Result\r
  )\r
{\r
  if (sizeof (UINTN) == sizeof (UINT32)) {\r
    return SafeInt32ToUint32 (Operand, (UINT32 *)Result);\r
  }\r
  return SafeInt32ToUint64 (Operand, (UINT64 *) Result);\r
}\r
\r
/**\r
  UINT32 -> INTN conversion\r
\r
  Converts the value specified by Operand to a value specified by Result type\r
  and stores the converted value into the caller allocated output buffer\r
  specified by Result.  The caller must pass in a Result buffer that is at\r
  least as large as the Result type.\r
\r
  If Result is NULL, RETURN_INVALID_PARAMETER is returned.\r
\r
  If the conversion results in an overflow or an underflow condition, then\r
  Result is set to INTN_ERROR and RETURN_BUFFER_TOO_SMALL is returned.\r
\r
  @param[in]   Operand  Operand to be converted to new type\r
  @param[out]  Result   Pointer to the result of conversion\r
\r
  @retval  RETURN_SUCCESS            Successful conversion\r
  @retval  RETURN_BUFFER_TOO_SMALL   Overflow\r
  @retval  RETURN_INVALID_PARAMETER  Result is NULL\r
**/\r
RETURN_STATUS\r
EFIAPI\r
SafeUint32ToIntn (\r
  IN  UINT32  Operand,\r
  OUT INTN    *Result\r
  )\r
{\r
  if (Result == NULL) {\r
    return RETURN_INVALID_PARAMETER;\r
  }\r
\r
  if (sizeof (UINTN) == sizeof (UINT32)) {\r
    return SafeUint32ToInt32 (Operand, (INT32 *)Result);\r
  }\r
  *Result = Operand;\r
  return RETURN_SUCCESS;\r
}\r
\r
/**\r
  INTN -> INT32 conversion\r
\r
  Converts the value specified by Operand to a value specified by Result type\r
  and stores the converted value into the caller allocated output buffer\r
  specified by Result.  The caller must pass in a Result buffer that is at\r
  least as large as the Result type.\r
\r
  If Result is NULL, RETURN_INVALID_PARAMETER is returned.\r
\r
  If the conversion results in an overflow or an underflow condition, then\r
  Result is set to INT32_ERROR and RETURN_BUFFER_TOO_SMALL is returned.\r
\r
  @param[in]   Operand  Operand to be converted to new type\r
  @param[out]  Result   Pointer to the result of conversion\r
\r
  @retval  RETURN_SUCCESS            Successful conversion\r
  @retval  RETURN_BUFFER_TOO_SMALL   Overflow\r
  @retval  RETURN_INVALID_PARAMETER  Result is NULL\r
**/\r
RETURN_STATUS\r
EFIAPI\r
SafeIntnToInt32 (\r
  IN  INTN   Operand,\r
  OUT INT32  *Result\r
  )\r
{\r
  if (Result == NULL) {\r
    return RETURN_INVALID_PARAMETER;\r
  }\r
\r
  if (sizeof (UINTN) == sizeof (UINT32)) {\r
    *Result = (INT32)Operand;\r
    return RETURN_SUCCESS;\r
  }\r
  return SafeInt64ToInt32 ((INT64) Operand, Result);\r
}\r
\r
/**\r
  INTN -> UINT32 conversion\r
\r
  Converts the value specified by Operand to a value specified by Result type\r
  and stores the converted value into the caller allocated output buffer\r
  specified by Result.  The caller must pass in a Result buffer that is at\r
  least as large as the Result type.\r
\r
  If Result is NULL, RETURN_INVALID_PARAMETER is returned.\r
\r
  If the conversion results in an overflow or an underflow condition, then\r
  Result is set to UINT32_ERROR and RETURN_BUFFER_TOO_SMALL is returned.\r
\r
  @param[in]   Operand  Operand to be converted to new type\r
  @param[out]  Result   Pointer to the result of conversion\r
\r
  @retval  RETURN_SUCCESS            Successful conversion\r
  @retval  RETURN_BUFFER_TOO_SMALL   Overflow\r
  @retval  RETURN_INVALID_PARAMETER  Result is NULL\r
**/\r
RETURN_STATUS\r
EFIAPI\r
SafeIntnToUint32 (\r
  IN  INTN    Operand,\r
  OUT UINT32  *Result\r
  )\r
{\r
  RETURN_STATUS  Status;\r
\r
  if (Result == NULL) {\r
    return RETURN_INVALID_PARAMETER;\r
  }\r
\r
  if (sizeof (UINTN) == sizeof (UINT32)) {\r
    if (Operand >= 0) {\r
      *Result = (UINT32)Operand;\r
      Status = RETURN_SUCCESS;\r
    } else {\r
      *Result = UINT32_ERROR;\r
      Status = RETURN_BUFFER_TOO_SMALL;\r
    }\r
\r
    return Status;\r
  }\r
  return SafeInt64ToUint32 ((INT64)Operand, Result);\r
}\r
\r
/**\r
  UINTN -> UINT32 conversion\r
\r
  Converts the value specified by Operand to a value specified by Result type\r
  and stores the converted value into the caller allocated output buffer\r
  specified by Result.  The caller must pass in a Result buffer that is at\r
  least as large as the Result type.\r
\r
  If Result is NULL, RETURN_INVALID_PARAMETER is returned.\r
\r
  If the conversion results in an overflow or an underflow condition, then\r
  Result is set to UINT32_ERROR and RETURN_BUFFER_TOO_SMALL is returned.\r
\r
  @param[in]   Operand  Operand to be converted to new type\r
  @param[out]  Result   Pointer to the result of conversion\r
\r
  @retval  RETURN_SUCCESS            Successful conversion\r
  @retval  RETURN_BUFFER_TOO_SMALL   Overflow\r
  @retval  RETURN_INVALID_PARAMETER  Result is NULL\r
**/\r
RETURN_STATUS\r
EFIAPI\r
SafeUintnToUint32 (\r
  IN  UINTN   Operand,\r
  OUT UINT32  *Result\r
  )\r
{\r
  if (Result == NULL) {\r
    return RETURN_INVALID_PARAMETER;\r
  }\r
\r
  if (sizeof (UINTN) == sizeof (UINT32)) {\r
    *Result = (UINT32)Operand;\r
    return RETURN_SUCCESS;\r
  }\r
  return SafeUint64ToUint32 ((UINT64)Operand, Result);\r
}\r
\r
/**\r
  UINTN -> INT64 conversion\r
\r
  Converts the value specified by Operand to a value specified by Result type\r
  and stores the converted value into the caller allocated output buffer\r
  specified by Result.  The caller must pass in a Result buffer that is at\r
  least as large as the Result type.\r
\r
  If Result is NULL, RETURN_INVALID_PARAMETER is returned.\r
\r
  If the conversion results in an overflow or an underflow condition, then\r
  Result is set to INT64_ERROR and RETURN_BUFFER_TOO_SMALL is returned.\r
\r
  @param[in]   Operand  Operand to be converted to new type\r
  @param[out]  Result   Pointer to the result of conversion\r
\r
  @retval  RETURN_SUCCESS            Successful conversion\r
  @retval  RETURN_BUFFER_TOO_SMALL   Overflow\r
  @retval  RETURN_INVALID_PARAMETER  Result is NULL\r
**/\r
RETURN_STATUS\r
EFIAPI\r
SafeUintnToInt64 (\r
  IN  UINTN  Operand,\r
  OUT INT64  *Result\r
  )\r
{\r
  if (Result == NULL) {\r
    return RETURN_INVALID_PARAMETER;\r
  }\r
\r
  if (sizeof (UINTN) == sizeof (UINT32)) {\r
    *Result = (INT64)Operand;\r
    return RETURN_SUCCESS;\r
  }\r
  return SafeUint64ToInt64 ((UINT64)Operand, Result);\r
}\r
\r
/**\r
  INT64 -> INTN conversion\r
\r
  Converts the value specified by Operand to a value specified by Result type\r
  and stores the converted value into the caller allocated output buffer\r
  specified by Result.  The caller must pass in a Result buffer that is at\r
  least as large as the Result type.\r
\r
  If Result is NULL, RETURN_INVALID_PARAMETER is returned.\r
\r
  If the conversion results in an overflow or an underflow condition, then\r
  Result is set to INTN_ERROR and RETURN_BUFFER_TOO_SMALL is returned.\r
\r
  @param[in]   Operand  Operand to be converted to new type\r
  @param[out]  Result   Pointer to the result of conversion\r
\r
  @retval  RETURN_SUCCESS            Successful conversion\r
  @retval  RETURN_BUFFER_TOO_SMALL   Overflow\r
  @retval  RETURN_INVALID_PARAMETER  Result is NULL\r
**/\r
RETURN_STATUS\r
EFIAPI\r
SafeInt64ToIntn (\r
  IN  INT64  Operand,\r
  OUT INTN   *Result\r
  )\r
{\r
  if (Result == NULL) {\r
    return RETURN_INVALID_PARAMETER;\r
  }\r
\r
  if (sizeof (UINTN) == sizeof (UINT32)) {\r
    return SafeInt64ToInt32 (Operand, (INT32 *)Result);\r
  }\r
  *Result = (INTN)Operand;\r
  return RETURN_SUCCESS;\r
}\r
\r
/**\r
  INT64 -> UINTN conversion\r
\r
  Converts the value specified by Operand to a value specified by Result type\r
  and stores the converted value into the caller allocated output buffer\r
  specified by Result.  The caller must pass in a Result buffer that is at\r
  least as large as the Result type.\r
\r
  If Result is NULL, RETURN_INVALID_PARAMETER is returned.\r
\r
  If the conversion results in an overflow or an underflow condition, then\r
  Result is set to UINTN_ERROR and RETURN_BUFFER_TOO_SMALL is returned.\r
\r
  @param[in]   Operand  Operand to be converted to new type\r
  @param[out]  Result   Pointer to the result of conversion\r
\r
  @retval  RETURN_SUCCESS            Successful conversion\r
  @retval  RETURN_BUFFER_TOO_SMALL   Overflow\r
  @retval  RETURN_INVALID_PARAMETER  Result is NULL\r
**/\r
RETURN_STATUS\r
EFIAPI\r
SafeInt64ToUintn (\r
  IN  INT64  Operand,\r
  OUT UINTN  *Result\r
  )\r
{\r
  if (sizeof (UINTN) == sizeof (UINT32)) {\r
    return SafeInt64ToUint32 (Operand, (UINT32 *)Result);\r
  }\r
  return SafeInt64ToUint64 (Operand, (UINT64 *)Result);\r
}\r
\r
/**\r
  UINT64 -> UINTN conversion\r
\r
  Converts the value specified by Operand to a value specified by Result type\r
  and stores the converted value into the caller allocated output buffer\r
  specified by Result.  The caller must pass in a Result buffer that is at\r
  least as large as the Result type.\r
\r
  If Result is NULL, RETURN_INVALID_PARAMETER is returned.\r
\r
  If the conversion results in an overflow or an underflow condition, then\r
  Result is set to UINTN_ERROR and RETURN_BUFFER_TOO_SMALL is returned.\r
\r
  @param[in]   Operand  Operand to be converted to new type\r
  @param[out]  Result   Pointer to the result of conversion\r
\r
  @retval  RETURN_SUCCESS            Successful conversion\r
  @retval  RETURN_BUFFER_TOO_SMALL   Overflow\r
  @retval  RETURN_INVALID_PARAMETER  Result is NULL\r
**/\r
RETURN_STATUS\r
EFIAPI\r
SafeUint64ToUintn (\r
  IN  UINT64  Operand,\r
  OUT UINTN   *Result\r
  )\r
{\r
  if (Result == NULL) {\r
    return RETURN_INVALID_PARAMETER;\r
  }\r
\r
  if (sizeof (UINTN) == sizeof (UINT32)) {\r
    return SafeUint64ToUint32 ((UINT64) Operand, (UINT32 *)Result);\r
  }\r
  *Result = Operand;\r
  return RETURN_SUCCESS;\r
}\r
\r
/**\r
  UINTN addition\r
\r
  Performs the requested operation using the input parameters into a value\r
  specified by Result type and stores the converted value into the caller\r
  allocated output buffer specified by Result.  The caller must pass in a\r
  Result buffer that is at least as large as the Result type.\r
\r
  If Result is NULL, RETURN_INVALID_PARAMETER is returned.\r
\r
  If the requested operation results in an overflow or an underflow condition,\r
  then Result is set to UINTN_ERROR and RETURN_BUFFER_TOO_SMALL is returned.\r
\r
  @param[in]   Augend  A number to which addend will be added\r
  @param[in]   Addend  A number to be added to another\r
  @param[out]  Result  Pointer to the result of addition\r
\r
  @retval  RETURN_SUCCESS            Successful addition\r
  @retval  RETURN_BUFFER_TOO_SMALL   Overflow\r
  @retval  RETURN_INVALID_PARAMETER  Result is NULL\r
**/\r
RETURN_STATUS\r
EFIAPI\r
SafeUintnAdd (\r
  IN  UINTN  Augend,\r
  IN  UINTN  Addend,\r
  OUT UINTN  *Result\r
  )\r
{\r
  RETURN_STATUS  Status;\r
\r
  if (Result == NULL) {\r
    return RETURN_INVALID_PARAMETER;\r
  }\r
\r
  if (sizeof (UINTN) == sizeof (UINT32)) {\r
    if ((UINT32)(Augend + Addend) >= Augend) {\r
      *Result = (Augend + Addend);\r
      Status = RETURN_SUCCESS;\r
    } else {\r
      *Result = UINTN_ERROR;\r
      Status = RETURN_BUFFER_TOO_SMALL;\r
    }\r
\r
    return Status;\r
  }\r
  return SafeUint64Add ((UINT64)Augend, (UINT64)Addend, (UINT64 *)Result);\r
}\r
\r
/**\r
  UINTN subtraction\r
\r
  Performs the requested operation using the input parameters into a value\r
  specified by Result type and stores the converted value into the caller\r
  allocated output buffer specified by Result.  The caller must pass in a\r
  Result buffer that is at least as large as the Result type.\r
\r
  If Result is NULL, RETURN_INVALID_PARAMETER is returned.\r
\r
  If the requested operation results in an overflow or an underflow condition,\r
  then Result is set to UINTN_ERROR and RETURN_BUFFER_TOO_SMALL is returned.\r
\r
  @param[in]   Minuend     A number from which another is to be subtracted.\r
  @param[in]   Subtrahend  A number to be subtracted from another\r
  @param[out]  Result      Pointer to the result of subtraction\r
\r
  @retval  RETURN_SUCCESS            Successful subtraction\r
  @retval  RETURN_BUFFER_TOO_SMALL   Underflow\r
  @retval  RETURN_INVALID_PARAMETER  Result is NULL\r
**/\r
RETURN_STATUS\r
EFIAPI\r
SafeUintnSub (\r
  IN  UINTN  Minuend,\r
  IN  UINTN  Subtrahend,\r
  OUT UINTN  *Result\r
  )\r
{\r
  RETURN_STATUS  Status;\r
\r
  if (Result == NULL) {\r
    return RETURN_INVALID_PARAMETER;\r
  }\r
\r
  if (sizeof (UINTN) == sizeof (UINT32)) {\r
    if (Minuend >= Subtrahend) {\r
      *Result = (Minuend - Subtrahend);\r
      Status = RETURN_SUCCESS;\r
    } else {\r
      *Result = UINTN_ERROR;\r
      Status = RETURN_BUFFER_TOO_SMALL;\r
    }\r
\r
    return Status;\r
  }\r
  return SafeUint64Sub ((UINT64)Minuend, (UINT64)Subtrahend, (UINT64 *)Result);\r
}\r
\r
/**\r
  UINTN multiplication\r
\r
  Performs the requested operation using the input parameters into a value\r
  specified by Result type and stores the converted value into the caller\r
  allocated output buffer specified by Result.  The caller must pass in a\r
  Result buffer that is at least as large as the Result type.\r
\r
  If Result is NULL, RETURN_INVALID_PARAMETER is returned.\r
\r
  If the requested operation results in an overflow or an underflow condition,\r
  then Result is set to UINTN_ERROR and RETURN_BUFFER_TOO_SMALL is returned.\r
\r
  @param[in]   Multiplicand  A number that is to be multiplied by another\r
  @param[in]   Multiplier    A number by which the multiplicand is to be multiplied\r
  @param[out]  Result        Pointer to the result of multiplication\r
\r
  @retval  RETURN_SUCCESS            Successful multiplication\r
  @retval  RETURN_BUFFER_TOO_SMALL   Overflow\r
  @retval  RETURN_INVALID_PARAMETER  Result is NULL\r
**/\r
RETURN_STATUS\r
EFIAPI\r
SafeUintnMult (\r
  IN  UINTN  Multiplicand,\r
  IN  UINTN  Multiplier,\r
  OUT UINTN  *Result\r
  )\r
{\r
  UINT64  IntermediateResult;\r
\r
  if (sizeof (UINTN) == sizeof (UINT32)) {\r
    IntermediateResult = ((UINT64) Multiplicand) *((UINT64) Multiplier);\r
\r
    return SafeUint64ToUintn (IntermediateResult, Result);\r
  }\r
  return SafeUint64Mult ((UINT64)Multiplicand, (UINT64)Multiplier, (UINT64 *)Result);\r
}\r
\r
/**\r
  INTN Addition\r
\r
  Performs the requested operation using the input parameters into a value\r
  specified by Result type and stores the converted value into the caller\r
  allocated output buffer specified by Result.  The caller must pass in a\r
  Result buffer that is at least as large as the Result type.\r
\r
  If Result is NULL, RETURN_INVALID_PARAMETER is returned.\r
\r
  If the requested operation results in an overflow or an underflow condition,\r
  then Result is set to INTN_ERROR and RETURN_BUFFER_TOO_SMALL is returned.\r
\r
  @param[in]   Augend  A number to which addend will be added\r
  @param[in]   Addend  A number to be added to another\r
  @param[out]  Result  Pointer to the result of addition\r
\r
  @retval  RETURN_SUCCESS            Successful addition\r
  @retval  RETURN_BUFFER_TOO_SMALL   Overflow\r
  @retval  RETURN_INVALID_PARAMETER  Result is NULL\r
**/\r
RETURN_STATUS\r
EFIAPI\r
SafeIntnAdd (\r
  IN  INTN  Augend,\r
  IN  INTN  Addend,\r
  OUT INTN  *Result\r
  )\r
{\r
  if (sizeof (UINTN) == sizeof (UINT32)) {\r
    return SafeInt64ToIntn (((INT64)Augend) + ((INT64)Addend), Result);\r
  }\r
  return SafeInt64Add ((INT64)Augend, (INT64)Addend, (INT64 *)Result);\r
}\r
\r
/**\r
  INTN Subtraction\r
\r
  Performs the requested operation using the input parameters into a value\r
  specified by Result type and stores the converted value into the caller\r
  allocated output buffer specified by Result.  The caller must pass in a\r
  Result buffer that is at least as large as the Result type.\r
\r
  If Result is NULL, RETURN_INVALID_PARAMETER is returned.\r
\r
  If the requested operation results in an overflow or an underflow condition,\r
  then Result is set to INTN_ERROR and RETURN_BUFFER_TOO_SMALL is returned.\r
\r
  @param[in]   Minuend     A number from which another is to be subtracted.\r
  @param[in]   Subtrahend  A number to be subtracted from another\r
  @param[out]  Result      Pointer to the result of subtraction\r
\r
  @retval  RETURN_SUCCESS            Successful subtraction\r
  @retval  RETURN_BUFFER_TOO_SMALL   Underflow\r
  @retval  RETURN_INVALID_PARAMETER  Result is NULL\r
**/\r
RETURN_STATUS\r
EFIAPI\r
SafeIntnSub (\r
  IN  INTN  Minuend,\r
  IN  INTN  Subtrahend,\r
  OUT INTN  *Result\r
  )\r
{\r
  if (sizeof (UINTN) == sizeof (UINT32)) {\r
    return SafeInt64ToIntn (((INT64)Minuend) - ((INT64)Subtrahend), Result);\r
  }\r
  return SafeInt64Sub ((INT64)Minuend, (INT64)Subtrahend, (INT64 *)Result);\r
}\r
\r
/**\r
  INTN multiplication\r
\r
  Performs the requested operation using the input parameters into a value\r
  specified by Result type and stores the converted value into the caller\r
  allocated output buffer specified by Result.  The caller must pass in a\r
  Result buffer that is at least as large as the Result type.\r
\r
  If Result is NULL, RETURN_INVALID_PARAMETER is returned.\r
\r
  If the requested operation results in an overflow or an underflow condition,\r
  then Result is set to INTN_ERROR and RETURN_BUFFER_TOO_SMALL is returned.\r
\r
  @param[in]   Multiplicand  A number that is to be multiplied by another\r
  @param[in]   Multiplier    A number by which the multiplicand is to be multiplied\r
  @param[out]  Result        Pointer to the result of multiplication\r
\r
  @retval  RETURN_SUCCESS            Successful multiplication\r
  @retval  RETURN_BUFFER_TOO_SMALL   Overflow\r
  @retval  RETURN_INVALID_PARAMETER  Result is NULL\r
**/\r
RETURN_STATUS\r
EFIAPI\r
SafeIntnMult (\r
  IN  INTN  Multiplicand,\r
  IN  INTN  Multiplier,\r
  OUT INTN  *Result\r
  )\r
{\r
  if (sizeof (UINTN) == sizeof (UINT32)) {\r
    return SafeInt64ToIntn (((INT64)Multiplicand) *((INT64)Multiplier), Result);\r
  }\r
  return SafeInt64Mult ((INT64)Multiplicand, (INT64)Multiplier, (INT64 *)Result);\r
}\r
\r