Package org.wildfly.security.mechanism._private

Interface ElytronMessages

  • All Superinterfaces:
    org.jboss.logging.BasicLogger
    @MessageLogger(projectCode="ELY",
               length=5)
@ValidIdRange(min=7,max=7) @ValidIdRange(min=1151,max=1151) @ValidIdRange(min=5001,max=5177) @ValidIdRange(min=6001,max=6022) @ValidIdRange(min=7001,max=7004)
public interface ElytronMessages
extends org.jboss.logging.BasicLogger
    Log messages and exceptions for Elytron.
    Author:
    David M. Lloyd, Darran Lofthouse

    • Method Detail

      • credentialDestroyingFailed

        @LogMessage(level=WARN)
@Message(id=7,
         value="Credential destroying failed")
void credentialDestroyingFailed​(@Cause
                                Throwable cause)

      • authenticationFailedEvidenceVerification

        @Message(id=1151,
         value="Evidence Verification Failed.")
SecurityException authenticationFailedEvidenceVerification()

      • mechMessageAfterComplete

        @Message(id=5001,
         value="Authentication mechanism exchange received a message after authentication was already complete")
AuthenticationMechanismException mechMessageAfterComplete()

      • mechUserNameContainsInvalidCharacter

        @Message(id=5002,
         value="Authentication mechanism user name contains an invalid or disallowed character")
AuthenticationMechanismException mechUserNameContainsInvalidCharacter()

      • mechAuthenticationNotComplete

        @Message(id=5005,
         value="Authentication mechanism authentication is not yet complete")
IllegalStateException mechAuthenticationNotComplete()

      • mechNoSecurityLayer

        @Message(id=5006,
         value="Authentication mechanism does not support security layer (wrapping/unwrapping)")
IllegalStateException mechNoSecurityLayer()

      • mechInvalidMessageReceived

        @Message(id=5007,
         value="Invalid authentication mechanism negotiation message received")
AuthenticationMechanismException mechInvalidMessageReceived()

      • mechServerSideAuthenticationFailed

        @Message(id=5012,
         value="Authentication mechanism server-side authentication failed")
AuthenticationMechanismException mechServerSideAuthenticationFailed​(@Cause
                                                                    Exception e)

      • mechAuthorizationFailed

        @Message(id=5014,
         value="Authentication mechanism authorization failed: \"%s\" running as \"%s\"")
AuthenticationMechanismException mechAuthorizationFailed​(String userName,
                                                         String authorizationId)

      • mechInitialChallengeMustBeEmpty

        @Message(id=5022,
         value="Initial challenge must be empty")
AuthenticationMechanismException mechInitialChallengeMustBeEmpty()

      • mechFailedToDetermineChannelBindingStatus

        @Message(id=5024,
         value="Failed to determine channel binding status")
AuthenticationMechanismException mechFailedToDetermineChannelBindingStatus​(@Cause
                                                                           Exception e)

      • mechMutualAuthenticationNotEnabled

        @Message(id=5025,
         value="Mutual authentication not enabled")
AuthenticationMechanismException mechMutualAuthenticationNotEnabled()

      • mechGssApiMechanismMismatch

        @Message(id=5032,
         value="GSS-API mechanism mismatch between SASL client and server")
AuthenticationMechanismException mechGssApiMechanismMismatch()

      • mechChannelBindingNotSupported

        @Message(id=5033,
         value="Channel binding not supported for this SASL mechanism")
AuthenticationMechanismException mechChannelBindingNotSupported()

      • mechChannelBindingTypeMismatch

        @Message(id=5034,
         value="Channel binding type mismatch between SASL client and server")
AuthenticationMechanismException mechChannelBindingTypeMismatch()

      • mechChannelBindingNotProvided

        @Message(id=5035,
         value="Channel binding not provided by client")
AuthenticationMechanismException mechChannelBindingNotProvided()

      • mechClientRefusesToInitiateAuthentication

        @Message(id=5037,
         value="Authentication mechanism client refuses to initiate authentication")
AuthenticationMechanismException mechClientRefusesToInitiateAuthentication()

      • mechIterationCountIsTooLow

        @Message(id=5040,
         value="Iteration count %d is below the minimum of %d")
AuthenticationMechanismException mechIterationCountIsTooLow​(int iterationCount,
                                                            int minimumIterationCount)

      • mechIterationCountIsTooHigh

        @Message(id=5041,
         value="Iteration count %d is above the maximum of %d")
