カスタムトークン

[アーティクル]
04/07/2023

このサンプルでは、Windows Communication Foundation (WCF) アプリケーションにカスタムトークン実装を追加する方法を示します。この例では、CreditCardToken を使用して、クライアントのクレジットカードに関する情報をサーバーに安全に渡します。このトークンは、WS-Security メッセージヘッダー内で渡され、対称セキュリティバインド要素を使用してメッセージ本文と他のメッセージヘッダーと共に署名および暗号化されます。これは、組み込みのトークンでは不十分な場合に役立ちます。このサンプルでは、組み込みのトークンのいずれかを使用する代わりに、カスタムセキュリティトークンをサービスに提供する方法を示します。サービスは、要求/応答通信パターンを定義するコントラクトを実装します。

Note

このサンプルのセットアップ手順とビルド手順については、このトピックの最後を参照してください。

このサンプルに示されている手順の概要は次のとおりです。

クライアントがカスタムセキュリティトークンをサービスに渡す方法。
サービスがカスタムセキュリティトークンを使用および検証する方法。
WCF サービスコードで、カスタムセキュリティトークンを含む、受信したセキュリティトークンに関する情報を取得する方法。
サーバーの X.509 証明書を使用して、メッセージの暗号化や署名に使用する対称キーを保護する方法。

カスタムセキュリティトークンを使用したクライアント認証

サービスは単一エンドポイントを公開します。エンドポイントは、BindingHelper クラスと EchoServiceHost クラスを使用してプログラムによって作成されます。エンドポイントは、アドレス、バインディング、およびコントラクトがそれぞれ 1 つずつで構成されます。バインディングは、SymmetricSecurityBindingElement と HttpTransportBindingElement を使用して、カスタムバインディングとして構成されます。このサンプルでは、SymmetricSecurityBindingElement を設定してサービスの X.509 証明書を使用し、送信中の対称キーを保護して、WS-Security メッセージヘッダー内でカスタム CreditCardToken を署名および暗号化されたセキュリティトークンとして渡します。この動作により、クライアント認証に使用されるサービス資格情報と、サービス X.509 証明書に関する情報が指定されます。

public static class BindingHelper
{
    public static Binding CreateCreditCardBinding()
    {
        var httpTransport = new HttpTransportBindingElement();

        // The message security binding element will be configured to require a credit card.
        // The token that is encrypted with the service's certificate.
        var messageSecurity = new SymmetricSecurityBindingElement();
        messageSecurity.EndpointSupportingTokenParameters.SignedEncrypted.Add(new CreditCardTokenParameters());
        X509SecurityTokenParameters x509ProtectionParameters = new X509SecurityTokenParameters();
        x509ProtectionParameters.InclusionMode = SecurityTokenInclusionMode.Never;
        messageSecurity.ProtectionTokenParameters = x509ProtectionParameters;
        return new CustomBinding(messageSecurity, httpTransport);
    }
}

メッセージ内のクレジットカードトークンを使用するため、このサンプルではカスタムサービス資格情報を使用してこの機能を実現します。サービス資格情報クラスは CreditCardServiceCredentials クラス内にあり、EchoServiceHost.InitializeRuntime メソッド内のサービスホストの動作コレクションに追加されます。

class EchoServiceHost : ServiceHost
{
    string creditCardFile;

    public EchoServiceHost(parameters Uri[] addresses)
        : base(typeof(EchoService), addresses)
    {
        creditCardFile = ConfigurationManager.AppSettings["creditCardFile"];
        if (string.IsNullOrEmpty(creditCardFile))
        {
            throw new ConfigurationErrorsException("creditCardFile not specified in service config");
        }

        creditCardFile = String.Format("{0}\\{1}", System.Web.Hosting.HostingEnvironment.ApplicationPhysicalPath, creditCardFile);
    }

