Line data    Source code

       1             : #include "source/extensions/transport_sockets/alts/tsi_frame_protector.h"
       2             : 
       3             : #include "source/common/buffer/buffer_impl.h"
       4             : #include "source/common/common/assert.h"
       5             : 
       6             : #include "src/core/lib/iomgr/exec_ctx.h"
       7             : #include "src/core/tsi/transport_security_grpc.h"
       8             : #include "src/core/tsi/transport_security_interface.h"
       9             : 
      10             : namespace Envoy {
      11             : namespace Extensions {
      12             : namespace TransportSockets {
      13             : namespace Alts {
      14             : 
      15             : TsiFrameProtector::TsiFrameProtector(CFrameProtectorPtr&& frame_protector)
      16           0 :     : frame_protector_(std::move(frame_protector)) {}
      17             : 
      18           0 : tsi_result TsiFrameProtector::protect(const grpc_slice& input_slice, Buffer::Instance& output) {
      19           0 :   ASSERT(frame_protector_);
      20             : 
      21           0 :   if (GRPC_SLICE_LENGTH(input_slice) == 0) {
      22           0 :     return TSI_OK;
      23           0 :   }
      24             : 
      25           0 :   grpc_core::ExecCtx exec_ctx;
      26             : 
      27           0 :   grpc_slice_buffer message_buffer;
      28           0 :   grpc_slice_buffer_init(&message_buffer);
      29           0 :   grpc_slice_buffer_add(&message_buffer, input_slice);
      30             : 
      31           0 :   grpc_slice_buffer protected_buffer;
      32           0 :   grpc_slice_buffer_init(&protected_buffer);
      33             : 
      34           0 :   tsi_result result = tsi_zero_copy_grpc_protector_protect(frame_protector_.get(), &message_buffer,
      35           0 :                                                            &protected_buffer);
      36             : 
      37           0 :   if (result != TSI_OK) {
      38           0 :     ASSERT(result != TSI_INVALID_ARGUMENT && result != TSI_UNIMPLEMENTED);
      39           0 :     grpc_slice_buffer_destroy(&message_buffer);
      40           0 :     grpc_slice_buffer_destroy(&protected_buffer);
      41           0 :     return result;
      42           0 :   }
      43             : 
      44           0 :   const size_t protected_data_length = protected_buffer.length;
      45           0 :   char* protected_data = new char[protected_data_length];
      46             : 
      47           0 :   grpc_slice_buffer_move_first_into_buffer(&protected_buffer, protected_data_length,
      48           0 :                                            protected_data);
      49             : 
      50           0 :   auto fragment = new Buffer::BufferFragmentImpl(
      51           0 :       protected_data, protected_data_length,
      52           0 :       [protected_data](const void*, size_t,
      53           0 :                        const Envoy::Buffer::BufferFragmentImpl* this_fragment) {
      54           0 :         delete[] protected_data;
      55           0 :         delete this_fragment;
      56           0 :       });
      57             : 
      58           0 :   output.addBufferFragment(*fragment);
      59             : 
      60           0 :   grpc_slice_buffer_destroy(&message_buffer);
      61           0 :   grpc_slice_buffer_destroy(&protected_buffer);
      62             : 
      63           0 :   return TSI_OK;
      64           0 : }
      65             : 
      66           0 : tsi_result TsiFrameProtector::unprotect(Buffer::Instance& input, Buffer::Instance& output) {
      67           0 :   ASSERT(frame_protector_);
      68             : 
      69           0 :   if (input.length() == 0) {
      70           0 :     return TSI_OK;
      71           0 :   }
      72             : 
      73           0 :   grpc_core::ExecCtx exec_ctx;
      74           0 :   grpc_slice input_slice = grpc_slice_from_copied_buffer(
      75           0 :       reinterpret_cast<char*>(input.linearize(input.length())), input.length());
      76             : 
      77           0 :   grpc_slice_buffer protected_buffer;
      78           0 :   grpc_slice_buffer_init(&protected_buffer);
      79           0 :   grpc_slice_buffer_add(&protected_buffer, input_slice);
      80             : 
      81           0 :   grpc_slice_buffer unprotected_buffer;
      82           0 :   grpc_slice_buffer_init(&unprotected_buffer);
      83             : 
      84           0 :   tsi_result result = tsi_zero_copy_grpc_protector_unprotect(
      85           0 :       frame_protector_.get(), &protected_buffer, &unprotected_buffer, nullptr);
      86             : 
      87           0 :   if (result != TSI_OK) {
      88           0 :     ASSERT(result != TSI_INVALID_ARGUMENT && result != TSI_UNIMPLEMENTED);
      89           0 :     grpc_slice_buffer_destroy(&protected_buffer);
      90           0 :     grpc_slice_buffer_destroy(&unprotected_buffer);
      91           0 :     return result;
      92           0 :   }
      93             : 
      94           0 :   const size_t unprotected_data_length = unprotected_buffer.length;
      95           0 :   char* unprotected_data = new char[unprotected_data_length];
      96             : 
      97           0 :   grpc_slice_buffer_move_first_into_buffer(&unprotected_buffer, unprotected_data_length,
      98           0 :                                            unprotected_data);
      99             : 
     100           0 :   auto fragment = new Buffer::BufferFragmentImpl(
     101           0 :       unprotected_data, unprotected_data_length,
     102           0 :       [unprotected_data](const void*, size_t,
     103           0 :                          const Envoy::Buffer::BufferFragmentImpl* this_fragment) {
     104           0 :         delete[] unprotected_data;
     105           0 :         delete this_fragment;
     106           0 :       });
     107             : 
     108           0 :   output.addBufferFragment(*fragment);
     109           0 :   input.drain(input.length());
     110             : 
     111           0 :   grpc_slice_buffer_destroy(&protected_buffer);
     112           0 :   grpc_slice_buffer_destroy(&unprotected_buffer);
     113             : 
     114           0 :   return TSI_OK;
     115           0 : }
     116             : 
     117             : } // namespace Alts
     118             : } // namespace TransportSockets
     119             : } // namespace Extensions
     120             : } // namespace Envoy