UefiCpuPkg: Move AsmRelocateApLoopStart from Mpfuncs.nasm to AmdSev.nasm

[mirror_edk2.git] / NetworkPkg / IScsiDxe / IScsiCHAP.c

/** @file\r
  This file is for Challenge-Handshake Authentication Protocol (CHAP)\r
  Configuration.\r
\r
Copyright (c) 2004 - 2018, Intel Corporation. All rights reserved.<BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "IScsiImpl.h"\r
\r
//\r
// Supported CHAP hash algorithms, mapped to sets of BaseCryptLib APIs and\r
// macros. CHAP_HASH structures at lower subscripts in the array are preferred\r
// by the initiator.\r
//\r
STATIC CONST CHAP_HASH  mChapHash[] = {\r
  {\r
    ISCSI_CHAP_ALGORITHM_SHA256,\r
    SHA256_DIGEST_SIZE,\r
    Sha256GetContextSize,\r
    Sha256Init,\r
    Sha256Update,\r
    Sha256Final\r
  },\r
 #ifdef ENABLE_MD5_DEPRECATED_INTERFACES\r
  //\r
  // Keep the deprecated MD5 entry at the end of the array (making MD5 the\r
  // least preferred choice of the initiator).\r
  //\r
  {\r
    ISCSI_CHAP_ALGORITHM_MD5,\r
    MD5_DIGEST_SIZE,\r
    Md5GetContextSize,\r
    Md5Init,\r
    Md5Update,\r
    Md5Final\r
  },\r
 #endif // ENABLE_MD5_DEPRECATED_INTERFACES\r
};\r
\r
//\r
// Ordered list of mChapHash[*].Algorithm values. It is formatted for the\r
// CHAP_A=<A1,A2...> value string, by the IScsiCHAPInitHashList() function. It\r
// is sent by the initiator in ISCSI_CHAP_STEP_ONE.\r
//\r
STATIC CHAR8  mChapHashListString[\r
                                  3 +                                      // UINT8 identifier in\r
                                                                           //   decimal\r
                                  (1 + 3) * (ARRAY_SIZE (mChapHash) - 1) + // comma prepended for\r
                                                                           //   entries after the\r
                                                                           //   first\r
                                  1 +                                      // extra character for\r
                                                                           //   AsciiSPrint()\r
                                                                           //   truncation check\r
                                  1                                        // terminating NUL\r
];\r
\r
/**\r
  Initiator calculates its own expected hash value.\r
\r
  @param[in]   ChapIdentifier     iSCSI CHAP identifier sent by authenticator.\r
  @param[in]   ChapSecret         iSCSI CHAP secret of the authenticator.\r
  @param[in]   SecretLength       The length of iSCSI CHAP secret.\r
  @param[in]   ChapChallenge      The challenge message sent by authenticator.\r
  @param[in]   ChallengeLength    The length of iSCSI CHAP challenge message.\r
  @param[in]   Hash               Pointer to the CHAP_HASH structure that\r
                                  determines the hashing algorithm to use. The\r
                                  caller is responsible for making Hash point\r
                                  to an "mChapHash" element.\r
  @param[out]  ChapResponse       The calculation of the expected hash value.\r
\r
  @retval EFI_SUCCESS             The expected hash value was calculatedly\r
                                  successfully.\r
  @retval EFI_PROTOCOL_ERROR      The length of the secret should be at least\r
                                  the length of the hash value for the hashing\r
                                  algorithm chosen.\r
  @retval EFI_PROTOCOL_ERROR      Hash operation fails.\r
  @retval EFI_OUT_OF_RESOURCES    Failure to allocate resource to complete\r
                                  hashing.\r
\r
**/\r
EFI_STATUS\r
IScsiCHAPCalculateResponse (\r
  IN  UINT32           ChapIdentifier,\r
  IN  CHAR8            *ChapSecret,\r
  IN  UINT32           SecretLength,\r
  IN  UINT8            *ChapChallenge,\r
  IN  UINT32           ChallengeLength,\r
  IN  CONST CHAP_HASH  *Hash,\r
  OUT UINT8            *ChapResponse\r
  )\r
{\r
  UINTN       ContextSize;\r
  VOID        *Ctx;\r
  CHAR8       IdByte[1];\r
  EFI_STATUS  Status;\r
\r
  if (SecretLength < ISCSI_CHAP_SECRET_MIN_LEN) {\r
    return EFI_PROTOCOL_ERROR;\r
  }\r
\r
  ASSERT (Hash != NULL);\r
\r
  ContextSize = Hash->GetContextSize ();\r
  Ctx         = AllocatePool (ContextSize);\r
  if (Ctx == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  Status = EFI_PROTOCOL_ERROR;\r
\r
  if (!Hash->Init (Ctx)) {\r
    goto Exit;\r
  }\r
\r
  //\r
  // Hash Identifier - Only calculate 1 byte data (RFC1994)\r
  //\r
  IdByte[0] = (CHAR8)ChapIdentifier;\r
  if (!Hash->Update (Ctx, IdByte, 1)) {\r
    goto Exit;\r
  }\r
\r
  //\r
  // Hash Secret\r
  //\r
  if (!Hash->Update (Ctx, ChapSecret, SecretLength)) {\r
    goto Exit;\r
  }\r
\r
  //\r
  // Hash Challenge received from Target\r
  //\r
  if (!Hash->Update (Ctx, ChapChallenge, ChallengeLength)) {\r
    goto Exit;\r
  }\r
\r
  if (Hash->Final (Ctx, ChapResponse)) {\r
    Status = EFI_SUCCESS;\r
  }\r
\r
Exit:\r
  FreePool (Ctx);\r
  return Status;\r
}\r
\r
/**\r
  The initiator checks the CHAP response replied by target against its own\r
  calculation of the expected hash value.\r
\r
  @param[in]   AuthData             iSCSI CHAP authentication data.\r
  @param[in]   TargetResponse       The response from target.\r
\r
  @retval EFI_SUCCESS               The response from target passed\r
                                    authentication.\r
  @retval EFI_SECURITY_VIOLATION    The response from target was not expected\r
                                    value.\r
  @retval Others                    Other errors as indicated.\r
\r
**/\r
EFI_STATUS\r
IScsiCHAPAuthTarget (\r
  IN  ISCSI_CHAP_AUTH_DATA  *AuthData,\r
  IN  UINT8                 *TargetResponse\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINT32      SecretSize;\r
  UINT8       VerifyRsp[ISCSI_CHAP_MAX_DIGEST_SIZE];\r
  INTN        Mismatch;\r
\r
  Status = EFI_SUCCESS;\r
\r
  SecretSize = (UINT32)AsciiStrLen (AuthData->AuthConfig->ReverseCHAPSecret);\r
\r
  ASSERT (AuthData->Hash != NULL);\r
\r
  Status = IScsiCHAPCalculateResponse (\r
             AuthData->OutIdentifier,\r
             AuthData->AuthConfig->ReverseCHAPSecret,\r
             SecretSize,\r
             AuthData->OutChallenge,\r
             AuthData->Hash->DigestSize,              // ChallengeLength\r
             AuthData->Hash,\r
             VerifyRsp\r
             );\r
\r
  Mismatch = CompareMem (\r
               VerifyRsp,\r
               TargetResponse,\r
               AuthData->Hash->DigestSize\r
               );\r
  if (Mismatch != 0) {\r
    Status = EFI_SECURITY_VIOLATION;\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  This function checks the received iSCSI Login Response during the security\r
  negotiation stage.\r
\r
  @param[in] Conn             The iSCSI connection.\r
\r
  @retval EFI_SUCCESS          The Login Response passed the CHAP validation.\r
  @retval EFI_OUT_OF_RESOURCES Failed to allocate memory.\r
  @retval EFI_PROTOCOL_ERROR   Some kind of protocol error occurred.\r
  @retval Others               Other errors as indicated.\r
\r
**/\r
EFI_STATUS\r
IScsiCHAPOnRspReceived (\r
  IN ISCSI_CONNECTION  *Conn\r
  )\r
{\r
  EFI_STATUS            Status;\r
  ISCSI_SESSION         *Session;\r
  ISCSI_CHAP_AUTH_DATA  *AuthData;\r
  CHAR8                 *Value;\r
  UINT8                 *Data;\r
  UINT32                Len;\r
  LIST_ENTRY            *KeyValueList;\r
  UINTN                 Algorithm;\r
  CHAR8                 *Identifier;\r
  CHAR8                 *Challenge;\r
  CHAR8                 *Name;\r
  CHAR8                 *Response;\r
  UINT8                 TargetRsp[ISCSI_CHAP_MAX_DIGEST_SIZE];\r
  UINT32                RspLen;\r
  UINTN                 Result;\r
  UINTN                 HashIndex;\r
\r
  ASSERT (Conn->CurrentStage == ISCSI_SECURITY_NEGOTIATION);\r
  ASSERT (Conn->RspQue.BufNum != 0);\r
\r
  Session  = Conn->Session;\r
  AuthData = &Session->AuthData.CHAP;\r
  Len      = Conn->RspQue.BufSize;\r
  Data     = AllocateZeroPool (Len);\r
  if (Data == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  //\r
  // Copy the data in case the data spans over multiple PDUs.\r
  //\r
  NetbufQueCopy (&Conn->RspQue, 0, Len, Data);\r
\r
  //\r
  // Build the key-value list from the data segment of the Login Response.\r
  //\r
  KeyValueList = IScsiBuildKeyValueList ((CHAR8 *)Data, Len);\r
  if (KeyValueList == NULL) {\r
    Status = EFI_OUT_OF_RESOURCES;\r
    goto ON_EXIT;\r
  }\r
\r
  Status = EFI_PROTOCOL_ERROR;\r
\r
  switch (Conn->AuthStep) {\r
    case ISCSI_AUTH_INITIAL:\r
      //\r
      // The first Login Response.\r
      //\r
      Value = IScsiGetValueByKeyFromList (\r
                KeyValueList,\r
                ISCSI_KEY_TARGET_PORTAL_GROUP_TAG\r
                );\r
      if (Value == NULL) {\r
        goto ON_EXIT;\r
      }\r
\r
      Result = IScsiNetNtoi (Value);\r
      if (Result > 0xFFFF) {\r
        goto ON_EXIT;\r
      }\r
\r
      Session->TargetPortalGroupTag = (UINT16)Result;\r
\r
      Value = IScsiGetValueByKeyFromList (\r
                KeyValueList,\r
                ISCSI_KEY_AUTH_METHOD\r
                );\r
      if (Value == NULL) {\r
        goto ON_EXIT;\r
      }\r
\r
      //\r
      // Initiator mandates CHAP authentication but target replies without\r
      // "CHAP", or initiator suggets "None" but target replies with some kind of\r
      // auth method.\r
      //\r
      if (Session->AuthType == ISCSI_AUTH_TYPE_NONE) {\r
        if (AsciiStrCmp (Value, ISCSI_KEY_VALUE_NONE) != 0) {\r
          goto ON_EXIT;\r
        }\r
      } else if (Session->AuthType == ISCSI_AUTH_TYPE_CHAP) {\r
        if (AsciiStrCmp (Value, ISCSI_AUTH_METHOD_CHAP) != 0) {\r
          goto ON_EXIT;\r
        }\r
      } else {\r
        goto ON_EXIT;\r
      }\r
\r
      //\r
      // Transit to CHAP step one.\r
      //\r
      Conn->AuthStep = ISCSI_CHAP_STEP_ONE;\r
      Status         = EFI_SUCCESS;\r
      break;\r
\r
    case ISCSI_CHAP_STEP_TWO:\r
      //\r
      // The Target replies with CHAP_A=<A> CHAP_I=<I> CHAP_C=<C>\r
      //\r
      Value = IScsiGetValueByKeyFromList (\r
                KeyValueList,\r
                ISCSI_KEY_CHAP_ALGORITHM\r
                );\r
      if (Value == NULL) {\r
        goto ON_EXIT;\r
      }\r
\r
      Algorithm = IScsiNetNtoi (Value);\r
      for (HashIndex = 0; HashIndex < ARRAY_SIZE (mChapHash); HashIndex++) {\r
        if (Algorithm == mChapHash[HashIndex].Algorithm) {\r
          break;\r
        }\r
      }\r
\r
      if (HashIndex == ARRAY_SIZE (mChapHash)) {\r
        //\r
        // Unsupported algorithm is chosen by target.\r
        //\r
        goto ON_EXIT;\r
      }\r
\r
      //\r
      // Remember the target's chosen hash algorithm.\r
      //\r
      ASSERT (AuthData->Hash == NULL);\r
      AuthData->Hash = &mChapHash[HashIndex];\r
\r
      Identifier = IScsiGetValueByKeyFromList (\r
                     KeyValueList,\r
                     ISCSI_KEY_CHAP_IDENTIFIER\r
                     );\r
      if (Identifier == NULL) {\r
        goto ON_EXIT;\r
      }\r
\r
      Challenge = IScsiGetValueByKeyFromList (\r
                    KeyValueList,\r
                    ISCSI_KEY_CHAP_CHALLENGE\r
                    );\r
      if (Challenge == NULL) {\r
        goto ON_EXIT;\r
      }\r
\r
      //\r
      // Process the CHAP identifier and CHAP Challenge from Target.\r
      // Calculate Response value.\r
      //\r
      Result = IScsiNetNtoi (Identifier);\r
      if (Result > 0xFF) {\r
        goto ON_EXIT;\r
      }\r
\r
      AuthData->InIdentifier      = (UINT32)Result;\r
      AuthData->InChallengeLength = (UINT32)sizeof (AuthData->InChallenge);\r
      Status                      = IScsiHexToBin (\r
                                      (UINT8 *)AuthData->InChallenge,\r
                                      &AuthData->InChallengeLength,\r
                                      Challenge\r
                                      );\r
      if (EFI_ERROR (Status)) {\r
        Status = EFI_PROTOCOL_ERROR;\r
        goto ON_EXIT;\r
      }\r
\r
      Status = IScsiCHAPCalculateResponse (\r
                 AuthData->InIdentifier,\r
                 AuthData->AuthConfig->CHAPSecret,\r
                 (UINT32)AsciiStrLen (AuthData->AuthConfig->CHAPSecret),\r
                 AuthData->InChallenge,\r
                 AuthData->InChallengeLength,\r
                 AuthData->Hash,\r
                 AuthData->CHAPResponse\r
                 );\r
\r
      //\r
      // Transit to next step.\r
      //\r
      Conn->AuthStep = ISCSI_CHAP_STEP_THREE;\r
      break;\r
\r
    case ISCSI_CHAP_STEP_THREE:\r
      //\r
      // One way CHAP authentication and the target would like to\r
      // authenticate us.\r
      //\r
      Status = EFI_SUCCESS;\r
      break;\r
\r
    case ISCSI_CHAP_STEP_FOUR:\r
      ASSERT (AuthData->AuthConfig->CHAPType == ISCSI_CHAP_MUTUAL);\r
      //\r
      // The forth step, CHAP_N=<N> CHAP_R=<R> is received from Target.\r
      //\r
      Name = IScsiGetValueByKeyFromList (KeyValueList, ISCSI_KEY_CHAP_NAME);\r
      if (Name == NULL) {\r
        goto ON_EXIT;\r
      }\r
\r
      Response = IScsiGetValueByKeyFromList (\r
                   KeyValueList,\r
                   ISCSI_KEY_CHAP_RESPONSE\r
                   );\r
      if (Response == NULL) {\r
        goto ON_EXIT;\r
      }\r
\r
      ASSERT (AuthData->Hash != NULL);\r
      RspLen = AuthData->Hash->DigestSize;\r
      Status = IScsiHexToBin (TargetRsp, &RspLen, Response);\r
      if (EFI_ERROR (Status) || (RspLen != AuthData->Hash->DigestSize)) {\r
        Status = EFI_PROTOCOL_ERROR;\r
        goto ON_EXIT;\r
      }\r
\r
      //\r
      // Check the CHAP Name and Response replied by Target.\r
      //\r
      Status = IScsiCHAPAuthTarget (AuthData, TargetRsp);\r
      break;\r
\r
    default:\r
      break;\r
  }\r
\r
ON_EXIT:\r
\r
  if (KeyValueList != NULL) {\r
    IScsiFreeKeyValueList (KeyValueList);\r
  }\r
\r
  FreePool (Data);\r
\r
  return Status;\r
}\r
\r
/**\r
  This function fills the CHAP authentication information into the login PDU\r
  during the security negotiation stage in the iSCSI connection login.\r
\r
  @param[in]       Conn        The iSCSI connection.\r
  @param[in, out]  Pdu         The PDU to send out.\r
\r
  @retval EFI_SUCCESS           All check passed and the phase-related CHAP\r
                                authentication info is filled into the iSCSI\r
                                PDU.\r
  @retval EFI_OUT_OF_RESOURCES  Failed to allocate memory.\r
  @retval EFI_PROTOCOL_ERROR    Some kind of protocol error occurred.\r
\r
**/\r
EFI_STATUS\r
IScsiCHAPToSendReq (\r
  IN      ISCSI_CONNECTION  *Conn,\r
  IN OUT  NET_BUF           *Pdu\r
  )\r
{\r
  EFI_STATUS            Status;\r
  ISCSI_SESSION         *Session;\r
  ISCSI_LOGIN_REQUEST   *LoginReq;\r
  ISCSI_CHAP_AUTH_DATA  *AuthData;\r
  CHAR8                 *Value;\r
  CHAR8                 ValueStr[256];\r
  CHAR8                 *Response;\r
  UINT32                RspLen;\r
  CHAR8                 *Challenge;\r
  UINT32                ChallengeLen;\r
  EFI_STATUS            BinToHexStatus;\r
\r
  ASSERT (Conn->CurrentStage == ISCSI_SECURITY_NEGOTIATION);\r
\r
  Session  = Conn->Session;\r
  AuthData = &Session->AuthData.CHAP;\r
  LoginReq = (ISCSI_LOGIN_REQUEST *)NetbufGetByte (Pdu, 0, 0);\r
  if (LoginReq == NULL) {\r
    return EFI_PROTOCOL_ERROR;\r
  }\r
\r
  Status = EFI_SUCCESS;\r
\r
  RspLen   = 2 * ISCSI_CHAP_MAX_DIGEST_SIZE + 3;\r
  Response = AllocateZeroPool (RspLen);\r
  if (Response == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  ChallengeLen = 2 * ISCSI_CHAP_MAX_DIGEST_SIZE + 3;\r
  Challenge    = AllocateZeroPool (ChallengeLen);\r
  if (Challenge == NULL) {\r
    FreePool (Response);\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  switch (Conn->AuthStep) {\r
    case ISCSI_AUTH_INITIAL:\r
      //\r
      // It's the initial Login Request. Fill in the key=value pairs mandatory\r
      // for the initial Login Request.\r
      //\r
      IScsiAddKeyValuePair (\r
        Pdu,\r
        ISCSI_KEY_INITIATOR_NAME,\r
        mPrivate->InitiatorName\r
        );\r
      IScsiAddKeyValuePair (Pdu, ISCSI_KEY_SESSION_TYPE, "Normal");\r
      IScsiAddKeyValuePair (\r
        Pdu,\r
        ISCSI_KEY_TARGET_NAME,\r
        Session->ConfigData->SessionConfigData.TargetName\r
        );\r
\r
      if (Session->AuthType == ISCSI_AUTH_TYPE_NONE) {\r
        Value = ISCSI_KEY_VALUE_NONE;\r
        ISCSI_SET_FLAG (LoginReq, ISCSI_LOGIN_REQ_PDU_FLAG_TRANSIT);\r
      } else {\r
        Value = ISCSI_AUTH_METHOD_CHAP;\r
      }\r
\r
      IScsiAddKeyValuePair (Pdu, ISCSI_KEY_AUTH_METHOD, Value);\r
\r
      break;\r
\r
    case ISCSI_CHAP_STEP_ONE:\r
      //\r
      // First step, send the Login Request with CHAP_A=<A1,A2...> key-value\r
      // pair.\r
      //\r
      IScsiAddKeyValuePair (Pdu, ISCSI_KEY_CHAP_ALGORITHM, mChapHashListString);\r
\r
      Conn->AuthStep = ISCSI_CHAP_STEP_TWO;\r
      break;\r
\r
    case ISCSI_CHAP_STEP_THREE:\r
      //\r
      // Third step, send the Login Request with CHAP_N=<N> CHAP_R=<R> or\r
      // CHAP_N=<N> CHAP_R=<R> CHAP_I=<I> CHAP_C=<C> if target authentication is\r
      // required too.\r
      //\r
      // CHAP_N=<N>\r
      //\r
      IScsiAddKeyValuePair (\r
        Pdu,\r
        ISCSI_KEY_CHAP_NAME,\r
        (CHAR8 *)&AuthData->AuthConfig->CHAPName\r
        );\r
      //\r
      // CHAP_R=<R>\r
      //\r
      ASSERT (AuthData->Hash != NULL);\r
      BinToHexStatus = IScsiBinToHex (\r
                         (UINT8 *)AuthData->CHAPResponse,\r
                         AuthData->Hash->DigestSize,\r
                         Response,\r
                         &RspLen\r
                         );\r
      ASSERT_EFI_ERROR (BinToHexStatus);\r
      IScsiAddKeyValuePair (Pdu, ISCSI_KEY_CHAP_RESPONSE, Response);\r
\r
      if (AuthData->AuthConfig->CHAPType == ISCSI_CHAP_MUTUAL) {\r
        //\r
        // CHAP_I=<I>\r
        //\r
        IScsiGenRandom ((UINT8 *)&AuthData->OutIdentifier, 1);\r
        AsciiSPrint (ValueStr, sizeof (ValueStr), "%d", AuthData->OutIdentifier);\r
        IScsiAddKeyValuePair (Pdu, ISCSI_KEY_CHAP_IDENTIFIER, ValueStr);\r
        //\r
        // CHAP_C=<C>\r
        //\r
        IScsiGenRandom (\r
          (UINT8 *)AuthData->OutChallenge,\r
          AuthData->Hash->DigestSize\r
          );\r
        BinToHexStatus = IScsiBinToHex (\r
                           (UINT8 *)AuthData->OutChallenge,\r
                           AuthData->Hash->DigestSize,\r
                           Challenge,\r
                           &ChallengeLen\r
                           );\r
        ASSERT_EFI_ERROR (BinToHexStatus);\r
        IScsiAddKeyValuePair (Pdu, ISCSI_KEY_CHAP_CHALLENGE, Challenge);\r
\r
        Conn->AuthStep = ISCSI_CHAP_STEP_FOUR;\r
      }\r
\r
      //\r
      // Set the stage transition flag.\r
      //\r
      ISCSI_SET_FLAG (LoginReq, ISCSI_LOGIN_REQ_PDU_FLAG_TRANSIT);\r
      break;\r
\r
    default:\r
      Status = EFI_PROTOCOL_ERROR;\r
      break;\r
  }\r
\r
  FreePool (Response);\r
  FreePool (Challenge);\r
\r
  return Status;\r
}\r
\r
/**\r
  Initialize the CHAP_A=<A1,A2...> *value* string for the entire driver, to be\r
  sent by the initiator in ISCSI_CHAP_STEP_ONE.\r
\r
  This function sanity-checks the internal table of supported CHAP hashing\r
  algorithms, as well.\r
**/\r
VOID\r
IScsiCHAPInitHashList (\r
  VOID\r
  )\r
{\r
  CHAR8            *Position;\r
  UINTN            Left;\r
  UINTN            HashIndex;\r
  CONST CHAP_HASH  *Hash;\r
  UINTN            Printed;\r
\r
  Position = mChapHashListString;\r
  Left     = sizeof (mChapHashListString);\r
  for (HashIndex = 0; HashIndex < ARRAY_SIZE (mChapHash); HashIndex++) {\r
    Hash = &mChapHash[HashIndex];\r
\r
    //\r
    // Format the next hash identifier.\r
    //\r
    // Assert that we can format at least one non-NUL character, i.e. that we\r
    // can progress. Truncation is checked after printing.\r
    //\r
    ASSERT (Left >= 2);\r
    Printed = AsciiSPrint (\r
                Position,\r
                Left,\r
                "%a%d",\r
                (HashIndex == 0) ? "" : ",",\r
                Hash->Algorithm\r
                );\r
    //\r
    // There's no way to differentiate between the "buffer filled to the brim,\r
    // but not truncated" result and the "truncated" result of AsciiSPrint().\r
    // This is why "mChapHashListString" has an extra byte allocated, and the\r
    // reason why we use the less-than (rather than the less-than-or-equal-to)\r
    // relational operator in the assertion below -- we enforce "no truncation"\r
    // by excluding the "completely used up" case too.\r
    //\r
    ASSERT (Printed + 1 < Left);\r
\r
    Position += Printed;\r
    Left     -= Printed;\r
\r
    //\r
    // Sanity-check the digest size for Hash.\r
    //\r
    ASSERT (Hash->DigestSize <= ISCSI_CHAP_MAX_DIGEST_SIZE);\r
  }\r
}\r