AuthenticationMechanismException mechIterationCountIsTooHigh​(int iterationCount,
                                                             int maximumIterationCount)

      • mechUnmatchedMechanism

        @Message(id=5047,
         value="[%s] Authentication mechanism message is for mismatched mechanism \"%s\"")
AuthenticationMechanismException mechUnmatchedMechanism​(String mechName,
                                                        String otherMechName)

      • mechServerAuthenticityCannotBeVerified

        @Message(id=5049,
         value="Server authenticity cannot be verified")
AuthenticationMechanismException mechServerAuthenticityCannotBeVerified()

      • mechCallbackHandlerDoesNotSupportUserName

        @Message(id=5050,
         value="Callback handler does not support user name")
AuthenticationMechanismException mechCallbackHandlerDoesNotSupportUserName​(@Cause
                                                                           Throwable cause)

      • mechCallbackHandlerDoesNotSupportCredentialAcquisition

        @Message(id=5051,
         value="Callback handler does not support credential acquisition")
AuthenticationMechanismException mechCallbackHandlerDoesNotSupportCredentialAcquisition​(@Cause
                                                                                        Throwable cause)

      • mechCallbackHandlerFailedForUnknownReason

        @Message(id=5053,
         value="Callback handler failed for unknown reason")
AuthenticationMechanismException mechCallbackHandlerFailedForUnknownReason​(@Cause
                                                                           Throwable cause)

      • mechAuthenticationRejectedInvalidProof

        @Message(id=5055,
         value="Authentication rejected (invalid proof)")
AuthenticationMechanismException mechAuthenticationRejectedInvalidProof()

      • invalidNumericCharacter

        @Message(id=5061,
         value="Invalid numeric character")
NumberFormatException invalidNumericCharacter()

      • mechExpectingCommaOrLinearWhitespaceAfterQuoted

        @Message(id=5069,
         value="Expecting comma or linear whitespace after quoted string: %s")
AuthenticationMechanismException mechExpectingCommaOrLinearWhitespaceAfterQuoted​(String value)

      • mechMessageTypeMustEqual

        @Message(id=5070,
         value="MessageType must equal to %d, but it is %d")
AuthenticationMechanismException mechMessageTypeMustEqual​(int expected,
                                                          int actual)

      • mechBadSequenceNumberWhileUnwrapping

        @Message(id=5071,
         value="Bad sequence number while unwrapping: expected %d, but %d received")
AuthenticationMechanismException mechBadSequenceNumberWhileUnwrapping​(int expected,
                                                                      int actual)

      • mechProblemGettingRequiredCipher

        @Message(id=5076,
         value="Problem getting required cipher. Check your transformation mapper settings.")
AuthenticationMechanismException mechProblemGettingRequiredCipher​(@Cause
                                                                  Throwable cause)

      • mechNoCommonProtectionLayer

        @Message(id=5077,
         value="No common protection layer between client and server")
AuthenticationMechanismException mechNoCommonProtectionLayer()

      • mechNonceCountMustEqual

        @Message(id=5084,
         value="nonce-count must equal to %d, but it is %d")
AuthenticationMechanismException mechNonceCountMustEqual​(int expected,
                                                         int actual)

      • mechUnknownCharset

        @Message(id=5086,
         value="Charset can be only \"utf-8\" or unspecified (to use ISO 8859-1)")
AuthenticationMechanismException mechUnknownCharset()

      • wrappingNotConfigured

        @Message(id=5090,
         value="Wrapping is not configured")
IllegalStateException wrappingNotConfigured()

      • mechAuthenticationNameTooLong

        @Message(id=5091,
         value="Authentication name string is too long")
AuthenticationMechanismException mechAuthenticationNameTooLong()

      • mechAnonymousAuthorizationDenied

        @Message(id=5093,
         value="Authorization for anonymous access is denied")
AuthenticationMechanismException mechAnonymousAuthorizationDenied()

      • requiredNegativePadding

        @Message(id=5094,
         value="Required padded length (%d) is less than length of conversion result (%d)")
IllegalArgumentException requiredNegativePadding​(int totalLength,
                                                 int hexLength)

      • mechInvalidKeyForDigestHMAC

        @Message(id=5095,
         value="Invalid key provided for Digest HMAC computing")