    override protected void InitializeRuntime()
    {
        // Create a credit card service credentials and add it to the behaviors.
        CreditCardServiceCredentials serviceCredentials = new CreditCardServiceCredentials(this.creditCardFile);
        serviceCredentials.ServiceCertificate.SetCertificate("CN=localhost", StoreLocation.LocalMachine, StoreName.My);
        this.Description.Behaviors.Remove((typeof(ServiceCredentials)));
        this.Description.Behaviors.Add(serviceCredentials);

        // Register a credit card binding for the endpoint.
        Binding creditCardBinding = BindingHelper.CreateCreditCardBinding();
        this.AddServiceEndpoint(typeof(IEchoService), creditCardBinding, string.Empty);

        base.InitializeRuntime();
    }
}

クライアントエンドポイントは、サービスエンドポイントと同様の方法で構成されます。クライアントは、同じ BindingHelper クラスを使用してバインディングを作成します。セットアップの残りの部分は、Client クラスにあります。クライアントはさらに、CreditCardToken インスタンスを適切なデータと共にクライアントエンドポイントの動作コレクションに追加することによって、CreditCardClientCredentials に含まれる情報とサービス X.509 証明書に関する情報をセットアップコード内に設定します。サンプルでは、サービス証明書として、サブジェクト名が CN=localhost に設定された X.509 証明書を使用しています。

Binding creditCardBinding = BindingHelper.CreateCreditCardBinding();
var serviceAddress = new EndpointAddress("http://localhost/servicemodelsamples/service.svc");

// Create a client with given client endpoint configuration.
channelFactory = new ChannelFactory<IEchoService>(creditCardBinding, serviceAddress);

// Configure the credit card credentials on the channel factory.
var credentials =
      new CreditCardClientCredentials(
      new CreditCardInfo(creditCardNumber, issuer, expirationTime));
// Configure the service certificate on the credentials.
credentials.ServiceCertificate.SetDefaultCertificate(
      "CN=localhost", StoreLocation.LocalMachine, StoreName.My);

// Replace ClientCredentials with CreditCardClientCredentials.
channelFactory.Endpoint.Behaviors.Remove(typeof(ClientCredentials));
channelFactory.Endpoint.Behaviors.Add(credentials);

client = channelFactory.CreateChannel();

Console.WriteLine($"Echo service returned: {client.Echo()}");

((IChannel)client).Close();
channelFactory.Close();

カスタムセキュリティトークンの実装

WCF でカスタムセキュリティトークンを有効にするには、カスタムセキュリティトークンのオブジェクト表現を作成します。サンプルのこの表現は、CreditCardToken クラスにあります。このオブジェクト表現は、セキュリティトークンのすべての関連情報を保持し、セキュリティトークンに含まれるセキュリティキーのリストを提供します。この場合、クレジットカードセキュリティトークンにはセキュリティキーが含まれません。

次のセクションでは、カスタムトークンを有効にして通信回線を介して送信し、さらに WCF エンドポイントで使用するために必要な手順について説明します。

class CreditCardToken : SecurityToken
{
    CreditCardInfo cardInfo;
    DateTime effectiveTime = DateTime.UtcNow;
    string id;
    ReadOnlyCollection<SecurityKey> securityKeys;

    public CreditCardToken(CreditCardInfo cardInfo) : this(cardInfo, Guid.NewGuid().ToString()) { }

    public CreditCardToken(CreditCardInfo cardInfo, string id)
    {
        if (cardInfo == null)
            throw new ArgumentNullException(nameof(cardInfo));

        if (id == null)
            throw new ArgumentNullException(nameof(id));

        this.cardInfo = cardInfo;
        this.id = id;

        // The credit card token is not capable of any cryptography.
        this.securityKeys = new ReadOnlyCollection<SecurityKey>(new List<SecurityKey>());
    }

    public CreditCardInfo CardInfo { get { return this.cardInfo; } }

    public override ReadOnlyCollection<SecurityKey> SecurityKeys { get { return this.securityKeys; } }

    public override DateTime ValidFrom { get { return this.effectiveTime; } }
    public override DateTime ValidTo { get { return this.cardInfo.ExpirationDate; } }
    public override string Id { get { return this.id; } }
}

カスタムクレジットカードトークンのメッセージへの提供とメッセージからの取得

