code: def _activate_outbound(self):
          
          m = Message()
          m.add_byte(cMSG_NEWKEYS)
          self._send_message(m)
          block_size = self._cipher_info[self.local_cipher]["block-size"]
          if self.server_mode:
              IV_out = self._compute_key("B", block_size)
              key_out = self._compute_key(
                  "D", self._cipher_info[self.local_cipher]["key-size"]
              )
          else:
              IV_out = self._compute_key("A", block_size)
              key_out = self._compute_key(
                  "C", self._cipher_info[self.local_cipher]["key-size"]
              )
          engine = self._get_cipher(
              self.local_cipher, key_out, IV_out, self._ENCRYPT
          )
          mac_size = self._mac_info[self.local_mac]["size"]
          mac_engine = self._mac_info[self.local_mac]["class"]
          # initial mac keys are done in the hash's natural size (not the
          # potentially truncated transmission size)
          if self.server_mode:
              mac_key = self._compute_key("F", mac_engine().digest_size)
          else:
              mac_key = self._compute_key("E", mac_engine().digest_size)
          sdctr = self.local_cipher.endswith("-ctr")
          self.packetizer.set_outbound_cipher(
              engine, block_size, mac_engine, mac_size, mac_key, sdctr
          )
          compress_out = self._compression_info[self.local_compression][0]
          if compress_out is not None and (
              self.local_compression != "zlib@openssh.com" or self.authenticated
          ):
              self._log(DEBUG, "Switching on outbound compression ...")
              self.packetizer.set_outbound_compressor(compress_out())
          if not self.packetizer.need_rekey():
              self.in_kex = False
          # we always expect to receive NEWKEYS now
          self._expect_packet(MSG_NEWKEYS)
docs: switch on newly negotiated encryption parameters for
           outbound traffic