IAuthenticationModule インターフェイスとは? わかりやすく解説

Weblio 辞書 > コンピュータ > .NET Framework クラス ライブラリ リファレンス > IAuthenticationModule インターフェイスの意味・解説 

IAuthenticationModule インターフェイス

Web クライアント認証モジュール基本認証インターフェイス提供します

名前空間: System.Net
アセンブリ: System (system.dll 内)
構文構文

Public Interface IAuthenticationModule
Dim instance As IAuthenticationModule
public interface IAuthenticationModule
public interface class IAuthenticationModule
public interface IAuthenticationModule
public interface IAuthenticationModule
解説解説
使用例使用例

IAuthenticationModule インターフェイス実装することによって、カスタマイズされた認証クラス作成する例を次に示します詳細については、AuthenticationManager クラストピック参照してください

' The CustomBasic class creates a custom Basic authentication by implementing
 the
' IAuthenticationModule interface. It performs the following
' tasks:
' 1) Defines and initializes the required properties.
' 2) Implements the Authenticate and PreAuthenticate methods.

Public Class CustomBasic
  Implements IAuthenticationModule

  Private m_authenticationType As String
  Private m_canPreAuthenticate As Boolean


  ' The CustomBasic constructor initializes the properties of the customized
 
  ' authentication.
  Public Sub New()
    m_authenticationType = "Basic"
    m_canPreAuthenticate = False
  End Sub 'New

  ' Define the authentication type. This type is then used to identify
 this
  ' custom authentication module. The default is set to Basic.

  Public ReadOnly Property
 AuthenticationType() As String _
   Implements IAuthenticationModule.AuthenticationType

    Get
      Return m_authenticationType
    End Get
  End Property

  ' Define the pre-authentication capabilities for the module. The default
 is set
  ' to false.

  Public ReadOnly Property
 CanPreAuthenticate() As Boolean _
   Implements IAuthenticationModule.CanPreAuthenticate


    Get
      Return m_canPreAuthenticate
    End Get
  End Property

' The checkChallenge method checks whether the challenge sent by the
 HttpWebRequest 
' contains the correct type (Basic) and the correct domain name. 
' Note: The challenge is in the form BASIC REALM="DOMAINNAME";
 
