SSLEngine (Платформа Java SE 7)

java.lang. Объект
- javax.net.ssl. SSLEngine

```
public abstract class SSLEngine
extends Object
```
Класс, который включает безопасной связи, используя протоколы, такие как Уровень защищенных сокетов (SSL) или RFC 2246 IETF "Безопасность Транспортного уровня" (TLS) протоколы, но является транспортным независимым политиком.
Безопасные коммуникационные режимы включают:
- Защита целостности. SSL/TLS защищает от модификации сообщений активным wiretapper.
- Аутентификация. В большинстве режимов SSL/TLS обеспечивает равноправную аутентификацию. Серверы обычно аутентифицируются, и клиенты могут аутентифицироваться согласно просьбе серверами.
- Конфиденциальность (Защита конфиденциальности). В большинстве режимов SSL/TLS шифрует данные, отправляемые между клиентом и сервером. Это защищает конфиденциальность данных, так, чтобы пассивный wiretappers не видел уязвимых данных, таких как финансовая информация или персональные данные многих видов.
Эти виды защиты определяются "комплектом шифра", который является комбинацией криптографических алгоритмов, используемых данным соединением SSL. Во время процесса согласования эти две конечных точки должны договориться о комплекте шифра, который доступен в обеих средах. Если нет такого комплекта вместе, никакое соединение SSL не может быть установлено, и никакие данные не могут быть переданы.
Используемый комплект шифра устанавливается процессом согласования, вызванным, "квитируя". Цель этого процесса состоит в том, чтобы создать или воссоединиться с "сеансом", который может защитить много соединений в течение долгого времени. После того, как квитирование завершилось, можно получить доступ к атрибутам сеанса при использовании getSession() метод.
SSLSocket класс обеспечивает большую часть той же самой функциональности безопасности, но все входящие и исходящие данные автоматически транспортируются, используя базовое Socket, который проектом использует модель блокирования. В то время как это является подходящим для многих приложений, эта модель не обеспечивает масштабируемость, требуемую большими серверами.
Основное различие SSLEngine это, это работает на входящих и исходящих потоках байтов, независимых от транспортного механизма. Это - ответственность SSLEngine пользователь, чтобы устроить надежный ввод-вывод транспортирует к коллеге. Разделяя абстракцию SSL/TLS от ввода-вывода транспортируют механизм, SSLEngine может использоваться для большого разнообразия типов ввода-вывода, такой как non-blocking I/O (polling), selectable non-blocking I/O, Socket и традиционный Input/OutputStreams, локальный ByteBuffers или байтовые массивы, будущие асинхронные модели ввода-вывода, и так далее.
На высоком уровне, SSLEngine появляется таким образом:
```
                   app data

                |           ^
                |     |     |
                v     |     |
           +----+-----|-----+----+
           |          |          |
           |       SSL|Engine    |
   wrap()  |          |          |  unwrap()
           | OUTBOUND | INBOUND  |
           |          |          |
           +----+-----|-----+----+
                |     |     ^
                |     |     |
                v           |

                   net data
 
```
Данные приложения (также известный как простой текст или открытый текст) являются данными, которые производятся или используются приложением. Его дубликат является сетевыми данными, которые состоят из любого квитирования и/или шифрованного текста (зашифрованные) данные, и предназначенный, чтобы быть транспортированными через механизм ввода-вывода. Входящие данные являются данными, которые были получены от коллеги, и исходящие данные предназначаются для коллеги.
(В контексте SSLEngine, термин "квитирование данных" берется, чтобы означать любые данные, переданные, чтобы установить и управлять безопасным соединением. Данные квитирования включают сообщения SSL/TLS "предупреждение", "change_cipher_spec", и "квитирование".)
Есть пять отличных фаз к SSLEngine.
1. Создание - SSLEngine был создан и инициализирован, но еще не использовался. Во время этой фазы приложение может установить любого SSLEngineСпецифичные настройки (включал комплектам шифра, ли SSLEngine должен квитировать в клиенте или режиме сервера, и так далее). Как только квитирование начало, тем не менее, любые новые настройки (кроме клиент-серверного режима, см. ниже), будет использоваться для следующего квитирования.
2. Начальное Квитирование - начальное квитирование является процедурой, которой две коллеги обмениваются коммуникационными параметрами, пока SSLSession не устанавливается. Данные приложения не могут быть отправлены во время этой фазы.
3. Данные приложения - Однажды коммуникационные параметры были установлены, и квитирование полно, данные приложения могут течь через SSLEngine. Исходящие сообщения приложения шифруются и целостность, защищенные, и входящие сообщения инвертируют процесс.
4. Повторно квитируя - Любая сторона может запросить пересмотр сеанса в любое время во время фазы Данных приложения. Новые данные квитирования могут быть смешаны среди данных приложения. Прежде, чем запустить фазу переквитирования, приложение может сбросить коммуникационные параметры SSL/TLS, такие как список включенного ciphersuites и использовать ли аутентификацию клиента, но не может измениться между клиент-серверными режимами. Как прежде, как только квитирование началось, любой новый SSLEngine параметры конфигурации не будут использоваться до следующего квитирования.
5. Закрытие - Когда соединение больше не необходимо, приложение, должно закрыться SSLEngine и должен отправить/получить любые остающиеся сообщения коллеге прежде, чем закрыть базовый транспортный механизм. Как только механизм закрывается, это не допускающее повторное использование: новое SSLEngine должен быть создан.
SSLEngine создается, вызывая SSLContext.createSSLEngine() от инициализированного SSLContext. Любые параметры конфигурации должны быть установлены прежде, чем сделать первый звонок wrap(), unwrap(), или beginHandshake(). Эти методы весь триггер начальное квитирование.
Данные перемещаются через механизм, вызывая wrap() или unwrap() на исходящих или входящих данных, соответственно. В зависимости от состояния SSLEngine, a wrap() вызов может использовать данные приложения от исходного буфера и может произвести сетевые данные в целевом буфере. Исходящие данные могут содержать приложение и/или квитировать данные. Звонок unwrap() исследует исходный буфер и может усовершенствовать квитирование, если данные будут квитировать информацию, или смогут поместить данные приложения в целевой буфер, если данные являются приложением. Состояние базового алгоритма SSL/TLS определит, когда данные будут использованы и производятся.
Звонки wrap() и unwrap() возвратитесь SSLEngineResult который указывает на состояние работы, и (дополнительно) как взаимодействовать с механизмом, чтобы сделать успехи.
SSLEngine производит/использует полные пакеты SSL/TLS только, и не хранит данные приложения внутренне между звонками wrap()/unwrap(). Таким образом вход и выход ByteBuffers должен быть измерен соответственно, чтобы содержать максимальную запись, которая может быть произведена. Звонки SSLSession.getPacketBufferSize() и SSLSession.getApplicationBufferSize() должен использоваться, чтобы определить соответствующие буферные размеры. Размер исходящего буфера данных приложения обычно не имеет значения. Если буферные условия не учитывают надлежащее потребление/производство данных, приложение должно определить (через SSLEngineResult) и исправьте проблему, и затем попробуйте вызов снова.
Например, unwrap() возвратит a SSLEngineResult.Status.BUFFER_OVERFLOW закончитесь, если механизм решает, что есть недостаточное целевое доступное пространство буфера. Приложения должны вызвать SSLSession.getApplicationBufferSize() и сравните то значение с пространством, доступным в целевом буфере, увеличивая буфер в случае необходимости. Точно так же, если unwrap() должны были возвратить a SSLEngineResult.Status.BUFFER_UNDERFLOW, приложение должно вызвать SSLSession.getPacketBufferSize() гарантировать, что у исходного буфера есть достаточно комнаты, чтобы содержать запись (увеличение в случае необходимости), и затем получить больше входящих данных.
```
   SSLEngineResult r = engine.unwrap(src, dst);
   switch (r.getStatus()) {
   BUFFER_OVERFLOW:
       // Could attempt to drain the dst buffer of any already obtained
       // data, but we'll just increase it to the size needed.
       int appSize = engine.getSession().getApplicationBufferSize();
       ByteBuffer b = ByteBuffer.allocate(appSize + dst.position());
       dst.flip();
       b.put(dst);
       dst = b;
       // retry the operation.
       break;
   BUFFER_UNDERFLOW:
       int netSize = engine.getSession().getPacketBufferSize();
       // Resize buffer if needed.
       if (netSize > dst.capacity()) {
           ByteBuffer b = ByteBuffer.allocate(netSize);
           src.flip();
           b.put(src);
           src = b;
       }
       // Obtain more inbound network data for src,
       // then retry the operation.
       break;
   // other cases: CLOSED, OK.
   }
 
```
В отличие от этого SSLSocket, все методы SSLEngine неблокируют. SSLEngine реализации могут потребовать результатов задач, которые могут взять длительный период времени, чтобы завершиться, или могут даже блокировать. Например, TrustManager, возможно, должен соединиться с удаленной службой проверки допустимости сертификата, или KeyManager, возможно, должен был бы запросить пользователя определять который сертификат использовать в качестве части аутентификации клиента. Дополнительно, создание криптографических подписей и проверка их могут быть медленными, по-видимому блокируя.
Для любой работы, которая может потенциально блокировать, SSLEngine создаст a Runnable делегированная задача. Когда SSLEngineResult указывает, что делегированный результат задачи необходим, приложение должно вызвать getDelegatedTask() получить выдающуюся делегированную задачу и вызвать run() метод (возможно использующий различный поток в зависимости от вычислить стратегии). Приложение должно продолжать получать делегированные задачи, пока больше не существуют, и пробуют исходную работу снова.
В конце коммуникационного сеанса приложения должны должным образом закрыть ссылку SSL/TLS. У протоколов SSL/TLS есть сообщения квитирования закрытия, и эти сообщения должны быть переданы к коллеге прежде, чем выпустить SSLEngine и закрытие базового транспортного механизма. Завершение может инициироваться одним из: SSLException, входящее сообщение квитирования закрытия, или один из близких методов. Во всех случаях сообщения квитирования закрытия сгенерированы механизмом, и wrap() должен неоднократно вызываться до получающегося SSLEngineResult's возвраты состояния "ЗАКРЫЛСЯ", или isOutboundDone() возвращает true. Все данные, полученные из wrap() метод должен быть отправлен коллеге.
closeOutbound() используется, чтобы сигнализировать механизм, что приложение не будет отправлять больше данные.
Коллега будет сигнализировать свое намерение к рядом с отправкой ее собственного сообщения квитирования закрытия. После того, как это сообщение было получено и обработано локальной переменной SSLEngine's unwrap() вызовите, приложение может обнаружить рядом с вызовом unwrap() и поиск a SSLEngineResult с состоянием, "ЗАКРЫТЫМ", или если isInboundDone() возвращает true. Если по некоторым причинам коллега закрывает линию связи, не отправляя надлежащее сообщение закрытия SSL/TLS, приложение может обнаружить конец потока и может сигнализировать механизм через closeInbound() то, что там больше не будет входящих сообщений, чтобы обработать. Некоторые приложения могли бы хотеть требовать аккуратных сообщений завершения работы от коллеги, когда они могут проверить, что закрытие было сгенерировано сообщением квитирования а не условием конца потока.
Есть две группы комплектов шифра, о которых Вы должны будете знать, управляя комплектами шифра:
- Поддерживаемые комплекты шифра: все комплекты, которые поддерживаются реализацией SSL. Об этом списке сообщают, используя getSupportedCipherSuites().
- Включенные комплекты шифра, которые могут быть меньше чем полный комплект поддерживаемых комплектов. Эта группа устанавливается, используя setEnabledCipherSuites(String []) метод, и запрошенное использование getEnabledCipherSuites() метод. Первоначально, набор по умолчанию комплектов шифра будет включен на новом механизме, который представляет минимальную предложенную конфигурацию.
Значения по умолчанию реализации требуют, что только комплекты шифра, которые аутентифицируют серверы и обеспечивают конфиденциальность быть включенными по умолчанию. Только если обе стороны явно соглашаются на неаутентифицируемую и/или нечастную (незашифрованную) связь, будет такой комплект шифра быть выбранным.
У каждого соединения SSL/TLS должны быть один клиент и один сервер, таким образом каждая конечная точка должна решить который роль принять. Этот выбор определяет, кто начинает процесс квитирования так же как какой тип сообщений должен быть отправлен каждой стороной. Метод setUseClientMode(boolean) конфигурирует режим. Как только начальное квитирование запустилось, SSLEngine не может переключиться между режимами клиента и сервера, выполняя пересмотры.
Приложения могли бы хотеть обрабатывать делегированные задачи в различных потоках. Когда SSLEngine создается, ток AccessControlContext сохраняется. Все будущее делегированные задачи будет обработано, используя этот контекст: то есть, все решения управления доступом будут приняты, используя контекст, полученный при создании механизма.