WCF のセキュリティトークンシリアライザーでは、メッセージの XML からセキュリティトークンのオブジェクト表現を作成し、XML 形式のセキュリティトークンを作成します。また、セキュリティトークンを指すキー識別子の読み取りと書き込みなど、他の機能も備えていますが、この例ではセキュリティトークン関連の機能だけを使用します。カスタムトークンを有効にするには、独自のセキュリティトークンシリアライザーを実装する必要があります。このサンプルでは、この目的のために CreditCardSecurityTokenSerializer クラスを使用します。

サービス側では、カスタムシリアライザーは XML 形式のカスタムトークンを読み取り、そこからカスタムトークンのオブジェクト表現を作成します。

クライアント側では、CreditCardSecurityTokenSerializer クラスが、セキュリティトークンのオブジェクト表現に含まれる情報を XML ライターに書き込みます。

public class CreditCardSecurityTokenSerializer : WSSecurityTokenSerializer
{
    public CreditCardSecurityTokenSerializer(SecurityTokenVersion version) : base() { }

    protected override bool CanReadTokenCore(XmlReader reader)
    {
        XmlDictionaryReader localReader = XmlDictionaryReader.CreateDictionaryReader(reader);

        if (reader == null)
            throw new ArgumentNullException(nameof(reader));

        if (reader.IsStartElement(Constants.CreditCardTokenName, Constants.CreditCardTokenNamespace))
            return true;

        return base.CanReadTokenCore(reader);
    }

    protected override SecurityToken ReadTokenCore(XmlReader reader, SecurityTokenResolver tokenResolver)
    {
        if (reader == null)
            throw new ArgumentNullException(nameof(reader));

        if (reader.IsStartElement(Constants.CreditCardTokenName, Constants.CreditCardTokenNamespace))
        {
            string id = reader.GetAttribute(Constants.Id, Constants.WsUtilityNamespace);

            reader.ReadStartElement();

            // Read the credit card number.
            string creditCardNumber = reader.ReadElementString(Constants.CreditCardNumberElementName, Constants.CreditCardTokenNamespace);

            // Read the expiration date.
            string expirationTimeString = reader.ReadElementString(Constants.CreditCardExpirationElementName, Constants.CreditCardTokenNamespace);
            DateTime expirationTime = XmlConvert.ToDateTime(expirationTimeString, XmlDateTimeSerializationMode.Utc);

            // Read the issuer of the credit card.
            string creditCardIssuer = reader.ReadElementString(Constants.CreditCardIssuerElementName, Constants.CreditCardTokenNamespace);
            reader.ReadEndElement();

            var cardInfo = new CreditCardInfo(creditCardNumber, creditCardIssuer, expirationTime);

            return new CreditCardToken(cardInfo, id);
        }
        else
        {
            return WSSecurityTokenSerializer.DefaultInstance.ReadToken(reader, tokenResolver);
        }
    }

    protected override bool CanWriteTokenCore(SecurityToken token)
    {
        if (token is CreditCardToken)
            return true;
        return base.CanWriteTokenCore(token);
    }

    protected override void WriteTokenCore(XmlWriter writer, SecurityToken token)
    {
        if (writer == null)
            throw new ArgumentNullException(nameof(writer));
        if (token == null)
            throw new ArgumentNullException(nameof(token));

        CreditCardToken c = token as CreditCardToken;
        if (c != null)
        {
            writer.WriteStartElement(Constants.CreditCardTokenPrefix, Constants.CreditCardTokenName, Constants.CreditCardTokenNamespace);
            writer.WriteAttributeString(Constants.WsUtilityPrefix, Constants.Id, Constants.WsUtilityNamespace, token.Id);
            writer.WriteElementString(Constants.CreditCardNumberElementName, Constants.CreditCardTokenNamespace, c.CardInfo.CardNumber);
            writer.WriteElementString(Constants.CreditCardExpirationElementName, Constants.CreditCardTokenNamespace, XmlConvert.ToString(c.CardInfo.ExpirationDate, XmlDateTimeSerializationMode.Utc));
            writer.WriteElementString(Constants.CreditCardIssuerElementName, Constants.CreditCardTokenNamespace, c.CardInfo.CardIssuer);
            writer.WriteEndElement();
            writer.Flush();
        }
        else
        {
            base.WriteTokenCore(writer, token);
        }
    }
}

