For the latest news and information visit The GNU Crypto project

## gnu.crypto.sasl
Class ServerMechanism

    java.lang.Object
      |
      +--gnu.crypto.sasl.ServerMechanism

All Implemented Interfaces:
  SaslServer

Direct Known Subclasses:
  AnonymousServer, CramMD5Server, PlainServer, SRPServer

public abstract class ServerMechanism
extends java.lang.Object
implements SaslServer

A base class to facilitate implementing SASL server-side mechanisms.

Field Summary
`protected IAuthInfoProvider` `authenticator` The provider for authentication information.
`protected java.lang.String` `authorizationID` The authorisation identity.
`protected byte[]` `channelBinding` Channel binding data to use with this mechanism instance.
`protected boolean` `complete` Whether authentication phase is completed (true) or not (false).
`protected CallbackHandler` `handler` Callback handler to use with this mechanism instance.
`protected java.lang.String` `mechanism` Name of this mechanism.
`protected java.util.Map` `properties` Properties of qualities desired for this mechanism.
`protected java.lang.String` `protocol` Name of protocol using this mechanism.
`protected java.lang.String` `serverName` Name of server to authenticate to.
`protected int` `state` The state of the authentication automaton.

Constructor Summary
`protected` `ServerMechanism(java.lang.String mechanism)`