Примечания параллелизма: есть две проблемы параллелизма, чтобы знать:
1. wrap() и unwrap() методы могут выполниться одновременно друг друга.
2. Протоколы SSL/TLS используют упорядоченные пакеты. Приложения должны заботиться, чтобы гарантировать, что сгенерированные пакеты поставляются в последовательности. Если пакеты прибывают не в порядке, неожиданные или фатальные результаты могут произойти.
  Например:
```
              synchronized (outboundLock) {
                  sslEngine.wrap(src, dst);
                  outboundQueue.put(dst);
              }
      
```
  Как заключение, два потока не должны попытаться вызвать тот же самый метод (также wrap() или unwrap()) одновременно, потому что нет никакого способа гарантировать возможное пакетное упорядочивание.
С тех пор:

1.5

См. Также:
SSLContext, SSLSocket, SSLServerSocket, SSLSession, Socket

Сводка конструктора

Конструкторы
Модификатор	Конструктор и Описание
`protected`	`SSLEngine()` Конструктор для `SSLEngine` обеспечение никаких подсказок для внутренней стратегии повторного использования сеанса.
`protected`	`SSLEngine(String peerHost, int peerPort)` Конструктор для `SSLEngine`.

Сводка метода

Методы
Модификатор и Тип	Метод и Описание
`abstract void`	`beginHandshake()` Новички, квитирующие (начальная буква или пересмотр) на этом SSLEngine.
`abstract void`	`closeInbound()` Сигналы, что больше входящих сетевых данных не будет отправлено этому `SSLEngine`.
`abstract void`	`closeOutbound()` Сигналы, что больше исходящих данных приложения не будет отправлено на этом `SSLEngine`.
`abstract Runnable`	`getDelegatedTask()` Возвращает делегированный `Runnable` задача для этого `SSLEngine`.
`abstract String[]`	`getEnabledCipherSuites()` Возвращает имена комплектов шифра SSL, которые в настоящий момент включаются для использования на этом механизме.
`abstract String[]`	`getEnabledProtocols()` Возвращает имена версий протокола, которые в настоящий момент включаются для использования с этим `SSLEngine`.
`abstract boolean`	`getEnableSessionCreation()` Возвращает true, если новые сеансы SSL могут быть установлены этим механизмом.
`SSLSession`	`getHandshakeSession()` Возвраты `SSLSession` будучи созданным во время квитирования SSL/TLS.
`abstract SSLEngineResult.HandshakeStatus`	`getHandshakeStatus()` Возвращает текущее состояние квитирования для этого `SSLEngine`.
`abstract boolean`	`getNeedClientAuth()` Возвращает true, если механизм потребует аутентификации клиента.
`Строка`	`getPeerHost()` Возвращает имя хоста коллеги.
`int`	`getPeerPort()` Возвращает номер порта коллеги.
`abstract SSLSession`	`getSession()` Возвраты `SSLSession` в использовании в этом `SSLEngine`.
`SSLParameters`	`getSSLParameters()` Возвращает SSLParameters в действительности для этого SSLEngine.
`abstract String[]`	`getSupportedCipherSuites()` Возвращает имена комплектов шифра, которые могли быть включены для использования на этом механизме.
`abstract String[]`	`getSupportedProtocols()` Возвращает имена протоколов, которые могли быть включены для использования с этим `SSLEngine`.
`abstract boolean`	`getUseClientMode()` Возвращает true, если механизм устанавливается использовать клиентский режим, квитируя.
`abstract boolean`	`getWantClientAuth()` Возвращает true, если механизм запросит аутентификацию клиента.
`abstract boolean`	`isInboundDone()` Возвраты, ли `unwrap(ByteBuffer, ByteBuffer)` будет больше принимать входящие сообщения данных.
`abstract boolean`	`isOutboundDone()` Возвраты, ли `wrap(ByteBuffer, ByteBuffer)` будет больше производить исходящие сообщения данных.
`abstract void`	`setEnabledCipherSuites(String[] suites)` Устанавливает комплекты шифра, включенные для использования на этом механизме.
`abstract void`	`setEnabledProtocols(String[] protocols)` Установите версии протокола, включенные для использования на этом механизме.
`abstract void`	`setEnableSessionCreation(boolean flag)` Средства управления, могут ли новые сеансы SSL быть установлены этим механизмом.
`abstract void`	`setNeedClientAuth(boolean need)` Конфигурирует механизм, чтобы потребовать аутентификации клиента.
`void`	`setSSLParameters(SSLParameters params)` Применяет SSLParameters к этому механизму.
`abstract void`	`setUseClientMode(boolean mode)` Конфигурирует механизм, чтобы использовать клиент (или сервер) режим, квитируя.
`abstract void`	`setWantClientAuth(boolean want)` Конфигурирует механизм, чтобы запросить аутентификацию клиента.
`SSLEngineResult`	`unwrap(ByteBuffer src, ByteBuffer dst)` Попытки декодировать данные сети SSL/TLS в буфер данных приложения простого текста.
`SSLEngineResult`	`unwrap(ByteBuffer src, ByteBuffer[] dsts)` Попытки декодировать данные сети SSL/TLS в последовательность буферов данных приложения простого текста.
`abstract SSLEngineResult`	`unwrap(ByteBuffer src, ByteBuffer[] dsts, int offset, int length)` Попытки декодировать данные сети SSL/TLS в подпоследовательность буферов данных приложения простого текста.
`SSLEngineResult`	`wrap(ByteBuffer[] srcs, ByteBuffer dst)` Попытки закодировать байты простого текста от последовательности буферов данных в данные сети SSL/TLS.
`abstract SSLEngineResult`	`wrap(ByteBuffer[] srcs, int offset, int length, ByteBuffer dst)` Попытки закодировать байты простого текста от подпоследовательности буферов данных в данные сети SSL/TLS.
`SSLEngineResult`	`wrap(ByteBuffer src, ByteBuffer dst)` Попытки закодировать буфер данных приложения простого текста в данные сети SSL/TLS.