トークンプロバイダークラスとトークン認証システムクラスの作成方法

クライアントとサービスの資格情報は、セキュリティトークンマネージャーのインスタンスを提供します。セキュリティトークンマネージャーのインスタンスを使用すると、トークンプロバイダー、トークン認証システム、およびトークンシリアライザーを取得できます。

トークンプロバイダーは、クライアントまたはサービスの資格情報に含まれる情報に基づいて、トークンのオブジェクト表現を作成します。次に、トークンのオブジェクト表現は、(前のセクションで説明したとおり) トークンシリアライザーを使用してメッセージに書き込まれます。

トークン認証システムは、到着したメッセージ内のトークンを検証します。受信トークンのオブジェクト表現は、トークンシリアライザーによって作成されます。このオブジェクト表現は、次に、検証のためトークン認証システムに渡されます。トークンが正常に検証されたら、トークン認証システムは IAuthorizationPolicy オブジェクトのコレクションを返します。このオブジェクトはトークンに含まれる情報を表します。この情報は、承認に関する決定を行ったり、アプリケーションに対するクレームを提供したりするために、後でメッセージ処理中に使用されます。この例では、クレジットカードトークンの認証システムはこの目的のために CreditCardTokenAuthorizationPolicy を使用します。

トークンシリアライザーは、トークンのオブジェクト表現を通信回線に送り、通信回線からトークンのオブジェクト表現を受け取ります。これについては、前のセクションで説明したとおりです。

このサンプルでは、トークンプロバイダーはクライアントでのみ使用し、トークン認証システムはサービスでのみ使用します。これは、クレジットカードトークンの送信はクライアントからサービスへの方向でのみ行うためです。

クライアント側の機能は CreditCardClientCredentials、CreditCardClientCredentialsSecurityTokenManager、および CreditCardTokenProvider クラスにあります。