' the Internet Web site must reside on a server whose
' domain name is equal to DOMAINNAME.
  Public Function checkChallenge(ByVal
 Challenge As String, ByVal
 domain As String) As Boolean
    Dim challengePasses As Boolean
 = False

    Dim tempChallenge As [String] = Challenge.ToUpper()

    ' Verify that this is a Basic authorization request and that the
 requested domain
    ' is correct.
    ' Note: When the domain is an empty string, the following code only
 checks 
    ' whether the authorization type is Basic.
    If tempChallenge.IndexOf("BASIC")
 <> -1 Then
      If domain <> [String].Empty Then
        If tempChallenge.IndexOf(domain.ToUpper()) <> -1
 Then
          challengePasses = True
          ' The domain is not allowed and the authorization type is
 Basic.
        Else
          challengePasses = False
        End If
        ' The domain is a blank string and the authorization type is
 Basic.
      Else
        challengePasses = True
      End If
    End If
    Return challengePasses
  End Function 'checkChallenge


  ' The PreAuthenticate method specifies whether the authentication
 implemented 
  ' by this class allows pre-authentication. 
  ' Even if you do not use it, this method must be implemented to obey
 to the rules 
  ' of interface implementation.
  ' In this case it always returns null. 
  Public Function PreAuthenticate(ByVal
 request As WebRequest, ByVal credentials
 As ICredentials) As Authorization _
      Implements IAuthenticationModule.PreAuthenticate

    Return Nothing
  End Function 'PreAuthenticate

  
  ' Authenticate is the core method for this custom authentication.
  ' When an Internet resource requests authentication, the WebRequest.GetResponse
 
  ' method calls the AuthenticationManager.Authenticate method. This
 method, in 
  ' turn, calls the Authenticate method on each of the registered authentication
  ' modules, in the order in which they were registered. When the authentication
 is 
  ' complete an Authorization object is returned to the WebRequest.
  Public Function Authenticate(ByVal
 challenge As String, ByVal
 request As WebRequest, ByVal credentials As ICredentials) As Authorization _
      Implements IAuthenticationModule.Authenticate


    Dim ASCII As Encoding = Encoding.ASCII

    ' Get the username and password from the credentials
    Dim MyCreds As NetworkCredential = credentials.GetCredential(request.RequestUri,
 "Basic")

    If PreAuthenticate(request, credentials) Is
 Nothing Then
      Console.WriteLine(ControlChars.Lf + " Pre-authentication
 is not allowed.")
    Else
      Console.WriteLine(ControlChars.Lf + " Pre-authentication
 is allowed.")
    End If
    ' Verify that the challenge satisfies the authorization requirements.
    Dim challengeOk As Boolean
 = checkChallenge(challenge, MyCreds.Domain)

    If Not challengeOk Then
      Return Nothing
    End If

    ' Create the encrypted string according to the Basic authentication
 format as
    ' follows:
    ' a)Concatenate the username and password separated by colon;
    ' b)Apply ASCII encoding to obtain a stream of bytes;
    ' c)Apply Base64 encoding to this array of bytes to obtain the encoded
 
    ' authorization.
    Dim BasicEncrypt As String
 = MyCreds.UserName + ":" + MyCreds.Password

    Dim BasicToken As String
 = "Basic " + Convert.ToBase64String(ASCII.GetBytes(BasicEncrypt))

    ' Create an Authorization object using the encoded authorization
 above.
    Dim resourceAuthorization As New
 Authorization(BasicToken)

    ' Get the Message property, which contains the authorization string
 that the 
    ' client returns to the server when accessing protected resources.
    Console.WriteLine(ControlChars.Lf + " Authorization Message:{0}",
 resourceAuthorization.Message)

    ' Get the Complete property, which is set to true when the authentication
 process 
    ' between the client and the server is finished.
    Console.WriteLine(ControlChars.Lf + " Authorization Complete:{0}",
 resourceAuthorization.Complete)

    Console.WriteLine(ControlChars.Lf + " Authorization ConnectionGroupId:{0}",
 resourceAuthorization.ConnectionGroupId)


    Return resourceAuthorization
  End Function 'Authenticate
End Class 'CustomBasic 
// The CustomBasic class creates a custom Basic authentication by implementing
 the
// IAuthenticationModule interface. It performs the following
// tasks:
// 1) Defines and initializes the required properties.
// 2) Implements the Authenticate method.

public class CustomBasic : IAuthenticationModule
{

  private string m_authenticationType ;
  private bool m_canPreAuthenticate ;

  // The CustomBasic constructor initializes the properties of the customized
 
  // authentication.
  public CustomBasic()
  {
    m_authenticationType = "Basic";
    m_canPreAuthenticate = false;
  }

  // Define the authentication type. This type is then used to identify
 this
  // custom authentication module. The default is set to Basic.
  public string AuthenticationType
  {
    get
    {
      return m_authenticationType;
    }
  }

  // Define the pre-authentication capabilities for the module. The
 default is set
  // to false.
  public bool CanPreAuthenticate
  {
    get
    {
      return m_canPreAuthenticate;
    }
  }

  // The checkChallenge method checks whether the challenge sent by
 the HttpWebRequest 
  // contains the correct type (Basic) and the correct domain name.
 
  // Note: The challenge is in the form BASIC REALM="DOMAINNAME";
 
  // the Internet Web site must reside on a server whose
  // domain name is equal to DOMAINNAME.
  public bool checkChallenge(string
 Challenge, string domain) 
  {
    bool challengePasses = false;

    String tempChallenge = Challenge.ToUpper();

    // Verify that this is a Basic authorization request and that the
 requested domain
    // is correct.
    // Note: When the domain is an empty string, the following code
 only checks 
    // whether the authorization type is Basic.

    if (tempChallenge.IndexOf("BASIC") != -1)
      if (domain != String.Empty)
        if (tempChallenge.IndexOf(domain.ToUpper()) != -1)
          challengePasses = true;
        else
          // The domain is not allowed and the authorization type is
 Basic.
          challengePasses = false;
      else
        // The domain is a blank string and the authorization type is
 Basic.
        challengePasses = true;

    return challengePasses;
  }

  // The PreAuthenticate method specifies whether the authentication
 implemented 
  // by this class allows pre-authentication. 
  // Even if you do not use it, this method must be implemented to obey
 to the rules 
  // of interface implementation.
  // In this case it always returns null. 
  public Authorization PreAuthenticate(WebRequest request, ICredentials
 credentials) 
  {                
    return null;
  }

  // Authenticate is the core method for this custom authentication.
  // When an Internet resource requests authentication, the WebRequest.GetResponse
 
  // method calls the AuthenticationManager.Authenticate method. This
 method, in 
  // turn, calls the Authenticate method on each of the registered authentication
  // modules, in the order in which they were registered. When the authentication
 is 
  // complete an Authorization object is returned to the WebRequest.
  public Authorization Authenticate(String challenge, WebRequest
 request, ICredentials credentials) 
  {
    Encoding ASCII = Encoding.ASCII;        

    // Get the username and password from the credentials
    NetworkCredential MyCreds = credentials.GetCredential(request.RequestUri, "Basic");
        

    if (PreAuthenticate(request, credentials) == null)
      Console.WriteLine("\n Pre-authentication is not allowed.");
    else
      Console.WriteLine("\n Pre-authentication is allowed.");

    // Verify that the challenge satisfies the authorization requirements.
    bool challengeOk = checkChallenge(challenge, MyCreds.Domain);

    if (!challengeOk)
      return null;

    // Create the encrypted string according to the Basic authentication
 format as
    // follows:
    // a)Concatenate the username and password separated by colon;
    // b)Apply ASCII encoding to obtain a stream of bytes;
    // c)Apply Base64 encoding to this array of bytes to obtain the
 encoded 
    // authorization.
    string BasicEncrypt = MyCreds.UserName + ":" + MyCreds.Password;

    string BasicToken = "Basic " + Convert.ToBase64String(ASCII.GetBytes(BasicEncrypt));

    // Create an Authorization object using the encoded authorization
 above.
    Authorization resourceAuthorization = new Authorization(BasicToken);

    // Get the Message property, which contains the authorization string
 that the 
    // client returns to the server when accessing protected resources.
    Console.WriteLine("\n Authorization Message:{0}",resourceAuthorization.Message);

    // Get the Complete property, which is set to true when the authentication
 process 
    // between the client and the server is finished.
    Console.WriteLine("\n Authorization Complete:{0}",resourceAuthorization.Complete);

    Console.WriteLine("\n Authorization ConnectionGroupId:{0}",resourceAuthorization.ConnectionGroupId);


    return resourceAuthorization;
  }
}
// The CustomBasic class creates a custom Basic authentication by implementing
 the
// IAuthenticationModule interface. In particular it performs the following
// tasks:
// 1) Defines and initializes the required properties.
// 2) Impements the Authenticate method.
public ref class CustomBasic: public
 IAuthenticationModule
{
private:

   String^ m_authenticationType;
   bool m_canPreAuthenticate;

public:

   // The CustomBasic constructor initializes the properties of the
 customized
   // authentication.
   CustomBasic()
   {
      m_authenticationType = "Basic";
      m_canPreAuthenticate = false;
   }


   property String^ AuthenticationType 
   {

      // Define the authentication type. This type is then used to identify
 this
      // custom authentication module. The default is set to Basic.
      virtual String^ get()
      {
         return m_authenticationType;
      }

   }

   property bool CanPreAuthenticate 
   {

      // Define the pre-authentication capabilities for the module. The
 default is set
      // to false.
      virtual bool get()
      {
         return m_canPreAuthenticate;
      }

   }

   // The checkChallenge method checks if the challenge sent by the
 HttpWebRequest
   // contains the correct type (Basic) and the correct domain name.
   // Note: the challenge is in the form BASIC REALM=S"DOMAINNAME"
   // and you must assure that the Internet Web site resides on a server
 whose
   // domain name is equal to DOMAINAME.
   bool checkChallenge( String^ Challenge, String^ domain )
   {
      bool challengePasses = false;
      String^ tempChallenge = Challenge->ToUpper();
      
      // Verify that this is a Basic authorization request and the requested
 domain
      // is correct.
      // Note: When the domain is an empty string the following code
 only checks
      // whether the authorization type is Basic.
      if ( tempChallenge->IndexOf( "BASIC" ) != -1
 )
            if ( String::Compare( domain, String::Empty ) != 0
 )
            if ( tempChallenge->IndexOf( domain->ToUpper()
 ) != -1 )
            challengePasses = true; // The domain
 is not allowed and the authorization type is Basic.
      else
            challengePasses = false;

      else
            challengePasses = true;


      return challengePasses;
   }


   // The PreAuthenticate method specifies if the authentication implemented
   // by this class allows pre-authentication.
   // Even if you do not use it, this method must be implemented to
 obey to the rules
   // of interface implemebtation.
   // In this case it always returns null.
   virtual Authorization^ PreAuthenticate( WebRequest^ request, ICredentials^ credentials
 )
   {
      return nullptr;
   }


   // Authenticate is the core method for this custom authentication.
   // When an internet resource requests authentication, the WebRequest::GetResponse
   // method calls the AuthenticationManager::Authenticate method. This
 method, in
   // turn, calls the Authenticate method on each of the registered
 authentication
   // modules, in the order they were registered. When the authentication
 is
   // complete an Authorization object is returned to the WebRequest,
 as
   // shown by this routine's retun type.
   virtual Authorization^ Authenticate( String^ challenge, WebRequest^ request, ICredentials^
 credentials )
   {
      Encoding^ ASCII = Encoding::ASCII;
      
      // Get the username and password from the credentials
      NetworkCredential^ MyCreds = credentials->GetCredential( request->RequestUri,
 "Basic" );
      if ( PreAuthenticate( request, credentials ) == nullptr
 )
            Console::WriteLine( "\n Pre-authentication is not allowed."
 );
      else
            Console::WriteLine( "\n Pre-authentication is allowed." );

      
      // Verify that the challenge satisfies the authorization requirements.
      bool challengeOk = checkChallenge( challenge, MyCreds->Domain
 );
      if (  !challengeOk )
            return nullptr;

      
      // Create the encrypted string according to the Basic authentication
 format as
      // follows:
      // a)Concatenate username and password separated by colon;
      // b)Apply ASCII encoding to obtain a stream of bytes;
      // c)Apply Base64 Encoding to this array of bytes to obtain the
 encoded
      // authorization.
      String^ BasicEncrypt = String::Concat( MyCreds->UserName, ":",
 MyCreds->Password );
      String^ BasicToken = String::Concat( "Basic ", Convert::ToBase64String(
 ASCII->GetBytes( BasicEncrypt ) ) );
      
      // Create an Authorization object using the above encoded authorization.
      Authorization^ resourceAuthorization = gcnew Authorization( BasicToken );
      
      // Get the Message property which contains the authorization string
 that the
      // client returns to the server when accessing protected resources
      Console::WriteLine( "\n Authorization Message: {0}", resourceAuthorization->Message
 );
      
      // Get the Complete property which is set to true when the authentication
 process
      // between the client and the server is finished.
      Console::WriteLine( "\n Authorization Complete: {0}", resourceAuthorization->Complete
 );
      
      Console::WriteLine( "\n Authorization ConnectionGroupId: {0}", resourceAuthorization->ConnectionGroupId
 );
      return resourceAuthorization;
   }

};


// This is the program entry point. It allows the user to enter
// her credentials and the Internet resource (Web page) to access.
// It also unregisters the standard and registers the customized basic
// authentication.
int main()
{
   array<String^>^args = Environment::GetCommandLineArgs();
   if ( args->Length < 4 )
      TestAuthentication::showusage();
   else
   {
      
      // Read the user's credentials.
      TestAuthentication::uri = args[ 1 ];
      TestAuthentication::username = args[ 2 ];
      TestAuthentication::password = args[ 3 ];
      if ( args->Length == 4 )
            TestAuthentication::domain = String::Empty; // If the domain
 exists, store it. Usually the domain name
      else
            TestAuthentication::domain = args[ 4 ];
      
      // is by default the name of the server hosting the Internet
      // resource.
      // Instantiate the custom Basic authentication module.
      CustomBasic^ customBasicModule = gcnew CustomBasic;
      
      // Unregister the standard Basic authentication module.
      AuthenticationManager::Unregister( "Basic" );
      
      // Register the custom Basic authentication module.
      AuthenticationManager::Register( customBasicModule );
      
      // Display registered Authorization modules.
      TestAuthentication::displayRegisteredModules();
      
      // Read the specified page and display it on the console.
      TestAuthentication::getPage( TestAuthentication::uri );
   }
}

// The CustomBasic class creates a custom Basic authentication by implementing
// the IAuthenticationModule interface. It performs the following tasks:
// 1) Defines and initializes the required properties.
// 2) Implements the Authenticate method.
public class CustomBasic implements IAuthenticationModule
{
    private String m_authenticationType;
    private boolean m_canPreAuthenticate;

    // The CustomBasic constructor initializes the properties of the customized
 
    // authentication.
    public CustomBasic()
    {
        m_authenticationType = "Basic";
        m_canPreAuthenticate = false;
    } //CustomBasic

    // Define the authentication type. This type is then used to identify
 this
    // custom authentication module. The default is set to Basic.
    /** @property
     */
    public String get_AuthenticationType()
    {
        return m_authenticationType;
    } //get_AuthenticationType

    // Define the pre-authentication capabilities for the module. 
    // The default is set to false.
    /** @property
     */
    public boolean get_CanPreAuthenticate()
    {
        return m_canPreAuthenticate;
    } //get_CanPreAuthenticate

    // The CheckChallenge method checks whether the challenge sent by
 the 
    // HttpWebRequest contains the correct type (Basic) and the correct
 
    // domain name. Note: The challenge is in the form BASIC  
    // REALM="DOMAINNAME"; the Internet Web site must reside
 on a server whose
    // domain name is equal to DOMAINNAME.
    public boolean CheckChallenge(String challenge, String domain)
    {
        boolean challengePasses = false;
        String tempChallenge = challenge.ToUpper();

        // Verify that this is a Basic authorization request and that
 the 
        // requested domain is correct. Note: When the domain is an
 empty 
        // string, the following code only checks  whether the authorization
 
        // type is Basic.
        if (tempChallenge.IndexOf("BASIC") != -1) {
            if (domain.Equals("") == false)
 {
                if (tempChallenge.IndexOf(domain.ToUpper()) !=
 -1) {
                    challengePasses = true;
                }
                else {
                    // The domain is not allowed and the authorization
 
                    // type is Basic.
                    challengePasses = false;
                }
            }                
            else {
                // The domain is a blank string and the authorization
 type is
                // Basic.
                challengePasses = true;
            }
        }
        return challengePasses;
    } //CheckChallenge

    // The PreAuthenticate method specifies whether the authentication
 
    // implemented  by this class allows pre-authentication. 
    // Even if you do not use it, this method must be implemented to
 
    // obey to the rules of interface implementation.
    // In this case it always returns null. 
    public Authorization PreAuthenticate(WebRequest request, 
        ICredentials credentials)
    {
        return null;
    } //PreAuthenticate

    // Authenticate is the core method for this custom authentication.
    // When an Internet resource requests authentication, the WebRequest.
    // GetResponse  method calls the AuthenticationManager.Authenticate
 method. 
    // This method, in  turn, calls the Authenticate method on each
 of the 
    // registered authentication modules, in the order in which they
 were 
    // registered. When the authentication is  complete an Authorization
 object 
    // is returned to the WebRequest.
    public Authorization Authenticate(
        String challenge, WebRequest request, ICredentials credentials)
    {
        Encoding ascii = Encoding.get_ASCII();

        // Get the username and password from the credentials
        NetworkCredential myCreds = credentials.GetCredential(
                                    request.get_RequestUri(), "Basic");
        if (PreAuthenticate(request, credentials) == null)
 {
            Console.WriteLine("\n Pre-authentication is not allowed.");
        }
        else {
            Console.WriteLine("\n Pre-authentication is allowed.");
        }

        // Verify that the challenge satisfies the authorization requirements.
        boolean challengeOk = CheckChallenge(challenge, myCreds.get_Domain());

        if (!(challengeOk)) {
            return null;
        }
        // Create the encrypted string according to the Basic authentication
 
        // format as follows:
        // a)Concatenate the username and password separated by colon;
        // b)Apply ascii encoding to obtain a stream of bytes;
        // c)Apply Base64 encoding to this array of bytes to obtain the
 encoded 
        // authorization.
        String basicEncrypt = myCreds.get_UserName() + ":" 
            + myCreds.get_Password();
        String basicToken = "Basic " 
            + Convert.ToBase64String(ascii.GetBytes(basicEncrypt));

        // Create an Authorization object using the encoded
        // authorization above.
        Authorization resourceAuthorization = new Authorization(basicToken);

        // Get the Message property, which contains the authorization
 string 
        // that the client returns to the server when accessing protected
 
        // resources.
        Console.WriteLine("\n Authorization Message:{0}", 
            resourceAuthorization.get_Message());

        // Get the Complete property, which is set to true when the
 
        // authentication process between the client and the
        // server is finished.
        Console.WriteLine("\n Authorization Complete:{0}", 
            System.Convert.ToString(resourceAuthorization.get_Complete()));

        Console.WriteLine("\n Authorization ConnectionGroupId:{0}", 
            resourceAuthorization.get_ConnectionGroupId());
        return resourceAuthorization;
    } //Authenticate
} //CustomBasic
プラットフォームプラットフォーム
バージョン情報バージョン情報
参照参照
関連項目
IAuthenticationModule メンバ
System.Net 名前空間
AuthenticationManager クラス



英和和英テキスト翻訳>> Weblio翻訳
英語⇒日本語日本語⇒英語
  

辞書ショートカット

すべての辞書の索引

「IAuthenticationModule インターフェイス」の関連用語

IAuthenticationModule インターフェイスのお隣キーワード
検索ランキング

   

英語⇒日本語
日本語⇒英語
   



IAuthenticationModule インターフェイスのページの著作権
Weblio 辞書 情報提供元は 参加元一覧 にて確認できます。

   
日本マイクロソフト株式会社日本マイクロソフト株式会社
© 2025 Microsoft.All rights reserved.

©2025 GRAS Group, Inc.RSS