Методы java.lang унаследованный от класса. Объект
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Деталь конструктора
  - SSLEngine
```
protected SSLEngine()
```
    Конструктор для SSLEngine обеспечение никаких подсказок для внутренней стратегии повторного использования сеанса.
    
    См. Также:
    SSLContext.createSSLEngine(), SSLSessionContext
  - SSLEngine
```
protected SSLEngine(String peerHost,
         int peerPort)
```
    Конструктор для SSLEngine.
    SSLEngine реализации могут использовать peerHost и peerPort параметры как подсказки для их внутренней стратегии повторного использования сеанса.
    Некоторые комплекты шифра (такие как Kerberos) запрашивают удаленную информацию имени хоста. Реализации этого класса должны использовать этого конструктора, чтобы использовать Kerberos.
    Параметры не аутентифицируются SSLEngine.
    
    Параметры:
    peerHost - имя равноправного узла
    peerPort - номер порта коллеги
    См. Также:
    SSLContext.createSSLEngine(String, int), SSLSessionContext
- Деталь метода
  - getPeerHost
```
public String getPeerHost()
```
    Возвращает имя хоста коллеги.
    Отметьте, что значение не аутентифицируется, и не должно быть положено.
    
    Возвраты:
    имя хоста коллеги, или нуль, если ничто не доступно.
  - getPeerPort