サービス側の機能は CreditCardServiceCredentials、CreditCardServiceCredentialsSecurityTokenManager、CreditCardTokenAuthenticator、および CreditCardTokenAuthorizationPolicy クラスにあります。

    public class CreditCardClientCredentials : ClientCredentials
    {
        CreditCardInfo creditCardInfo;

        public CreditCardClientCredentials(CreditCardInfo creditCardInfo)
            : base()
        {
            if (creditCardInfo == null)
                throw new ArgumentNullException(nameof(creditCardInfo));

            this.creditCardInfo = creditCardInfo;
        }

        public CreditCardInfo CreditCardInfo
        {
            get { return this.creditCardInfo; }
        }

        protected override ClientCredentials CloneCore()
        {
            return new CreditCardClientCredentials(this.creditCardInfo);
        }

        public override SecurityTokenManager CreateSecurityTokenManager()
        {
            return new CreditCardClientCredentialsSecurityTokenManager(this);
        }
    }

    public class CreditCardClientCredentialsSecurityTokenManager : ClientCredentialsSecurityTokenManager
    {
        CreditCardClientCredentials creditCardClientCredentials;

        public CreditCardClientCredentialsSecurityTokenManager(CreditCardClientCredentials creditCardClientCredentials)
            : base (creditCardClientCredentials)
        {
            this.creditCardClientCredentials = creditCardClientCredentials;
        }

        public override SecurityTokenProvider CreateSecurityTokenProvider(SecurityTokenRequirement tokenRequirement)
        {
            // Handle this token for Custom.
            if (tokenRequirement.TokenType == Constants.CreditCardTokenType)
                return new CreditCardTokenProvider(this.creditCardClientCredentials.CreditCardInfo);
            // Return server cert.
            else if (tokenRequirement is InitiatorServiceModelSecurityTokenRequirement)
            {
                if (tokenRequirement.TokenType == SecurityTokenTypes.X509Certificate)
                {
                    return new X509SecurityTokenProvider(creditCardClientCredentials.ServiceCertificate.DefaultCertificate);
                }
            }

            return base.CreateSecurityTokenProvider(tokenRequirement);
        }

        public override SecurityTokenSerializer CreateSecurityTokenSerializer(SecurityTokenVersion version)
        {

            return new CreditCardSecurityTokenSerializer(version);
        }

    }

    class CreditCardTokenProvider : SecurityTokenProvider
    {
        CreditCardInfo creditCardInfo;

        public CreditCardTokenProvider(CreditCardInfo creditCardInfo) : base()
        {
            if (creditCardInfo == null)
                throw new ArgumentNullException(nameof(creditCardInfo));

            this.creditCardInfo = creditCardInfo;
        }

        protected override SecurityToken GetTokenCore(TimeSpan timeout)
        {
            SecurityToken result = new CreditCardToken(this.creditCardInfo);
            return result;
        }
    }

    public class CreditCardServiceCredentials : ServiceCredentials
    {
        string creditCardFile;

        public CreditCardServiceCredentials(string creditCardFile)
            : base()
        {
            if (creditCardFile == null)
                throw new ArgumentNullException(nameof(creditCardFile));

            this.creditCardFile = creditCardFile;
        }

        public string CreditCardDataFile
        {
            get { return this.creditCardFile; }
        }

        protected override ServiceCredentials CloneCore()
        {
            return new CreditCardServiceCredentials(this.creditCardFile);
        }

        public override SecurityTokenManager CreateSecurityTokenManager()
        {
            return new CreditCardServiceCredentialsSecurityTokenManager(this);
        }
    }

    public class CreditCardServiceCredentialsSecurityTokenManager : ServiceCredentialsSecurityTokenManager
    {
        CreditCardServiceCredentials creditCardServiceCredentials;

        public CreditCardServiceCredentialsSecurityTokenManager(CreditCardServiceCredentials creditCardServiceCredentials)
            : base(creditCardServiceCredentials)
        {
            this.creditCardServiceCredentials = creditCardServiceCredentials;
        }

        public override SecurityTokenAuthenticator CreateSecurityTokenAuthenticator(SecurityTokenRequirement tokenRequirement, out SecurityTokenResolver outOfBandTokenResolver)
        {
            if (tokenRequirement.TokenType == Constants.CreditCardTokenType)
            {
                outOfBandTokenResolver = null;
                return new CreditCardTokenAuthenticator(creditCardServiceCredentials.CreditCardDataFile);
            }

            return base.CreateSecurityTokenAuthenticator(tokenRequirement, out outOfBandTokenResolver);
        }

        public override SecurityTokenSerializer CreateSecurityTokenSerializer(SecurityTokenVersion version)
        {
            return new CreditCardSecurityTokenSerializer(version);
        }
    }

    class CreditCardTokenAuthenticator : SecurityTokenAuthenticator
    {
        string creditCardsFile;
        public CreditCardTokenAuthenticator(string creditCardsFile)
        {
            this.creditCardsFile = creditCardsFile;
        }

        protected override bool CanValidateTokenCore(SecurityToken token)
        {
            return (token is CreditCardToken);
        }

        protected override ReadOnlyCollection<IAuthorizationPolicy> ValidateTokenCore(SecurityToken token)
        {
            CreditCardToken creditCardToken = token as CreditCardToken;

            if (creditCardToken.CardInfo.ExpirationDate < DateTime.UtcNow)
                throw new SecurityTokenValidationException("The credit card has expired.");
            if (!IsCardNumberAndExpirationValid(creditCardToken.CardInfo))
                throw new SecurityTokenValidationException("Unknown or invalid credit card.");

            // the credit card token has only 1 claim - the card number. The issuer for the claim is the
            // credit card issuer

            var cardIssuerClaimSet = new DefaultClaimSet(new Claim(ClaimTypes.Name, creditCardToken.CardInfo.CardIssuer, Rights.PossessProperty));
            var cardClaimSet = new DefaultClaimSet(cardIssuerClaimSet, new Claim(Constants.CreditCardNumberClaim, creditCardToken.CardInfo.CardNumber, Rights.PossessProperty));
            var policies = new List<IAuthorizationPolicy>(1);
            policies.Add(new CreditCardTokenAuthorizationPolicy(cardClaimSet));
            return policies.AsReadOnly();
        }

        /// <summary>
        /// Helper method to check if a given credit card entry is present in the User DB
        /// </summary>
        private bool IsCardNumberAndExpirationValid(CreditCardInfo cardInfo)
        {
            try
            {
                using (var myStreamReader = new StreamReader(this.creditCardsFile))
                {
                    string line = "";
                    while ((line = myStreamReader.ReadLine()) != null)
                    {
                        string[] splitEntry = line.Split('#');
                        if (splitEntry[0] == cardInfo.CardNumber)
                        {
                            string expirationDateString = splitEntry[1].Trim();
                            DateTime expirationDateOnFile = DateTime.Parse(expirationDateString, System.Globalization.DateTimeFormatInfo.InvariantInfo, System.Globalization.DateTimeStyles.AdjustToUniversal);
                            if (cardInfo.ExpirationDate == expirationDateOnFile)
                            {
                                string issuer = splitEntry[2];
                                return issuer.Equals(cardInfo.CardIssuer, StringComparison.InvariantCultureIgnoreCase);
                            }
                            else
                            {
                                return false;
                            }
                        }
                    }
                    return false;
                }
            }
            catch (Exception e)
            {
                throw new Exception("BookStoreService: Error while retrieving credit card information from User DB " + e.ToString());
            }
        }
    }

    public class CreditCardTokenAuthorizationPolicy : IAuthorizationPolicy
    {
        string id;
        ClaimSet issuer;
        IEnumerable<ClaimSet> issuedClaimSets;

        public CreditCardTokenAuthorizationPolicy(ClaimSet issuedClaims)
        {
            if (issuedClaims == null)
                throw new ArgumentNullException(nameof(issuedClaims));
            this.issuer = issuedClaims.Issuer;
            this.issuedClaimSets = new ClaimSet[] { issuedClaims };
            this.id = Guid.NewGuid().ToString();
        }

        public ClaimSet Issuer { get { return this.issuer; } }

        public string Id { get { return this.id; } }

        public bool Evaluate(EvaluationContext context, ref object state)
        {
            foreach (ClaimSet issuance in this.issuedClaimSets)
            {
                context.AddClaimSet(this, issuance);
            }

            return true;
        }
    }