AuthenticationMechanismException mechInvalidKeyForDigestHMAC()

      • unableToDetermineSubjectName

        @Message(id=5097,
         value="Unable to determine subject name from X.509 certificate")
IllegalStateException unableToDetermineSubjectName​(@Cause
                                                   Throwable cause)

      • mechCallbackHandlerNotProvidedServerCertificate

        @Message(id=5101,
         value="Callback handler not provided server certificate")
AuthenticationMechanismException mechCallbackHandlerNotProvidedServerCertificate()

      • mechCallbackHandlerNotProvidedClientCertificate

        @Message(id=5102,
         value="Callback handler not provided client certificate")
AuthenticationMechanismException mechCallbackHandlerNotProvidedClientCertificate()

      • mechCallbackHandlerNotProvidedPrivateKey

        @Message(id=5106,
         value="Callback handler not provided private key")
AuthenticationMechanismException mechCallbackHandlerNotProvidedPrivateKey()

      • mechGettingSupportedMechanismsFailed

        @Message(id=5112,
         value="Getting authentication mechanisms supported by GSS-API failed")
AuthenticationMechanismException mechGettingSupportedMechanismsFailed​(@Cause
                                                                      Throwable cause)

      • unableToInitialiseOid

        @Message(id=5113,
         value="Unable to initialize OID of Kerberos V5")
RuntimeException unableToInitialiseOid​(@Cause
                                       Throwable cause)

      • mechReceiveBufferIsGreaterThanMaximum

        @Message(id=5114,
         value="Receive buffer requested \'%d\' is greater than supported maximum \'%d\'")
AuthenticationMechanismException mechReceiveBufferIsGreaterThanMaximum​(int requested,
                                                                       int maximum)

      • mechUnableToUnwrapSecurityLayerNegotiationMessage

        @Message(id=5117,
         value="Unable to unwrap security layer negotiation message")
AuthenticationMechanismException mechUnableToUnwrapSecurityLayerNegotiationMessage​(@Cause
                                                                                   Throwable cause)

      • mechInvalidMessageOnUnwrapping

        @Message(id=5118,
         value="Invalid message of length %d on unwrapping")
AuthenticationMechanismException mechInvalidMessageOnUnwrapping​(int length)

      • mechNegotiatedMechanismWasNotKerberosV5

        @Message(id=5119,
         value="Negotiated mechanism was not Kerberos V5")
AuthenticationMechanismException mechNegotiatedMechanismWasNotKerberosV5()

      • mechInsufficientQopsAvailable

        @Message(id=5120,
         value="Insufficient levels of protection available for supported security layers")
AuthenticationMechanismException mechInsufficientQopsAvailable()

      • mechSelectedUnofferedQop

        @Message(id=5122,
         value="Client selected a security layer that was not offered by server")
AuthenticationMechanismException mechSelectedUnofferedQop()

      • mechNoSecurityLayerButLengthReceived

        @Message(id=5123,
         value="No security layer selected but message length received")
AuthenticationMechanismException mechNoSecurityLayerButLengthReceived()

      • mechUnableToGetMaximumSizeOfMessage

        @Message(id=5124,
         value="Unable to get maximum size of message before wrap")
AuthenticationMechanismException mechUnableToGetMaximumSizeOfMessage​(@Cause
                                                                     Throwable cause)

      • mechBadLengthOfMessageForNegotiatingSecurityLayer

        @Message(id=5126,
         value="Bad length of message for negotiating security layer")
AuthenticationMechanismException mechBadLengthOfMessageForNegotiatingSecurityLayer()

      • mechReceivedMaxMessageSizeWhenNoSecurityLayer

        @Message(id=5127,
         value="No security layer supported by server but maximum message size received: \"%d\"")
AuthenticationMechanismException mechReceivedMaxMessageSizeWhenNoSecurityLayer​(int length)

      • mechAuthorizationIdTooLong

        @Message(id=5150,
         value="Authentication mechanism authorization ID is too long")
AuthenticationMechanismException mechAuthorizationIdTooLong()

      • mechInvalidOTPSeed

        @Message(id=5155,
         value="Invalid OTP seed, must be between 1 and 16 characters long")
AuthenticationMechanismException mechInvalidOTPSeed()

      • mechInvalidOTPPassPhrase

        @Message(id=5156,
         value="Invalid OTP pass phrase, must be between 10 and 63 characters long")