```
public int getPeerPort()
```
    Возвращает номер порта коллеги.
    Отметьте, что значение не аутентифицируется, и не должно быть положено.
    
    Возвраты:
    номер порта коллеги, или-1, если ничто не доступно.
  - обертка
```
public SSLEngineResult wrap(ByteBuffer src,
                   ByteBuffer dst)
                     throws SSLException
```
    Попытки закодировать буфер данных приложения простого текста в данные сети SSL/TLS.
    Вызов этого метода ведет себя точно тем же самым способом как вызов:
    engine.wrap(new ByteBuffer [] { src }, 0, 1, dst);
    Parameters:
    src - a ByteBuffer containing outbound application data
    dst - a ByteBuffer to hold outbound network data
    
    Returns:
    an SSLEngineResult describing the result of this operation.
    
    Throws:
    
    SSLException - A problem was encountered while processing the data that caused the SSLEngine to abort. See the class description for more information on engine closure.
    
    ReadOnlyBufferException - if the dst buffer is read-only.
    
    IllegalArgumentException - if either src or dst is null.
    
    IllegalStateException - if the client/server mode has not yet been set.
    See Also:
    wrap(ByteBuffer [], int, int, ByteBuffer)
  - wrap
```
public SSLEngineResult wrap(ByteBuffer[] srcs,
                   ByteBuffer dst)
                     throws SSLException
```
    Attempts to encode plaintext bytes from a sequence of data buffers into SSL/TLS network data.
    An invocation of this method behaves in exactly the same manner as the invocation:
    engine.wrap(srcs, 0, srcs.length, dst);
    Parameters:
    srcs - an array of ByteBuffers containing the outbound application data
    dst - a ByteBuffer to hold outbound network data
    
    Returns:
    an SSLEngineResult describing the result of this operation.
    
    Throws:
    
    SSLException - A problem was encountered while processing the data that caused the SSLEngine to abort. See the class description for more information on engine closure.
    
    ReadOnlyBufferException - if the dst buffer is read-only.
    
    IllegalArgumentException - if either srcs or dst is null, or if any element in srcs is null.
    
    IllegalStateException - if the client/server mode has not yet been set.
    See Also:
    wrap(ByteBuffer [], int, int, ByteBuffer)
  - wrap