呼び出し元の情報の表示

呼び出し元の情報を表示するには、次のサンプルコードに示すように ServiceSecurityContext.Current.AuthorizationContext.ClaimSets を使用します。 ServiceSecurityContext.Current.AuthorizationContext.ClaimSets には、現在の呼び出し元に関連付けられている承認クレームが含まれています。クレームは、CreditCardToken コレクションの AuthorizationPolicies クラスによって提供されます。

bool TryGetStringClaimValue(ClaimSet claimSet, string claimType, out string claimValue)
{
    claimValue = null;
    IEnumerable<Claim> matchingClaims = claimSet.FindClaims(claimType, Rights.PossessProperty);
    if (matchingClaims == null)
        return false;
    IEnumerator<Claim> enumerator = matchingClaims.GetEnumerator();
    enumerator.MoveNext();
    claimValue = (enumerator.Current.Resource == null) ? null :
        enumerator.Current.Resource.ToString();
    return true;
}

string GetCallerCreditCardNumber()
{
     foreach (ClaimSet claimSet in
         ServiceSecurityContext.Current.AuthorizationContext.ClaimSets)
     {
         string creditCardNumber = null;
         if (TryGetStringClaimValue(claimSet,
             Constants.CreditCardNumberClaim, out creditCardNumber))
             {
                 string issuer;
                 if (!TryGetStringClaimValue(claimSet.Issuer,
                        ClaimTypes.Name, out issuer))
                 {
                     issuer = "Unknown";
                 }
                 return $"Credit card '{creditCardNumber}' issued by '{issuer}'";
        }
    }
    return "Credit card is not known";
}