AuthenticationMechanismException mechInvalidOTPPassPhrase()

      • mechOTPPassPhraseAndSeedMustNotMatch

        @Message(id=5159,
         value="OTP pass phrase and seed must not match")
AuthenticationMechanismException mechOTPPassPhraseAndSeedMustNotMatch()

      • mechInvalidOTPAlternateDictionary

        @Message(id=5160,
         value="Invalid OTP alternate dictionary")
AuthenticationMechanismException mechInvalidOTPAlternateDictionary()

      • mechUnableToObtainExclusiveAccess

        @Message(id=5164,
         value="Unable to obtain exclusive access for \"%s\"")
AuthenticationMechanismException mechUnableToObtainExclusiveAccess​(String userName)

      • mechInvalidOTPPasswordFormatType

        @Message(id=5167,
         value="Invalid OTP password format type")
AuthenticationMechanismException mechInvalidOTPPasswordFormatType()

      • mechResponseTokenMismatch

        @Message(id=5169,
         value="[%s] Clients response token does not match expected token")
String mechResponseTokenMismatch​(String mechName)

      • mechProblemDuringCryptResultIsNull

        @Message(id=5170,
         value="Problem during crypt: The encrypted result is null. The input data has a length of zero or too short to result in a new block.")
AuthenticationMechanismException mechProblemDuringCryptResultIsNull()

      • mechProblemDuringDecryptResultIsNull

        @Message(id=5171,
         value="Problem during decrypt: The decrypted result is null. The input data has a length of zero or too short to result in a new block.")
AuthenticationMechanismException mechProblemDuringDecryptResultIsNull()

      • unableToObtainServerCredential

        @Message(id=5173,
         value="Unable to obtain server credential.")
AuthenticationMechanismException unableToObtainServerCredential()

      • mechOneOfDirectivesHasToBeDefined

        @Message(id=5177,
         value="One of \"%s\" and \"%s\" directives has to be defined")
AuthenticationMechanismException mechOneOfDirectivesHasToBeDefined​(String directive1,
                                                                   String directive2)

      • incorrectlyFormattedHeader

        @Message(id=6001,
         value="An incorrectly formatted \'%s\'header was encountered.")
String incorrectlyFormattedHeader​(String headerName)

      • authenticationFailed

        @Message(id=6002,
         value="An authentication attempt for user \'%s\' failed validation using mechanism \'%s\'.")
String authenticationFailed​(String username,
                            String mechanismName)

      • authenticationFailed

        @Message(id=6003,
         value="An authentication attempt failed validation.")
String authenticationFailed()

      • authorizationFailed

        @Message(id=6006,
         value="An authorization check for user \'%s\' failed.")
String authorizationFailed​(String username)

      • usernameOrPasswordMissing

        @Message(id=6007,
         value="Username or password missing from authentication attempt.")
String usernameOrPasswordMissing()

      • digestMechanismRequireRealm

        @Message(id=6015,
         value="Unable to authenticate using DIGEST mechanism - realm name needs to be specified")
HttpAuthenticationException digestMechanismRequireRealm()

      • digestMechanismInvalidRealm

        @Message(id=6019,
         value="Unable to authenticate using DIGEST mechanism - mechanism realm name (%s) is not valid")
HttpAuthenticationException digestMechanismInvalidRealm​(String realm)

      • unsuitableScope

        @Message(id=6020,
         value="Scope unsuitable for use with authentication state \'%s\'")
IllegalArgumentException unsuitableScope​(String scopeName)

      • unableToIdentifyHttpScope

        @Message(id=6021,
         value="Unable to identify suitable HttpScope for mechanism state storage")
IllegalArgumentException unableToIdentifyHttpScope()

      • invalidNonceCount

        @Message(id=6022,
         value="Invalid nonce count %s")
HttpAuthenticationException invalidNonceCount​(int nonceCount)

      • asnUnrecognisedAlgorithm

        @Message(id=7001,
         value="Unrecognized encoding algorithm [%s]")
ASN1Exception asnUnrecognisedAlgorithm​(String algorithm)

      • asnInvalidGeneralNameType

        @Message(id=7002,
         value="Invalid general name type")
ASN1Exception asnInvalidGeneralNameType()

      • asnUnexpectedTag

        @Message(id=7004,
         value="Unexpected ASN.1 tag encountered")
ASN1Exception asnUnexpectedTag()