```
public abstract SSLEngineResult wrap(ByteBuffer[] srcs,
                   int offset,
                   int length,
                   ByteBuffer dst)
                              throws SSLException
```
    Attempts to encode plaintext bytes from a subsequence of data buffers into SSL/TLS network data. This "gathering" operation encodes, in a single invocation, a sequence of bytes from one or more of a given sequence of buffers. Gathering wraps are often useful when implementing network protocols or file formats that, for example, group data into segments consisting of one or more fixed-length headers followed by a variable-length body. See GatheringByteChannel for more information on gathering, and GatheringByteChannel.write(ByteBuffer[], int, int) for more information on the subsequence behavior.
    Depending on the state of the SSLEngine, this method may produce network data without consuming any application data (for example, it may generate handshake data.)
    The application is responsible for reliably transporting the network data to the peer, and for ensuring that data created by multiple calls to wrap() is transported in the same order in which it was generated. The application must properly synchronize multiple calls to this method.
    If this SSLEngine has not yet started its initial handshake, this method will automatically start the handshake.
    This method will attempt to produce one SSL/TLS packet, and will consume as much source data as possible, but will never consume more than the sum of the bytes remaining in each buffer. Each ByteBuffer's position is updated to reflect the amount of data consumed or produced. The limits remain the same.
    The underlying memory used by the srcs and dst ByteBuffers must not be the same.
    See the class description for more information on engine closure.
    
    Parameters:
    srcs - an array of ByteBuffers containing the outbound application data
    offset - The offset within the buffer array of the first buffer from which bytes are to be retrieved; it must be non-negative and no larger than srcs.length
    length - The maximum number of buffers to be accessed; it must be non-negative and no larger than srcs.length - offset
    dst - a ByteBuffer to hold outbound network data
    
    Returns:
    an SSLEngineResult describing the result of this operation.
    
    Throws:
    
    SSLException - A problem was encountered while processing the data that caused the SSLEngine to abort. See the class description for more information on engine closure.
    
    IndexOutOfBoundsException - if the preconditions on the offset and length parameters do not hold.
    
    ReadOnlyBufferException - if the dst buffer is read-only.
    
    IllegalArgumentException - if either srcs or dst is null, or if any element in the srcs subsequence specified is null.
    
    IllegalStateException - if the client/server mode has not yet been set.
    See Also:
    GatheringByteChannel, GatheringByteChannel.write( ByteBuffer[], int, int)
  - unwrap
```
public SSLEngineResult unwrap(ByteBuffer src,
                     ByteBuffer dst)
                       throws SSLException
```
    Attempts to decode SSL/TLS network data into a plaintext application data buffer.
    An invocation of this method behaves in exactly the same manner as the invocation:
    engine.unwrap(src, new ByteBuffer [] { dst }, 0, 1);
    Parameters:
    src - a ByteBuffer containing inbound network data.
    dst - a ByteBuffer to hold inbound application data.
    
    Returns:
    an SSLEngineResult describing the result of this operation.
    
    Throws:
    
    SSLException - A problem was encountered while processing the data that caused the SSLEngine to abort. See the class description for more information on engine closure.
    
    ReadOnlyBufferException - if the dst buffer is read-only.
    
    IllegalArgumentException - if either src or dst is null.
    
    IllegalStateException - if the client/server mode has not yet been set.
    See Also:
    unwrap(ByteBuffer, ByteBuffer [], int, int)
  - unwrap
```
public SSLEngineResult unwrap(ByteBuffer src,
                     ByteBuffer[] dsts)
                       throws SSLException
```
    Attempts to decode SSL/TLS network data into a sequence of plaintext application data buffers.
    An invocation of this method behaves in exactly the same manner as the invocation:
    engine.unwrap(src, dsts, 0, dsts.length);
    Parameters:
    src - a ByteBuffer containing inbound network data.
    dsts - an array of ByteBuffers to hold inbound application data.
    
    Returns:
    an SSLEngineResult describing the result of this operation.
    
    Throws:
    
    SSLException - A problem was encountered while processing the data that caused the SSLEngine to abort. See the class description for more information on engine closure.
    
    ReadOnlyBufferException - if any of the dst buffers are read-only.
    
    IllegalArgumentException - if either src or dsts is null, or if any element in dsts is null.
    
    IllegalStateException - if the client/server mode has not yet been set.
    See Also:
    unwrap(ByteBuffer, ByteBuffer [], int, int)
  - unwrap
```
public abstract SSLEngineResult unwrap(ByteBuffer src,
                     ByteBuffer[] dsts,
                     int offset,
                     int length)
                                throws SSLException
```
    Attempts to decode SSL/TLS network data into a subsequence of plaintext application data buffers. This "scattering" operation decodes, in a single invocation, a sequence of bytes into one or more of a given sequence of buffers. Scattering unwraps are often useful when implementing network protocols or file formats that, for example, group data into segments consisting of one or more fixed-length headers followed by a variable-length body. See ScatteringByteChannel for more information on scattering, and ScatteringByteChannel.read(ByteBuffer[], int, int) for more information on the subsequence behavior.
    Depending on the state of the SSLEngine, this method may consume network data without producing any application data (for example, it may consume handshake data.)
    The application is responsible for reliably obtaining the network data from the peer, and for invoking unwrap() on the data in the order it was received. The application must properly synchronize multiple calls to this method.
    If this SSLEngine has not yet started its initial handshake, this method will automatically start the handshake.
    This method will attempt to consume one complete SSL/TLS network packet, but will never consume more than the sum of the bytes remaining in the buffers. Each ByteBuffer's position is updated to reflect the amount of data consumed or produced. The limits remain the same.
    The underlying memory used by the src and dsts ByteBuffers must not be the same.
    The inbound network buffer may be modified as a result of this call: therefore if the network data packet is required for some secondary purpose, the data should be duplicated before calling this method. Note: the network data will not be useful to a second SSLEngine, as each SSLEngine contains unique random state which influences the SSL/TLS messages.
    See the class description for more information on engine closure.
    
    Parameters:
    src - a ByteBuffer containing inbound network data.
    dsts - an array of ByteBuffers to hold inbound application data.
    offset - The offset within the buffer array of the first buffer from which bytes are to be transferred; it must be non-negative and no larger than dsts.length.
    length - The maximum number of buffers to be accessed; it must be non-negative and no larger than dsts.length - offset.
    
    Returns:
    an SSLEngineResult describing the result of this operation.
    
    Throws:
    
    SSLException - A problem was encountered while processing the data that caused the SSLEngine to abort. See the class description for more information on engine closure.
    
    IndexOutOfBoundsException - If the preconditions on the offset and length parameters do not hold.
    
    ReadOnlyBufferException - if any of the dst buffers are read-only.
    
    IllegalArgumentException - if either src or dsts is null, or if any element in the dsts subsequence specified is null.
    
    IllegalStateException - if the client/server mode has not yet been set.
    See Also:
    ScatteringByteChannel, ScatteringByteChannel.read( ByteBuffer[], int, int)
  - getDelegatedTask
```
public abstract Runnable getDelegatedTask()
```
    Returns a delegated Runnable task for this SSLEngine.
    SSLEngine operations may require the results of operations that block, or may take an extended period of time to complete. This method is used to obtain an outstanding Runnable operation (task). Each task must be assigned a thread (possibly the current) to perform the run operation. Once the run method returns, the Runnable object is no longer needed and may be discarded.
    Delegated tasks run in the AccessControlContext in place when this object was created.
    A call to this method will return each outstanding task exactly once.
    Multiple delegated tasks can be run in parallel.
    
    Returns:
    a delegated Runnable task, or null if none are available.
  - closeInbound
```
public abstract void closeInbound()
                           throws SSLException
```
    Signals that no more inbound network data will be sent to this SSLEngine.
    If the application initiated the closing process by calling closeOutbound(), under some circumstances it is not required that the initiator wait for the peer's corresponding close message. (See section 7.2.1 of the TLS specification (RFC 2246) for more information on waiting for closure alerts.) In such cases, this method need not be called.
    But if the application did not initiate the closure process, or if the circumstances above do not apply, this method should be called whenever the end of the SSL/TLS data stream is reached. This ensures closure of the inbound side, and checks that the peer followed the SSL/TLS close procedure properly, thus detecting possible truncation attacks.
    This method is idempotent: if the inbound side has already been closed, this method does not do anything.
    wrap() should be called to flush any remaining handshake data.
    
    Throws:
    
    SSLException - if this engine has not received the proper SSL/TLS close notification message from the peer.
    See Also:
    isInboundDone(), isOutboundDone()
  - isInboundDone
```
public abstract boolean isInboundDone()
```
    Returns whether unwrap(ByteBuffer, ByteBuffer) will accept any more inbound data messages.
    
    Returns:
    true if the SSLEngine will not consume anymore network data (and by implication, will not produce any more application data.)
    See Also:
    closeInbound()
  - closeOutbound
```
public abstract void closeOutbound()
```
    Signals that no more outbound application data will be sent on this SSLEngine.
    This method is idempotent: if the outbound side has already been closed, this method does not do anything.
    wrap(ByteBuffer, ByteBuffer) should be called to flush any remaining handshake data.
    
    See Also:
    isOutboundDone()
  - isOutboundDone
```
public abstract boolean isOutboundDone()
```
    Returns whether wrap(ByteBuffer, ByteBuffer) will produce any more outbound data messages.
    Note that during the closure phase, a SSLEngine may generate handshake closure data that must be sent to the peer. wrap() must be called to generate this data. When this method returns true, no more outbound data will be created.
    
    Returns:
    true if the SSLEngine will not produce any more network data
    See Also:
    closeOutbound(), closeInbound()
  - getSupportedCipherSuites
```
public abstract String[] getSupportedCipherSuites()
```
    Returns the names of the cipher suites which could be enabled for use on this engine. Normally, only a subset of these will actually be enabled by default, since this list may include cipher suites which do not meet quality of service requirements for those defaults. Such cipher suites might be useful in specialized applications.
    
    Returns:
    an array of cipher suite names
    See Also:
    getEnabledCipherSuites(), setEnabledCipherSuites(String [])
  - getEnabledCipherSuites
```
public abstract String[] getEnabledCipherSuites()
```
    Returns the names of the SSL cipher suites which are currently enabled for use on this engine. When an SSLEngine is first created, all enabled cipher suites support a minimum quality of service. Thus, in some environments this value might be empty.
    Even if a suite has been enabled, it might never be used. (For example, the peer does not support it, the requisite certificates/private keys for the suite are not available, or an anonymous suite is enabled but authentication is required.)
    
    Returns:
    an array of cipher suite names
    See Also:
    getSupportedCipherSuites(), setEnabledCipherSuites(String [])
  - setEnabledCipherSuites
```
public abstract void setEnabledCipherSuites(String[] suites)
```
    Sets the cipher suites enabled for use on this engine.
    Each cipher suite in the suites parameter must have been listed by getSupportedCipherSuites(), or the method will fail. Following a successful call to this method, only suites listed in the suites parameter are enabled for use.
    See getEnabledCipherSuites() for more information on why a specific cipher suite may never be used on a engine.
    
    Parameters:
    suites - Names of all the cipher suites to enable
    
    Throws:
    
    IllegalArgumentException - when one or more of the ciphers named by the parameter is not supported, or when the parameter is null.
    See Also:
    getSupportedCipherSuites(), getEnabledCipherSuites()
  - getSupportedProtocols
```
public abstract String[] getSupportedProtocols()
```
    Returns the names of the protocols which could be enabled for use with this SSLEngine.
    
    Returns:
    an array of protocols supported
  - getEnabledProtocols
```
public abstract String[] getEnabledProtocols()
```
    Returns the names of the protocol versions which are currently enabled for use with this SSLEngine.
    
    Returns:
    an array of protocols
    See Also:
    setEnabledProtocols(String [])
  - setEnabledProtocols
```
public abstract void setEnabledProtocols(String[] protocols)
```
    Set the protocol versions enabled for use on this engine.
    The protocols must have been listed by getSupportedProtocols() as being supported. Following a successful call to this method, only protocols listed in the protocols parameter are enabled for use.
    
    Parameters:
    protocols - Names of all the protocols to enable.
    
    Throws:
    
    IllegalArgumentException - when one or more of the protocols named by the parameter is not supported or when the protocols parameter is null.
    See Also:
    getEnabledProtocols()
  - getSession
```
public abstract SSLSession getSession()
```
    Returns the SSLSession in use in this SSLEngine.
    These can be long lived, and frequently correspond to an entire login session for some user. The session specifies a particular cipher suite which is being actively used by all connections in that session, as well as the identities of the session's client and server.
    Unlike SSLSocket.getSession() this method does not block until handshaking is complete.
    Until the initial handshake has completed, this method returns a session object which reports an invalid cipher suite of "SSL_NULL_WITH_NULL_NULL".
    
    Returns:
    the SSLSession for this SSLEngine
    See Also:
    SSLSession
  - getHandshakeSession
```
public SSLSession getHandshakeSession()
```
    Returns the SSLSession being constructed during a SSL/TLS handshake.
    TLS protocols may negotiate parameters that are needed when using an instance of this class, but before the SSLSession has been completely initialized and made available via getSession. For example, the list of valid signature algorithms may restrict the type of certificates that can used during TrustManager decisions, or the maximum TLS fragment packet sizes can be resized to better support the network environment.
    This method provides early access to the SSLSession being constructed. Depending on how far the handshake has progressed, some data may not yet be available for use. For example, if a remote server will be sending a Certificate chain, but that chain has yet not been processed, the getPeerCertificates method of SSLSession will throw a SSLPeerUnverifiedException. Once that chain has been processed, getPeerCertificates will return the proper value.
    
    Returns:
    null if this instance is not currently handshaking, or if the current handshake has not progressed far enough to create a basic SSLSession. Otherwise, this method returns the SSLSession currently being negotiated.
    
    Throws:
    
    UnsupportedOperationException - if the underlying provider does not implement the operation.
    Since:
    
    1.7
    
    See Also:
    SSLSocket, SSLSession, ExtendedSSLSession, X509ExtendedKeyManager, X509ExtendedTrustManager
  - beginHandshake
```
public abstract void beginHandshake()
                             throws SSLException
```
    Initiates handshaking (initial or renegotiation) on this SSLEngine.
    This method is not needed for the initial handshake, as the wrap() and unwrap() methods will implicitly call this method if handshaking has not already begun.
    Note that the peer may also request a session renegotiation with this SSLEngine by sending the appropriate session renegotiate handshake message.
    Unlike the SSLSocket#startHandshake() method, this method does not block until handshaking is completed.
    To force a complete SSL/TLS session renegotiation, the current session should be invalidated prior to calling this method.
    Some protocols may not support multiple handshakes on an existing engine and may throw an SSLException.
    
    Throws:
    
    SSLException - if a problem was encountered while signaling the SSLEngine to begin a new handshake. See the class description for more information on engine closure.
    
    IllegalStateException - if the client/server mode has not yet been set.
    See Also:
    SSLSession.invalidate()
  - getHandshakeStatus
```
public abstract SSLEngineResult.HandshakeStatus getHandshakeStatus()
```
    Returns the current handshake status for this SSLEngine.
    
    Returns:
    the current SSLEngineResult.HandshakeStatus.
  - setUseClientMode
```
public abstract void setUseClientMode(boolean mode)
```
    Configures the engine to use client (or server) mode when handshaking.
    This method must be called before any handshaking occurs. Once handshaking has begun, the mode can not be reset for the life of this engine.
    Servers normally authenticate themselves, and clients are not required to do so.
    
    Parameters:
    mode - true if the engine should start its handshaking in "client" mode
    
    Throws:
    
    IllegalArgumentException - if a mode change is attempted after the initial handshake has begun.
    See Also:
    getUseClientMode()
  - getUseClientMode
```
public abstract boolean getUseClientMode()
```
    Returns true if the engine is set to use client mode when handshaking.
    
    Returns:
    true if the engine should do handshaking in "client" mode
    See Also:
    setUseClientMode(boolean)
  - setNeedClientAuth
```
public abstract void setNeedClientAuth(boolean need)
```
    Configures the engine to require client authentication. This option is only useful for engines in the server mode.
    An engine's client authentication setting is one of the following:
    - client authentication required
    - client authentication requested
    - no client authentication desired
    Unlike setWantClientAuth(boolean), if this option is set and the client chooses not to provide authentication information about itself, the negotiations will stop and the engine will begin its closure procedure.
    Calling this method overrides any previous setting made by this method or setWantClientAuth(boolean).
    Parameters:
    need - set to true if client authentication is required, or false if no client authentication is desired.
    See Also:
    getNeedClientAuth(), setWantClientAuth(boolean), getWantClientAuth(), setUseClientMode(boolean)
  - getNeedClientAuth
```
public abstract boolean getNeedClientAuth()
```
    Returns true if the engine will require client authentication. This option is only useful to engines in the server mode.
    
    Returns:
    true if client authentication is required, or false if no client authentication is desired.
    See Also:
    setNeedClientAuth(boolean), setWantClientAuth(boolean), getWantClientAuth(), setUseClientMode(boolean)
  - setWantClientAuth
```
public abstract void setWantClientAuth(boolean want)
```
    Configures the engine to request client authentication. This option is only useful for engines in the server mode.
    An engine's client authentication setting is one of the following:
    - client authentication required
    - client authentication requested
    - no client authentication desired
    Unlike setNeedClientAuth(boolean), if this option is set and the client chooses not to provide authentication information about itself, the negotiations will continue.
    Calling this method overrides any previous setting made by this method or setNeedClientAuth(boolean).
    Parameters:
    want - set to true if client authentication is requested, or false if no client authentication is desired.
    See Also:
    getWantClientAuth(), setNeedClientAuth(boolean), getNeedClientAuth(), setUseClientMode(boolean)
  - getWantClientAuth
```
public abstract boolean getWantClientAuth()
```
    Returns true if the engine will request client authentication. This option is only useful for engines in the server mode.
    
    Returns:
    true if client authentication is requested, or false if no client authentication is desired.
    See Also:
    setNeedClientAuth(boolean), getNeedClientAuth(), setWantClientAuth(boolean), setUseClientMode(boolean)
  - setEnableSessionCreation
```
public abstract void setEnableSessionCreation(boolean flag)
```
    Controls whether new SSL sessions may be established by this engine. If session creations are not allowed, and there are no existing sessions to resume, there will be no successful handshaking.
    
    Parameters:
    flag - true indicates that sessions may be created; this is the default. false indicates that an existing session must be resumed
    See Also:
    getEnableSessionCreation()
  - getEnableSessionCreation
```
public abstract boolean getEnableSessionCreation()
```
    Returns true if new SSL sessions may be established by this engine.
    
    Returns:
    true indicates that sessions may be created; this is the default. false indicates that an existing session must be resumed
    See Also:
    setEnableSessionCreation(boolean)
  - getSSLParameters
```
public SSLParameters getSSLParameters()
```
    Returns the SSLParameters in effect for this SSLEngine. The ciphersuites and protocols of the returned SSLParameters are always non-null.
    
    Returns:
    the SSLParameters in effect for this SSLEngine.
    Since:
    
    1.6
  - setSSLParameters
```
public void setSSLParameters(SSLParameters params)
```
    Applies SSLParameters to this engine.
    This means:
    - if params.getCipherSuites() is non-null, setEnabledCipherSuites() is called with that value
    - if params.getProtocols() is non-null, setEnabledProtocols() is called with that value
    - if params.getNeedClientAuth() or params.getWantClientAuth() return true, setNeedClientAuth(true) and setWantClientAuth(true) are called, respectively; otherwise setWantClientAuth(false) is called.
    Parameters:
    params - the parameters
    
    Throws:
    
    IllegalArgumentException - if the setEnabledCipherSuites() or the setEnabledProtocols() call fails
    Since:
    
    1.6

Представьте ошибку или функцию
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2011, Oracle and/or its affiliates. All rights reserved.

Класс SSLEngine

Сводка конструктора

Сводка метода

Методы java.lang унаследованный от класса. Объект

Деталь конструктора

SSLEngine

SSLEngine

Деталь метода

getPeerHost

getPeerPort

обертка

wrap

wrap

unwrap

unwrap

unwrap

getDelegatedTask

closeInbound

isInboundDone

closeOutbound

isOutboundDone

getSupportedCipherSuites

getEnabledCipherSuites

setEnabledCipherSuites

getSupportedProtocols

getEnabledProtocols

setEnabledProtocols

getSession

getHandshakeSession

beginHandshake

getHandshakeStatus

setUseClientMode

getUseClientMode

setNeedClientAuth

getNeedClientAuth

setWantClientAuth

getWantClientAuth

setEnableSessionCreation

getEnableSessionCreation

getSSLParameters

setSSLParameters