このサンプルを実行すると、操作要求および応答がクライアントのコンソールウィンドウに表示されます。クライアントをシャットダウンするには、クライアントウィンドウで Enter キーを押します。

セットアップバッチファイル

このサンプルに用意されている Setup.bat バッチファイルを使用すると、適切な証明書を使用してサーバーを構成し、サーバー証明書ベースのセキュリティを必要とする、IIS でホストされるアプリケーションを実行できるようになります。このバッチファイルは、複数のコンピューターを使用する場合またはホストなしの場合に応じて変更する必要があります。

次に、バッチファイルのセクションのうち、該当する構成で実行するために変更が必要となる部分を示します。

サーバー証明書の作成 :

Setup.bat バッチファイルの次の行は、使用するサーバー証明書を作成します。 %SERVER_NAME% 変数はサーバー名です。この変数を変更して、使用するサーバー名を指定します。このバッチファイルでの既定は localhost です。 %SERVER_NAME% 変数を変更する場合は、Client.cs ファイルと Service.cs ファイル全体を参照して、localhost のすべてのインスタンスを Setup.bat スクリプトで使用するサーバー名に置き換える必要があります。

証明書は、LocalMachine ストアの場所の My (Personal) ストアに保存されます。証明書は、IIS でホストされるサービスの LocalMachine ストアに保存されます。自己ホスト型サービスの場合、バッチファイルで文字列 LocalMachine を CurrentUser に置き換えて、クライアント証明書を CurrentUser ストアの場所に保存します。
```
echo ************
echo Server cert setup starting
echo %SERVER_NAME%
echo ************
echo making server cert
echo ************
makecert.exe -sr LocalMachine -ss MY -a sha1 -n CN=%SERVER_NAME% -sky exchange -pe
```
サーバー証明書のクライアントの信頼された証明書ストアへのインストール。

Setup.bat バッチファイルの次の行は、サーバー証明書をクライアントの信頼されたユーザーのストアにコピーします。この手順が必要なのは、Makecert.exe によって生成される証明書がクライアントシステムにより暗黙には信頼されないからです。マイクロソフト発行の証明書など、クライアントの信頼されたルート証明書に基づいた証明書が既にある場合は、クライアント証明書ストアにサーバー証明書を配置するこの手順は不要です。
```
echo ************
echo copying server cert to client's TrustedPeople store
echo ************
certmgr.exe -add -r LocalMachine -s My -c -n %SERVER_NAME% -r CurrentUser -s TrustedPeople
```

IIS でホストされるサービスから証明書の秘密キーへのアクセスを有効にするには、IIS でホストされる処理が実行されているユーザーアカウントに、秘密キーへの適切なアクセス許可を付与する必要があります。これは、Setup.bat スクリプトの最後の手順によって実現されます。

echo ************
echo setting privileges on server certificates
echo ************
for /F "delims=" %%i in ('"%ProgramFiles%\ServiceModelSampleTools\FindPrivateKey.exe" My LocalMachine -n CN^=%SERVER_NAME% -a') do set PRIVATE_KEY_FILE=%%i
set WP_ACCOUNT=NT AUTHORITY\NETWORK SERVICE
(ver | findstr /C:"5.1") && set WP_ACCOUNT=%COMPUTERNAME%\ASPNET
echo Y|cacls.exe "%PRIVATE_KEY_FILE%" /E /G "%WP_ACCOUNT%":R
iisreset

Note

Setup.bat バッチファイルは、Visual Studio コマンドプロンプトから実行します。 Visual Studio コマンドプロンプト内で設定された PATH 環境変数は、Setup.bat スクリプトで必要な実行可能ファイルが格納されているディレクトリを指しています。

サンプルをセットアップしてビルドするには

Windows Communication Foundation サンプルの 1 回限りのセットアップの手順を実行したことを確認します。
ソリューションをビルドするには、「Windows Communication Foundation サンプルのビルド」の手順に従います。

サンプルを同じコンピューターで実行するには

管理特権を使用して Visual Studio コマンドプロンプトウィンドウを開き、サンプルのインストールフォルダーから Setup.bat を実行します。これにより、サンプルの実行に必要なすべての証明書がインストールされます。Makecert.exe が存在するフォルダーがパスに含まれていることを確認します。

Note

サンプルの使用が終わったら、Cleanup.bat を実行して証明書を削除してください。他のセキュリティサンプルでも同じ証明書を使用します。

Client.exe を client\bin ディレクトリで起動します。クライアントアクティビティがクライアントのコンソールアプリケーションに表示されます。
クライアントとサービスの間で通信できない場合は、WCF サンプルのトラブルシューティングのヒントに関するページをご覧ください。

サンプルを複数のコンピューターで実行するには

サービスコンピューターにサービスバイナリ用のディレクトリを作成します。
サービスプログラムファイルを、サービスコンピューターのサービスディレクトリにコピーします。必ず CreditCardFile.txt をコピーしてください。これを行わない場合、クレジットカードの認証システムはクライアントから送信されたクレジットカード情報を検証できません。 Setup.bat ファイルと Cleanup.bat ファイルもサービスコンピューターにコピーします。
コンピューターの完全修飾ドメイン名を含むサブジェクト名を持つサーバー証明書が必要です。 %SERVER_NAME% 変数を、サービスがホストされるコンピューターの完全修飾名に変更すると、Setup.bat を使用してこの証明書を作成できます。 Setup.bat ファイルは、管理者特権で開いた Visual Studio の開発者コマンドプロンプトで実行する必要があります。
サーバー証明書をクライアントの CurrentUser-TrustedPeople ストアにコピーします。このようにする必要があるのは、サーバー証明書が信頼できる発行元から発行されていない場合のみです。
EchoServiceHost.cs ファイルで、証明書のサブジェクト名の値を localhost から完全修飾コンピューター名に変更します。
クライアントプログラムファイルを、言語固有のフォルダーにある \client\bin\ フォルダーからクライアントコンピューターにコピーします。
Client.cs ファイルで、エンドポイントのアドレス値をサービスの新しいアドレスに合わせます。
Client.cs ファイルで、サービス X.509 証明書のサブジェクト名を localhost からリモートホストの完全修飾コンピューター名に変更します。
クライアントコンピューターで、コマンドプロンプトウィンドウから Client.exe を起動します。
クライアントとサービスの間で通信できない場合は、WCF サンプルのトラブルシューティングのヒントに関するページをご覧ください。

サンプルの実行後にクリーンアップするには

サンプルの実行が終わったら、サンプルフォルダーにある Cleanup.bat を実行します。

次の方法で共有

カスタムトークン

カスタムセキュリティトークンを使用したクライアント認証

カスタムセキュリティトークンの実装

カスタムクレジットカードトークンのメッセージへの提供とメッセージからの取得

トークンプロバイダークラスとトークン認証システムクラスの作成方法

呼び出し元の情報の表示

セットアップバッチファイル

サンプルをセットアップしてビルドするには

サンプルを同じコンピューターで実行するには

サンプルを複数のコンピューターで実行するには

サンプルの実行後にクリーンアップするには

その他のリソース

次の方法で共有

カスタム トークン

カスタム セキュリティ トークンを使用したクライアント認証

カスタム セキュリティ トークンの実装

カスタム クレジット カード トークンのメッセージへの提供とメッセージからの取得

トークン プロバイダー クラスとトークン認証システム クラスの作成方法

呼び出し元の情報の表示

セットアップ バッチ ファイル

サンプルをセットアップしてビルドするには

サンプルを同じコンピューターで実行するには

サンプルを複数のコンピューターで実行するには

サンプルの実行後にクリーンアップするには

その他のリソース

カスタムトークン

カスタムセキュリティトークンを使用したクライアント認証

カスタムセキュリティトークンの実装

カスタムクレジットカードトークンのメッセージへの提供とメッセージからの取得

トークンプロバイダークラスとトークン認証システムクラスの作成方法

セットアップバッチファイル