Method Summary
`void` `dispose()` Disposes of any system resources or security-sensitive information the `SaslServer` might be using.
`protected byte[]` `engineUnwrap(byte[] incoming, int offset, int len)`
`protected byte[]` `engineWrap(byte[] outgoing, int offset, int len)`
`abstract byte[]` `evaluateResponse(byte[] response)` Evaluates the response data and generates a challenge.
`java.lang.String` `getAuthorizationID()` Reports the authorization ID in effect for the client of this session This method can only be called if `isComplete()` returns `true`.
`java.lang.String` `getMechanismName()` Returns the IANA-registered mechanism name of this SASL server (e.g.
`protected java.lang.String` `getNegotiatedMaxBuffer()`
`protected java.lang.String` `getNegotiatedPolicyForwardSecrecy()`
`protected java.lang.String` `getNegotiatedPolicyNoActive()`
`protected java.lang.String` `getNegotiatedPolicyNoAnonymous()`
`protected java.lang.String` `getNegotiatedPolicyNoDictionary()`
`protected java.lang.String` `getNegotiatedPolicyNoPlainText()`
`protected java.lang.String` `getNegotiatedPolicyPassCredentials()`
`java.lang.Object` `getNegotiatedProperty(java.lang.String propName)` Retrieves the negotiated property.
`protected java.lang.String` `getNegotiatedQOP()`
`protected java.lang.String` `getNegotiatedRawSendSize()`
`protected java.lang.String` `getNegotiatedServerAuth()`
`protected java.lang.String` `getNegotiatedStrength()`
`protected java.lang.String` `getReuse()`
`void` `init(java.util.Map attributes)` Initialises the mechanism with designated attributes.
`protected abstract void` `initMechanism()`
`boolean` `isComplete()` Determines if the authentication exchange has completed.
`void` `reset()` Resets the mechanism instance for re-initialisation and use with other characteristics.
`protected abstract void` `resetMechanism()`
`byte[]` `unwrap(byte[] incoming, int offset, int len)` Unwraps a byte array received from the client.
`byte[]` `wrap(byte[] outgoing, int offset, int len)` Wraps a byte array to be sent to the client.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### mechanism

    protected java.lang.String mechanism

  Name of this mechanism.

### protocol

    protected java.lang.String protocol

  Name of protocol using this mechanism.

### serverName

    protected java.lang.String serverName

  Name of server to authenticate to.

### properties

    protected java.util.Map properties

  Properties of qualities desired for this mechanism.

### handler

    protected CallbackHandler handler

  Callback handler to use with this mechanism instance.

### complete

    protected boolean complete

  Whether authentication phase is completed (true) or not (false).

### authorizationID

    protected java.lang.String authorizationID

  The authorisation identity.

### channelBinding

    protected byte[] channelBinding

  Channel binding data to use with this mechanism instance.

### state

    protected int state

  The state of the authentication automaton. -1 means uninitialised.

### authenticator

    protected IAuthInfoProvider authenticator

  The provider for authentication information.

Constructor Detail

### ServerMechanism

    protected ServerMechanism(java.lang.String mechanism)

Method Detail

### initMechanism

    protected abstract void initMechanism()
                                   throws SaslException

    `SaslException`

### resetMechanism

    protected abstract void resetMechanism()
                                    throws SaslException

    `SaslException`

### evaluateResponse

    public abstract byte[] evaluateResponse(byte[] response)
                                     throws SaslException

  Description copied from interface: `SaslServer`
  Evaluates the response data and generates a challenge. If a response is received from the client during the authentication process, this method is called to prepare an appropriate next challenge to submit to the client. The challenge is `null` if the authentication has succeeded and no more challenge data is to be sent to the client. It is non-null if the authentication must be continued by sending a challenge to the client, or if the authentication has succeeded but challenge data needs to be processed by the client. `SaslServer.isComplete()` should be called after each call to `evaluateResponse()`,to determine if any further response is needed from the client.

  Specified by:
    `evaluateResponse` in interface `SaslServer`
  Parameters:
    `response` - the non-null (but possibly empty) response sent by the client.
  Returns:
    the possibly `null` challenge to send to the client. It is `null` if the authentication has succeeded and there is no more challenge data to be sent to the client.
  Throws:
    `SaslException` - if an error occurred while processing the response or generating a challenge.

### isComplete

    public boolean isComplete()

  Description copied from interface: `SaslServer`
  Determines if the authentication exchange has completed. This method is typically called after each invocation of `SaslServer.evaluateResponse(byte[])` to determine whether the authentication has completed successfully or should be continued.

  Specified by:
    `isComplete` in interface `SaslServer`
  Returns:
    `true` if the authentication exchange has completed; `false` otherwise.

### unwrap

    public byte[] unwrap(byte[] incoming,
                         int offset,
                         int len)
                  throws SaslException

  Description copied from interface: `SaslServer`

  Unwraps a byte array received from the client. This method can be called only after the authentication exchange has completed (i.e., when `SaslServer.isComplete()` returns `true`) and only if the authentication exchange has negotiated integrity and/or privacy as the quality of protection; otherwise, an `IllegalStateException` is thrown.

  `incoming` is the contents of the SASL buffer as defined in RFC 2222 without the leading four octet field that represents the length. `offset` and `len` specify the portion of incoming to use.

  Specified by:
    `unwrap` in interface `SaslServer`
  Parameters:
    `incoming` - a non-null byte array containing the encoded bytes from the client.
    `offset` - the starting position at `incoming` of the bytes to use.
    `len` - the number of bytes from `incoming` to use.
  Returns:
    a non-null byte array containing the decoded bytes.
  Throws:
    `SaslException` - if `incoming` cannot be successfully unwrapped.

### wrap

    public byte[] wrap(byte[] outgoing,
                       int offset,
                       int len)
                throws SaslException

  Description copied from interface: `SaslServer`

  Wraps a byte array to be sent to the client. This method can be called only after the authentication exchange has completed (i.e., when `SaslServer.isComplete()` returns `true`) and only if the authentication exchange has negotiated integrity and/or privacy as the quality of protection; otherwise, an `IllegalStateException` is thrown.

  The result of this method will make up the contents of the SASL buffer as defined in RFC 2222 without the leading four octet field that represents the length. `offset` and `len` specify the portion of `outgoing` to use.

  Specified by:
    `wrap` in interface `SaslServer`
  Parameters:
    `outgoing` - a non-null byte array containing the bytes to encode.
    `offset` - the starting position at `outgoing` of the bytes to use.
    `len` - the number of bytes from `outgoing` to use.
  Returns:
    a non-null byte array containing the encoded bytes.
  Throws:
    `SaslException` - if `outgoing` cannot be successfully wrapped.

### getMechanismName

    public java.lang.String getMechanismName()

  Description copied from interface: `SaslServer`
  Returns the IANA-registered mechanism name of this SASL server (e.g. "CRAM-MD5", "GSSAPI").

  Specified by:
    `getMechanismName` in interface `SaslServer`
  Returns:
    a non-null string representing the IANA-registered mechanism name.

### getAuthorizationID

    public java.lang.String getAuthorizationID()

  Description copied from interface: `SaslServer`
  Reports the authorization ID in effect for the client of this session This method can only be called if `SaslServer.isComplete()` returns `true`.

  Specified by:
    `getAuthorizationID` in interface `SaslServer`
  Returns:
    the authorization ID of the client.

### getNegotiatedProperty

    public java.lang.Object getNegotiatedProperty(java.lang.String propName)
                                           throws SaslException

  Description copied from interface: `SaslServer`
  Retrieves the negotiated property. This method can be called only after the authentication exchange has completed (i.e., when `SaslServer.isComplete()` returns `true`); otherwise, an `IllegalStateException` is thrown.

  Specified by:
    `getNegotiatedProperty` in interface `SaslServer`
  Returns:
    the value of the negotiated property. If `null`, the property was not negotiated or is not applicable to this mechanism.
    `SaslException`

### dispose

    public void dispose()
                 throws SaslException

  Description copied from interface: `SaslServer`
  Disposes of any system resources or security-sensitive information the `SaslServer` might be using. Invoking this method invalidates the `SaslServer` instance. This method is idempotent.

  Specified by:
    `dispose` in interface `SaslServer`
  Throws:
    `SaslException` - if a problem was encountered while disposing of the resources.

### getNegotiatedQOP

    protected java.lang.String getNegotiatedQOP()

### getNegotiatedStrength

    protected java.lang.String getNegotiatedStrength()

### getNegotiatedServerAuth

    protected java.lang.String getNegotiatedServerAuth()

### getNegotiatedMaxBuffer

    protected java.lang.String getNegotiatedMaxBuffer()

### getNegotiatedPolicyNoPlainText

    protected java.lang.String getNegotiatedPolicyNoPlainText()

### getNegotiatedPolicyNoActive

    protected java.lang.String getNegotiatedPolicyNoActive()

### getNegotiatedPolicyNoDictionary

    protected java.lang.String getNegotiatedPolicyNoDictionary()

### getNegotiatedPolicyNoAnonymous

    protected java.lang.String getNegotiatedPolicyNoAnonymous()

### getNegotiatedPolicyForwardSecrecy

    protected java.lang.String getNegotiatedPolicyForwardSecrecy()

### getNegotiatedPolicyPassCredentials

    protected java.lang.String getNegotiatedPolicyPassCredentials()

### getNegotiatedRawSendSize

    protected java.lang.String getNegotiatedRawSendSize()

### getReuse

    protected java.lang.String getReuse()

### engineUnwrap

    protected byte[] engineUnwrap(byte[] incoming,
                                  int offset,
                                  int len)
                           throws SaslException

    `SaslException`

### engineWrap

    protected byte[] engineWrap(byte[] outgoing,
                                int offset,
                                int len)
                         throws SaslException

    `SaslException`

### init

    public void init(java.util.Map attributes)
              throws SaslException

  Initialises the mechanism with designated attributes. Permissible names and values are mechanism specific.

  Parameters:
    `attributes` - a set of name-value pairs that describes the desired future behaviour of this instance.
  Throws:
    `IllegalMechanismStateException` - if the instance is already initialised.
    `SaslException` - if an exception occurs during the process.

### reset

    public void reset()
               throws SaslException

  Resets the mechanism instance for re-initialisation and use with other characteristics.

  Throws:
    `SaslException` - if an exception occurs during the process.

For the latest news and information visit The GNU Crypto project

Copyright © 2001, 2002, 2003, 2004 Free Software Foundation, Inc.