VirtualBox

Ignore:
Timestamp:
Apr 14, 2023 3:17:44 PM (22 months ago)
Author:
vboxsync
Message:

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643

Location:
trunk/src/VBox/Devices/EFI/FirmwareNew
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/EFI/FirmwareNew

  • trunk/src/VBox/Devices/EFI/FirmwareNew/NetworkPkg/TlsDxe/TlsProtocol.c

    r85718 r99404  
    4646EFIAPI
    4747TlsSetSessionData (
    48   IN     EFI_TLS_PROTOCOL              *This,
    49   IN     EFI_TLS_SESSION_DATA_TYPE     DataType,
    50   IN     VOID                          *Data,
    51   IN     UINTN                         DataSize
     48  IN     EFI_TLS_PROTOCOL           *This,
     49  IN     EFI_TLS_SESSION_DATA_TYPE  DataType,
     50  IN     VOID                       *Data,
     51  IN     UINTN                      DataSize
    5252  )
    5353{
    54   EFI_STATUS                Status;
    55   TLS_INSTANCE              *Instance;
    56   UINT16                    *CipherId;
    57   CONST EFI_TLS_CIPHER      *TlsCipherList;
    58   UINTN                     CipherCount;
    59   CONST EFI_TLS_VERIFY_HOST *TlsVerifyHost;
    60   EFI_TLS_VERIFY            VerifyMethod;
    61   UINTN                     VerifyMethodSize;
    62   UINTN                     Index;
    63 
    64   EFI_TPL                   OldTpl;
     54  EFI_STATUS                 Status;
     55  TLS_INSTANCE               *Instance;
     56  UINT16                     *CipherId;
     57  CONST EFI_TLS_CIPHER       *TlsCipherList;
     58  UINTN                      CipherCount;
     59  CONST EFI_TLS_VERIFY_HOST  *TlsVerifyHost;
     60  EFI_TLS_VERIFY             VerifyMethod;
     61  UINTN                      VerifyMethodSize;
     62  UINTN                      Index;
     63
     64  EFI_TPL  OldTpl;
    6565
    6666  Status           = EFI_SUCCESS;
    … …  
    6868  VerifyMethodSize = sizeof (EFI_TLS_VERIFY);
    6969
    70   if (This == NULL || Data == NULL || DataSize == 0) {
     70  if ((This == NULL) || (Data == NULL) || (DataSize == 0)) {
    7171    return EFI_INVALID_PARAMETER;
    7272  }
    … …  
    7676  Instance = TLS_INSTANCE_FROM_PROTOCOL (This);
    7777
    78   if (DataType != EfiTlsSessionState  && Instance->TlsSessionState != EfiTlsSessionNotStarted){
     78  if ((DataType != EfiTlsSessionState) && (Instance->TlsSessionState != EfiTlsSessionNotStarted)) {
    7979    Status = EFI_NOT_READY;
    8080    goto ON_EXIT;
    … …  
    8282
    8383  switch (DataType) {
    84   //
    85   // Session Configuration
    86   //
    87   case EfiTlsVersion:
    88     if (DataSize != sizeof (EFI_TLS_VERSION)) {
    89       Status = EFI_INVALID_PARAMETER;
     84    //
     85    // Session Configuration
     86    //
     87    case EfiTlsVersion:
     88      if (DataSize != sizeof (EFI_TLS_VERSION)) {
     89        Status = EFI_INVALID_PARAMETER;
     90        goto ON_EXIT;
     91      }
     92
     93      Status = TlsSetVersion (Instance->TlsConn, ((EFI_TLS_VERSION *)Data)->Major, ((EFI_TLS_VERSION *)Data)->Minor);
     94      break;
     95    case EfiTlsConnectionEnd:
     96      if (DataSize != sizeof (EFI_TLS_CONNECTION_END)) {
     97        Status = EFI_INVALID_PARAMETER;
     98        goto ON_EXIT;
     99      }
     100
     101      Status = TlsSetConnectionEnd (Instance->TlsConn, *((EFI_TLS_CONNECTION_END *)Data));
     102      break;
     103    case EfiTlsCipherList:
     104      if (DataSize % sizeof (EFI_TLS_CIPHER) != 0) {
     105        Status = EFI_INVALID_PARAMETER;
     106        goto ON_EXIT;
     107      }
     108
     109      CipherId = AllocatePool (DataSize);
     110      if (CipherId == NULL) {
     111        Status = EFI_OUT_OF_RESOURCES;
     112        goto ON_EXIT;
     113      }
     114
     115      TlsCipherList = (CONST EFI_TLS_CIPHER *)Data;
     116      CipherCount   = DataSize / sizeof (EFI_TLS_CIPHER);
     117      for (Index = 0; Index < CipherCount; Index++) {
     118        CipherId[Index] = ((TlsCipherList[Index].Data1 << 8) |
     119                           TlsCipherList[Index].Data2);
     120      }
     121
     122      Status = TlsSetCipherList (Instance->TlsConn, CipherId, CipherCount);
     123
     124      FreePool (CipherId);
     125      break;
     126    case EfiTlsCompressionMethod:
     127      //
     128      // TLS seems only define one CompressionMethod.null, which specifies that data exchanged via the
     129      // record protocol will not be compressed.
     130      // More information from OpenSSL: http://www.openssl.org/docs/manmaster/ssl/SSL_COMP_add_compression_method.html
     131      // The TLS RFC does however not specify compression methods or their corresponding identifiers,
     132      // so there is currently no compatible way to integrate compression with unknown peers.
     133      // It is therefore currently not recommended to integrate compression into applications.
     134      // Applications for non-public use may agree on certain compression methods.
     135      // Using different compression methods with the same identifier will lead to connection failure.
     136      //
     137      for (Index = 0; Index < DataSize / sizeof (EFI_TLS_COMPRESSION); Index++) {
     138        Status = TlsSetCompressionMethod (*((UINT8 *)Data + Index));
     139        if (EFI_ERROR (Status)) {
     140          break;
     141        }
     142      }
     143
     144      break;
     145    case EfiTlsExtensionData:
     146      Status = EFI_UNSUPPORTED;
    90147      goto ON_EXIT;
    91     }
    92 
    93     Status = TlsSetVersion (Instance->TlsConn, ((EFI_TLS_VERSION *) Data)->Major, ((EFI_TLS_VERSION *) Data)->Minor);
    94     break;
    95   case EfiTlsConnectionEnd:
    96     if (DataSize != sizeof (EFI_TLS_CONNECTION_END)) {
    97       Status = EFI_INVALID_PARAMETER;
    98       goto ON_EXIT;
    99     }
    100 
    101     Status = TlsSetConnectionEnd (Instance->TlsConn, *((EFI_TLS_CONNECTION_END *) Data));
    102     break;
    103   case EfiTlsCipherList:
    104     if (DataSize % sizeof (EFI_TLS_CIPHER) != 0) {
    105       Status = EFI_INVALID_PARAMETER;
    106       goto ON_EXIT;
    107     }
    108 
    109     CipherId = AllocatePool (DataSize);
    110     if (CipherId == NULL) {
    111       Status = EFI_OUT_OF_RESOURCES;
    112       goto ON_EXIT;
    113     }
    114 
    115     TlsCipherList = (CONST EFI_TLS_CIPHER *) Data;
    116     CipherCount = DataSize / sizeof (EFI_TLS_CIPHER);
    117     for (Index = 0; Index < CipherCount; Index++) {
    118       CipherId[Index] = ((TlsCipherList[Index].Data1 << 8) |
    119                          TlsCipherList[Index].Data2);
    120     }
    121 
    122     Status = TlsSetCipherList (Instance->TlsConn, CipherId, CipherCount);
    123 
    124     FreePool (CipherId);
    125     break;
    126   case EfiTlsCompressionMethod:
    127     //
    128     // TLS seems only define one CompressionMethod.null, which specifies that data exchanged via the
    129     // record protocol will not be compressed.
    130     // More information from OpenSSL: http://www.openssl.org/docs/manmaster/ssl/SSL_COMP_add_compression_method.html
    131     // The TLS RFC does however not specify compression methods or their corresponding identifiers,
    132     // so there is currently no compatible way to integrate compression with unknown peers.
    133     // It is therefore currently not recommended to integrate compression into applications.
    134     // Applications for non-public use may agree on certain compression methods.
    135     // Using different compression methods with the same identifier will lead to connection failure.
    136     //
    137     for (Index = 0; Index < DataSize / sizeof (EFI_TLS_COMPRESSION); Index++) {
    138       Status = TlsSetCompressionMethod (*((UINT8 *) Data + Index));
     148    case EfiTlsVerifyMethod:
     149      if (DataSize != sizeof (EFI_TLS_VERIFY)) {
     150        Status = EFI_INVALID_PARAMETER;
     151        goto ON_EXIT;
     152      }
     153
     154      TlsSetVerify (Instance->TlsConn, *((UINT32 *)Data));
     155      break;
     156    case EfiTlsVerifyHost:
     157      if (DataSize != sizeof (EFI_TLS_VERIFY_HOST)) {
     158        Status = EFI_INVALID_PARAMETER;
     159        goto ON_EXIT;
     160      }
     161
     162      TlsVerifyHost = (CONST EFI_TLS_VERIFY_HOST *)Data;
     163
     164      if (((TlsVerifyHost->Flags & EFI_TLS_VERIFY_FLAG_ALWAYS_CHECK_SUBJECT) != 0) &&
     165          ((TlsVerifyHost->Flags & EFI_TLS_VERIFY_FLAG_NEVER_CHECK_SUBJECT) != 0))
     166      {
     167        Status = EFI_INVALID_PARAMETER;
     168        goto ON_EXIT;
     169      }
     170
     171      if (((TlsVerifyHost->Flags & EFI_TLS_VERIFY_FLAG_NO_WILDCARDS) != 0) &&
     172          (((TlsVerifyHost->Flags & EFI_TLS_VERIFY_FLAG_NO_PARTIAL_WILDCARDS) != 0) ||
     173           ((TlsVerifyHost->Flags & EFI_TLS_VERIFY_FLAG_MULTI_LABEL_WILDCARDS) != 0)))
     174      {
     175        Status = EFI_INVALID_PARAMETER;
     176        goto ON_EXIT;
     177      }
     178
     179      Status = This->GetSessionData (This, EfiTlsVerifyMethod, &VerifyMethod, &VerifyMethodSize);
    139180      if (EFI_ERROR (Status)) {
    140         break;
    141       }
    142     }
    143 
    144     break;
    145   case EfiTlsExtensionData:
    146     Status = EFI_UNSUPPORTED;
    147     goto ON_EXIT;
    148   case EfiTlsVerifyMethod:
    149     if (DataSize != sizeof (EFI_TLS_VERIFY)) {
    150       Status = EFI_INVALID_PARAMETER;
    151       goto ON_EXIT;
    152     }
    153 
    154     TlsSetVerify (Instance->TlsConn, *((UINT32 *) Data));
    155     break;
    156   case EfiTlsVerifyHost:
    157     if (DataSize != sizeof (EFI_TLS_VERIFY_HOST)) {
    158       Status = EFI_INVALID_PARAMETER;
    159       goto ON_EXIT;
    160     }
    161 
    162     TlsVerifyHost = (CONST EFI_TLS_VERIFY_HOST *) Data;
    163 
    164     if ((TlsVerifyHost->Flags & EFI_TLS_VERIFY_FLAG_ALWAYS_CHECK_SUBJECT) != 0 &&
    165         (TlsVerifyHost->Flags & EFI_TLS_VERIFY_FLAG_NEVER_CHECK_SUBJECT) != 0) {
    166       Status = EFI_INVALID_PARAMETER;
    167       goto ON_EXIT;
    168     }
    169 
    170     if ((TlsVerifyHost->Flags & EFI_TLS_VERIFY_FLAG_NO_WILDCARDS) != 0 &&
    171         ((TlsVerifyHost->Flags & EFI_TLS_VERIFY_FLAG_NO_PARTIAL_WILDCARDS) != 0 ||
    172          (TlsVerifyHost->Flags & EFI_TLS_VERIFY_FLAG_MULTI_LABEL_WILDCARDS) != 0)) {
    173       Status = EFI_INVALID_PARAMETER;
    174       goto ON_EXIT;
    175     }
    176 
    177     Status = This->GetSessionData (This, EfiTlsVerifyMethod, &VerifyMethod, &VerifyMethodSize);
    178     if (EFI_ERROR (Status)) {
    179       goto ON_EXIT;
    180     }
    181 
    182     if ((VerifyMethod & EFI_TLS_VERIFY_PEER) == 0) {
    183       Status = EFI_INVALID_PARAMETER;
    184       goto ON_EXIT;
    185     }
    186 
    187     Status = TlsSetVerifyHost (Instance->TlsConn, TlsVerifyHost->Flags, TlsVerifyHost->HostName);
    188 
    189     break;
    190   case EfiTlsSessionID:
    191     if (DataSize != sizeof (EFI_TLS_SESSION_ID)) {
    192       Status = EFI_INVALID_PARAMETER;
    193       goto ON_EXIT;
    194     }
    195 
    196     Status = TlsSetSessionId (
    197                Instance->TlsConn,
    198                ((EFI_TLS_SESSION_ID *) Data)->Data,
    199                ((EFI_TLS_SESSION_ID *) Data)->Length
    200                );
    201     break;
    202   case EfiTlsSessionState:
    203     if (DataSize != sizeof (EFI_TLS_SESSION_STATE)) {
    204       Status = EFI_INVALID_PARAMETER;
    205       goto ON_EXIT;
    206     }
    207 
    208     Instance->TlsSessionState = *(EFI_TLS_SESSION_STATE *) Data;
    209     break;
    210   //
    211   // Session information
    212   //
    213   case EfiTlsClientRandom:
    214     Status = EFI_ACCESS_DENIED;
    215     break;
    216   case EfiTlsServerRandom:
    217     Status = EFI_ACCESS_DENIED;
    218     break;
    219   case EfiTlsKeyMaterial:
    220     Status = EFI_ACCESS_DENIED;
    221     break;
    222   //
    223   // Unsupported type.
    224   //
    225   default:
    226     Status = EFI_UNSUPPORTED;
     181        goto ON_EXIT;
     182      }
     183
     184      if ((VerifyMethod & EFI_TLS_VERIFY_PEER) == 0) {
     185        Status = EFI_INVALID_PARAMETER;
     186        goto ON_EXIT;
     187      }
     188
     189      Status = TlsSetVerifyHost (Instance->TlsConn, TlsVerifyHost->Flags, TlsVerifyHost->HostName);
     190
     191      break;
     192    case EfiTlsSessionID:
     193      if (DataSize != sizeof (EFI_TLS_SESSION_ID)) {
     194        Status = EFI_INVALID_PARAMETER;
     195        goto ON_EXIT;
     196      }
     197
     198      Status = TlsSetSessionId (
     199                 Instance->TlsConn,
     200                 ((EFI_TLS_SESSION_ID *)Data)->Data,
     201                 ((EFI_TLS_SESSION_ID *)Data)->Length
     202                 );
     203      break;
     204    case EfiTlsSessionState:
     205      if (DataSize != sizeof (EFI_TLS_SESSION_STATE)) {
     206        Status = EFI_INVALID_PARAMETER;
     207        goto ON_EXIT;
     208      }
     209
     210      Instance->TlsSessionState = *(EFI_TLS_SESSION_STATE *)Data;
     211      break;
     212    //
     213    // Session information
     214    //
     215    case EfiTlsClientRandom:
     216      Status = EFI_ACCESS_DENIED;
     217      break;
     218    case EfiTlsServerRandom:
     219      Status = EFI_ACCESS_DENIED;
     220      break;
     221    case EfiTlsKeyMaterial:
     222      Status = EFI_ACCESS_DENIED;
     223      break;
     224    //
     225    // Unsupported type.
     226    //
     227    default:
     228      Status = EFI_UNSUPPORTED;
    227229  }
    228230
    … …  
    258260EFIAPI
    259261TlsGetSessionData (
    260   IN     EFI_TLS_PROTOCOL              *This,
    261   IN     EFI_TLS_SESSION_DATA_TYPE     DataType,
    262   IN OUT VOID                          *Data,  OPTIONAL
    263   IN OUT UINTN                         *DataSize
     262  IN     EFI_TLS_PROTOCOL           *This,
     263  IN     EFI_TLS_SESSION_DATA_TYPE  DataType,
     264  IN OUT VOID                       *Data   OPTIONAL,
     265  IN OUT UINTN                      *DataSize
    264266  )
    265267{
    266   EFI_STATUS                Status;
    267   TLS_INSTANCE              *Instance;
    268 
    269   EFI_TPL                   OldTpl;
     268  EFI_STATUS    Status;
     269  TLS_INSTANCE  *Instance;
     270
     271  EFI_TPL  OldTpl;
    270272
    271273  Status = EFI_SUCCESS;
    272274
    273   if (This == NULL || DataSize == NULL || (Data == NULL && *DataSize != 0)) {
     275  if ((This == NULL) || (DataSize == NULL) || ((Data == NULL) && (*DataSize != 0))) {
    274276    return EFI_INVALID_PARAMETER;
    275277  }
    … …  
    279281  Instance = TLS_INSTANCE_FROM_PROTOCOL (This);
    280282
    281   if (Instance->TlsSessionState == EfiTlsSessionNotStarted &&
    282     (DataType == EfiTlsSessionID || DataType == EfiTlsClientRandom ||
    283     DataType == EfiTlsServerRandom || DataType == EfiTlsKeyMaterial)) {
     283  if ((Instance->TlsSessionState == EfiTlsSessionNotStarted) &&
     284      ((DataType == EfiTlsSessionID) || (DataType == EfiTlsClientRandom) ||
     285       (DataType == EfiTlsServerRandom) || (DataType == EfiTlsKeyMaterial)))
     286  {
    284287    Status = EFI_NOT_READY;
    285288    goto ON_EXIT;
    … …  
    287290
    288291  switch (DataType) {
    289   case EfiTlsVersion:
    290     if (*DataSize < sizeof (EFI_TLS_VERSION)) {
    291       *DataSize = sizeof (EFI_TLS_VERSION);
    292       Status = EFI_BUFFER_TOO_SMALL;
     292    case EfiTlsVersion:
     293      if (*DataSize < sizeof (EFI_TLS_VERSION)) {
     294        *DataSize = sizeof (EFI_TLS_VERSION);
     295        Status    = EFI_BUFFER_TOO_SMALL;
     296        goto ON_EXIT;
     297      }
     298
     299      *DataSize         = sizeof (EFI_TLS_VERSION);
     300      *((UINT16 *)Data) = HTONS (TlsGetVersion (Instance->TlsConn));
     301      break;
     302    case EfiTlsConnectionEnd:
     303      if (*DataSize < sizeof (EFI_TLS_CONNECTION_END)) {
     304        *DataSize = sizeof (EFI_TLS_CONNECTION_END);
     305        Status    = EFI_BUFFER_TOO_SMALL;
     306        goto ON_EXIT;
     307      }
     308
     309      *DataSize        = sizeof (EFI_TLS_CONNECTION_END);
     310      *((UINT8 *)Data) = TlsGetConnectionEnd (Instance->TlsConn);
     311      break;
     312    case EfiTlsCipherList:
     313      //
     314      // Get the current session cipher suite.
     315      //
     316      if (*DataSize < sizeof (EFI_TLS_CIPHER)) {
     317        *DataSize = sizeof (EFI_TLS_CIPHER);
     318        Status    = EFI_BUFFER_TOO_SMALL;
     319        goto ON_EXIT;
     320      }
     321
     322      *DataSize         = sizeof (EFI_TLS_CIPHER);
     323      Status            = TlsGetCurrentCipher (Instance->TlsConn, (UINT16 *)Data);
     324      *((UINT16 *)Data) = HTONS (*((UINT16 *)Data));
     325      break;
     326    case EfiTlsCompressionMethod:
     327      //
     328      // Get the current session compression method.
     329      //
     330      if (*DataSize < sizeof (EFI_TLS_COMPRESSION)) {
     331        *DataSize = sizeof (EFI_TLS_COMPRESSION);
     332        Status    = EFI_BUFFER_TOO_SMALL;
     333        goto ON_EXIT;
     334      }
     335
     336      *DataSize = sizeof (EFI_TLS_COMPRESSION);
     337      Status    = TlsGetCurrentCompressionId (Instance->TlsConn, (UINT8 *)Data);
     338      break;
     339    case EfiTlsExtensionData:
     340      Status = EFI_UNSUPPORTED;
    293341      goto ON_EXIT;
    294     }
    295     *DataSize = sizeof (EFI_TLS_VERSION);
    296     *((UINT16 *) Data) = HTONS (TlsGetVersion (Instance->TlsConn));
    297     break;
    298   case EfiTlsConnectionEnd:
    299     if (*DataSize < sizeof (EFI_TLS_CONNECTION_END)) {
    300       *DataSize = sizeof (EFI_TLS_CONNECTION_END);
    301       Status = EFI_BUFFER_TOO_SMALL;
    302       goto ON_EXIT;
    303     }
    304     *DataSize = sizeof (EFI_TLS_CONNECTION_END);
    305     *((UINT8 *) Data) = TlsGetConnectionEnd (Instance->TlsConn);
    306     break;
    307   case EfiTlsCipherList:
    308     //
    309     // Get the current session cipher suite.
    310     //
    311     if (*DataSize < sizeof (EFI_TLS_CIPHER)) {
    312       *DataSize = sizeof (EFI_TLS_CIPHER);
    313       Status = EFI_BUFFER_TOO_SMALL;
    314       goto ON_EXIT;
    315     }
    316     *DataSize = sizeof(EFI_TLS_CIPHER);
    317     Status = TlsGetCurrentCipher (Instance->TlsConn, (UINT16 *) Data);
    318     *((UINT16 *) Data) = HTONS (*((UINT16 *) Data));
    319     break;
    320   case EfiTlsCompressionMethod:
    321     //
    322     // Get the current session compression method.
    323     //
    324     if (*DataSize < sizeof (EFI_TLS_COMPRESSION)) {
    325       *DataSize = sizeof (EFI_TLS_COMPRESSION);
    326       Status = EFI_BUFFER_TOO_SMALL;
    327       goto ON_EXIT;
    328     }
    329     *DataSize = sizeof (EFI_TLS_COMPRESSION);
    330     Status = TlsGetCurrentCompressionId (Instance->TlsConn, (UINT8 *) Data);
    331     break;
    332   case EfiTlsExtensionData:
    333     Status = EFI_UNSUPPORTED;
    334     goto ON_EXIT;
    335   case EfiTlsVerifyMethod:
    336     if (*DataSize < sizeof (EFI_TLS_VERIFY)) {
    337       *DataSize = sizeof (EFI_TLS_VERIFY);
    338       Status = EFI_BUFFER_TOO_SMALL;
    339       goto ON_EXIT;
    340     }
    341     *DataSize = sizeof (EFI_TLS_VERIFY);
    342     *((UINT32 *) Data) = TlsGetVerify (Instance->TlsConn);
    343     break;
    344   case EfiTlsSessionID:
    345     if (*DataSize < sizeof (EFI_TLS_SESSION_ID)) {
     342    case EfiTlsVerifyMethod:
     343      if (*DataSize < sizeof (EFI_TLS_VERIFY)) {
     344        *DataSize = sizeof (EFI_TLS_VERIFY);
     345        Status    = EFI_BUFFER_TOO_SMALL;
     346        goto ON_EXIT;
     347      }
     348
     349      *DataSize         = sizeof (EFI_TLS_VERIFY);
     350      *((UINT32 *)Data) = TlsGetVerify (Instance->TlsConn);
     351      break;
     352    case EfiTlsSessionID:
     353      if (*DataSize < sizeof (EFI_TLS_SESSION_ID)) {
     354        *DataSize = sizeof (EFI_TLS_SESSION_ID);
     355        Status    = EFI_BUFFER_TOO_SMALL;
     356        goto ON_EXIT;
     357      }
     358
    346359      *DataSize = sizeof (EFI_TLS_SESSION_ID);
    347       Status = EFI_BUFFER_TOO_SMALL;
    348       goto ON_EXIT;
    349     }
    350     *DataSize = sizeof (EFI_TLS_SESSION_ID);
    351     Status = TlsGetSessionId (
    352                Instance->TlsConn,
    353                ((EFI_TLS_SESSION_ID *) Data)->Data,
    354                &(((EFI_TLS_SESSION_ID *) Data)->Length)
    355                );
    356     break;
    357   case EfiTlsSessionState:
    358     if (*DataSize < sizeof (EFI_TLS_SESSION_STATE)) {
     360      Status    = TlsGetSessionId (
     361                    Instance->TlsConn,
     362                    ((EFI_TLS_SESSION_ID *)Data)->Data,
     363                    &(((EFI_TLS_SESSION_ID *)Data)->Length)
     364                    );
     365      break;
     366    case EfiTlsSessionState:
     367      if (*DataSize < sizeof (EFI_TLS_SESSION_STATE)) {
     368        *DataSize = sizeof (EFI_TLS_SESSION_STATE);
     369        Status    = EFI_BUFFER_TOO_SMALL;
     370        goto ON_EXIT;
     371      }
     372
    359373      *DataSize = sizeof (EFI_TLS_SESSION_STATE);
    360       Status = EFI_BUFFER_TOO_SMALL;
    361       goto ON_EXIT;
    362     }
    363     *DataSize = sizeof (EFI_TLS_SESSION_STATE);
    364     CopyMem (Data, &Instance->TlsSessionState, *DataSize);
    365     break;
    366   case EfiTlsClientRandom:
    367     if (*DataSize < sizeof (EFI_TLS_RANDOM)) {
     374      CopyMem (Data, &Instance->TlsSessionState, *DataSize);
     375      break;
     376    case EfiTlsClientRandom:
     377      if (*DataSize < sizeof (EFI_TLS_RANDOM)) {
     378        *DataSize = sizeof (EFI_TLS_RANDOM);
     379        Status    = EFI_BUFFER_TOO_SMALL;
     380        goto ON_EXIT;
     381      }
     382
    368383      *DataSize = sizeof (EFI_TLS_RANDOM);
    369       Status = EFI_BUFFER_TOO_SMALL;
    370       goto ON_EXIT;
    371     }
    372     *DataSize = sizeof (EFI_TLS_RANDOM);
    373     TlsGetClientRandom (Instance->TlsConn, (UINT8 *) Data);
    374     break;
    375   case EfiTlsServerRandom:
    376     if (*DataSize < sizeof (EFI_TLS_RANDOM)) {
     384      TlsGetClientRandom (Instance->TlsConn, (UINT8 *)Data);
     385      break;
     386    case EfiTlsServerRandom:
     387      if (*DataSize < sizeof (EFI_TLS_RANDOM)) {
     388        *DataSize = sizeof (EFI_TLS_RANDOM);
     389        Status    = EFI_BUFFER_TOO_SMALL;
     390        goto ON_EXIT;
     391      }
     392
    377393      *DataSize = sizeof (EFI_TLS_RANDOM);
    378       Status = EFI_BUFFER_TOO_SMALL;
    379       goto ON_EXIT;
    380     }
    381     *DataSize = sizeof (EFI_TLS_RANDOM);
    382     TlsGetServerRandom (Instance->TlsConn, (UINT8 *) Data);
    383     break;
    384   case EfiTlsKeyMaterial:
    385     if (*DataSize < sizeof (EFI_TLS_MASTER_SECRET)) {
     394      TlsGetServerRandom (Instance->TlsConn, (UINT8 *)Data);
     395      break;
     396    case EfiTlsKeyMaterial:
     397      if (*DataSize < sizeof (EFI_TLS_MASTER_SECRET)) {
     398        *DataSize = sizeof (EFI_TLS_MASTER_SECRET);
     399        Status    = EFI_BUFFER_TOO_SMALL;
     400        goto ON_EXIT;
     401      }
     402
    386403      *DataSize = sizeof (EFI_TLS_MASTER_SECRET);
    387       Status = EFI_BUFFER_TOO_SMALL;
    388       goto ON_EXIT;
    389     }
    390     *DataSize = sizeof (EFI_TLS_MASTER_SECRET);
    391     Status = TlsGetKeyMaterial (Instance->TlsConn, (UINT8 *) Data);
    392     break;
    393   //
    394   // Unsupported type.
    395   //
    396   default:
    397     Status = EFI_UNSUPPORTED;
     404      Status    = TlsGetKeyMaterial (Instance->TlsConn, (UINT8 *)Data);
     405      break;
     406    //
     407    // Unsupported type.
     408    //
     409    default:
     410      Status = EFI_UNSUPPORTED;
    398411  }
    399412
    … …  
    444457EFIAPI
    445458TlsBuildResponsePacket (
    446   IN     EFI_TLS_PROTOCOL              *This,
    447   IN     UINT8                         *RequestBuffer, OPTIONAL
    448   IN     UINTN                         RequestSize, OPTIONAL
    449      OUT UINT8                         *Buffer, OPTIONAL
    450   IN OUT UINTN                         *BufferSize
     459  IN     EFI_TLS_PROTOCOL  *This,
     460  IN     UINT8             *RequestBuffer  OPTIONAL,
     461  IN     UINTN             RequestSize  OPTIONAL,
     462  OUT UINT8                *Buffer  OPTIONAL,
     463  IN OUT UINTN             *BufferSize
    451464  )
    452465{
    453   EFI_STATUS                Status;
    454   TLS_INSTANCE              *Instance;
    455   EFI_TPL                   OldTpl;
     466  EFI_STATUS    Status;
     467  TLS_INSTANCE  *Instance;
     468  EFI_TPL       OldTpl;
    456469
    457470  Status = EFI_SUCCESS;
    458471
    459472  if ((This == NULL) || (BufferSize == NULL) ||
    460       (RequestBuffer == NULL && RequestSize != 0) ||
    461       (RequestBuffer != NULL && RequestSize == 0) ||
    462       (Buffer == NULL && *BufferSize !=0)) {
     473      ((RequestBuffer == NULL) && (RequestSize != 0)) ||
     474      ((RequestBuffer != NULL) && (RequestSize == 0)) ||
     475      ((Buffer == NULL) && (*BufferSize != 0)))
     476  {
    463477    return EFI_INVALID_PARAMETER;
    464478  }
    … …  
    468482  Instance = TLS_INSTANCE_FROM_PROTOCOL (This);
    469483
    470   if(RequestBuffer == NULL && RequestSize == 0) {
     484  if ((RequestBuffer == NULL) && (RequestSize == 0)) {
    471485    switch (Instance->TlsSessionState) {
    472     case EfiTlsSessionNotStarted:
    473       //
    474       // ClientHello.
    475       //
    476       Status = TlsDoHandshake (
    477                  Instance->TlsConn,
    478                  NULL,
    479                  0,
    480                  Buffer,
    481                  BufferSize
    482                  );
    483       if (EFI_ERROR (Status)) {
    484         goto ON_EXIT;
    485       }
    486 
    487       //
    488       // *BufferSize should not be zero when ClientHello.
    489       //
    490       if (*BufferSize == 0) {
    491         Status = EFI_ABORTED;
    492         goto ON_EXIT;
    493       }
    494 
    495       Instance->TlsSessionState = EfiTlsSessionHandShaking;
    496 
    497       break;
    498     case EfiTlsSessionClosing:
    499       //
    500       // TLS session will be closed and response packet needs to be CloseNotify.
    501       //
    502       Status = TlsCloseNotify (
    503                  Instance->TlsConn,
    504                  Buffer,
    505                  BufferSize
    506                  );
    507       if (EFI_ERROR (Status)) {
    508         goto ON_EXIT;
    509       }
    510 
    511       //
    512       // *BufferSize should not be zero when build CloseNotify message.
    513       //
    514       if (*BufferSize == 0) {
    515         Status = EFI_ABORTED;
    516         goto ON_EXIT;
    517       }
    518 
    519       break;
    520     case EfiTlsSessionError:
    521       //
    522       // TLS session has errors and the response packet needs to be Alert
    523       // message based on error type.
    524       //
    525       Status = TlsHandleAlert (
    526                  Instance->TlsConn,
    527                  NULL,
    528                  0,
    529                  Buffer,
    530                  BufferSize
    531                  );
    532       if (EFI_ERROR (Status)) {
    533         goto ON_EXIT;
    534       }
    535 
    536       break;
    537     default:
    538       //
    539       // Current TLS session state is NOT ready to build ResponsePacket.
    540       //
    541       Status = EFI_NOT_READY;
     486      case EfiTlsSessionNotStarted:
     487        //
     488        // ClientHello.
     489        //
     490        Status = TlsDoHandshake (
     491                   Instance->TlsConn,
     492                   NULL,
     493                   0,
     494                   Buffer,
     495                   BufferSize
     496                   );
     497        if (EFI_ERROR (Status)) {
     498          goto ON_EXIT;
     499        }
     500
     501        //
     502        // *BufferSize should not be zero when ClientHello.
     503        //
     504        if (*BufferSize == 0) {
     505          Status = EFI_ABORTED;
     506          goto ON_EXIT;
     507        }
     508
     509        Instance->TlsSessionState = EfiTlsSessionHandShaking;
     510
     511        break;
     512      case EfiTlsSessionClosing:
     513        //
     514        // TLS session will be closed and response packet needs to be CloseNotify.
     515        //
     516        Status = TlsCloseNotify (
     517                   Instance->TlsConn,
     518                   Buffer,
     519                   BufferSize
     520                   );
     521        if (EFI_ERROR (Status)) {
     522          goto ON_EXIT;
     523        }
     524
     525        //
     526        // *BufferSize should not be zero when build CloseNotify message.
     527        //
     528        if (*BufferSize == 0) {
     529          Status = EFI_ABORTED;
     530          goto ON_EXIT;
     531        }
     532
     533        break;
     534      case EfiTlsSessionError:
     535        //
     536        // TLS session has errors and the response packet needs to be Alert
     537        // message based on error type.
     538        //
     539        Status = TlsHandleAlert (
     540                   Instance->TlsConn,
     541                   NULL,
     542                   0,
     543                   Buffer,
     544                   BufferSize
     545                   );
     546        if (EFI_ERROR (Status)) {
     547          goto ON_EXIT;
     548        }
     549
     550        break;
     551      default:
     552        //
     553        // Current TLS session state is NOT ready to build ResponsePacket.
     554        //
     555        Status = EFI_NOT_READY;
    542556    }
    543557  } else {
    … …  
    567581      // Must be alert message, Decrypt it and build the ResponsePacket.
    568582      //
    569       ASSERT (((TLS_RECORD_HEADER *) RequestBuffer)->ContentType == TlsContentTypeAlert);
     583      ASSERT (((TLS_RECORD_HEADER *)RequestBuffer)->ContentType == TlsContentTypeAlert);
    570584
    571585      Status = TlsHandleAlert (
    … …  
    628642EFIAPI
    629643TlsProcessPacket (
    630   IN     EFI_TLS_PROTOCOL              *This,
    631   IN OUT EFI_TLS_FRAGMENT_DATA         **FragmentTable,
    632   IN     UINT32                        *FragmentCount,
    633   IN     EFI_TLS_CRYPT_MODE            CryptMode
     644  IN     EFI_TLS_PROTOCOL       *This,
     645  IN OUT EFI_TLS_FRAGMENT_DATA  **FragmentTable,
     646  IN     UINT32                 *FragmentCount,
     647  IN     EFI_TLS_CRYPT_MODE     CryptMode
    634648  )
    635649{
    636   EFI_STATUS                Status;
    637   TLS_INSTANCE              *Instance;
    638 
    639   EFI_TPL                   OldTpl;
     650  EFI_STATUS    Status;
     651  TLS_INSTANCE  *Instance;
     652
     653  EFI_TPL  OldTpl;
    640654
    641655  Status = EFI_SUCCESS;
    642656
    643   if (This == NULL || FragmentTable == NULL || FragmentCount == NULL) {
     657  if ((This == NULL) || (FragmentTable == NULL) || (FragmentCount == NULL)) {
    644658    return EFI_INVALID_PARAMETER;
    645659  }
    … …  
    660674  //
    661675  switch (CryptMode) {
    662   case EfiTlsEncrypt:
    663     Status = TlsEncryptPacket (Instance, FragmentTable, FragmentCount);
    664     break;
    665   case EfiTlsDecrypt:
    666     Status = TlsDecryptPacket (Instance, FragmentTable, FragmentCount);
    667     break;
    668   default:
    669     return EFI_INVALID_PARAMETER;
     676    case EfiTlsEncrypt:
     677      Status = TlsEncryptPacket (Instance, FragmentTable, FragmentCount);
     678      break;
     679    case EfiTlsDecrypt:
     680      Status = TlsDecryptPacket (Instance, FragmentTable, FragmentCount);
     681      break;
     682    default:
     683      return EFI_INVALID_PARAMETER;
    670684  }
    671685
    … …  
    674688  return Status;
    675689}
    676 
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette