• вместо STS который работает на базе HTTP Redirect вы используете STS, работающий поверх SOAP и аутентифицирующий пользователй по логину и паролю.
  
• вы настраиваете 2 биндинга: №1 — ws2007FederationHttpBinding для соединения с вашими сервисами и №2 — ws2007HttpBinding для соединения с STS. Биндинг №2 указываете в качестве параметра у №1.
  
• на сайте вы запоминаете логин и пароль и при создании WCF-клиента в качестве credentials передаете эти два параметра.
  
• дальше все за вас делает WCF: стучится с вашим логином и пролем на STS (биндинг №2), аутентифицируется там и получает токен (в этом токене помимо прочего будут лежать ключи для защиты соединения), затем с полученным тоеном идет (биндинг №1) на непосредственный сервис.

• Какой .Net используете
  
• Что используете в качестве STS (AD, свое решение — тогда на чем, сторонний продукт)
  
• Используете ли WIF

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <bindings>
      <ws2007FederationHttpBinding>
        <binding name="Service">
          <!--    Здесь мы не указываем параметров для Issuer, т.к. обращаться будем сами явно 
                однако, если оставить просто такие настройки, WCF начнет показывать окно выбора токена
                чтобы это предотвратить нужно или указать специальный параметр в <endpointBehaivor>
                или аналогичный параметр в коде (мы сделаем так)
          -->
          <security mode="TransportWithMessageCredential" />
        </binding>
      </ws2007FederationHttpBinding>
      <ws2007HttpBinding>
        <binding name="ForIssue">
          <security mode="TransportWithMessageCredential">
            <message clientCredentialType="UserName" establishSecurityContext="false" />
          </security>
        </binding>
      </ws2007HttpBinding>
    </bindings>
    <client>
      <endpoint address="https://мой_WCF_Service/WcfService/Service.svc"
          binding="ws2007FederationHttpBinding" bindingConfiguration="Service"
          contract="ServiceReference.Service" name="Service" />
      <!-- Мы добавляем новый endpoint -->
      <endpoint name="STS"
                address="https://мой_STS/IdSrv/issue/wstrust/mixed/username"
                binding="ws2007HttpBinding" bindingConfiguration="ForIssue"
                contract="System.ServiceModel.Security.IWSTrustChannelContract" />
    </client>
  </system.serviceModel>
</configuration>

// Формируем канал до STS - именно здесь мы указываем credentials пользователя
var stsChannelFactory = new WSTrustChannelFactory("STS");
stsChannelFactory.Credentials.UserName.UserName = "User1";
stsChannelFactory.Credentials.UserName.Password = "123456";
var stsClient = stsChannelFactory.CreateChannel();

// Запрашиваем токен
var token = stsClient.Issue(
    new RequestSecurityToken(RequestTypes.Issue)
    {
        // Указываем для какого RP нам нужен токен
        AppliesTo = new EndpointReference("https://мой_WCF_Service/WcfService/Service.svc")
    });

// Теперь канал уже до самого сервиса
var wcfServiceFactory = new ChannelFactory<ServiceReference.Service>("Service");
wcfServiceFactory.Credentials.UseIdentityConfiguration = true;
// Подавляем показ окошка выбора токена
wcfServiceFactory.Credentials.SupportInteractive = false;

// Собственно получение канала, у которого в качестве Credentials указан полученный ранее токен.
var channel = wcfServiceFactory.CreateChannelWithIssuedToken(token);
Console.WriteLine(channel.GetData());

• вы обращаетесь к некоемому центру, который может подтвердить вашу аутентичность (проверить что вы тот за кого себя выдаете, например по логину и паролю).
  
• этот центр после проверки формирует специальный документ, в котором указанные некоторые ваши данные. Чтобы ни у кого не было сомнений в подлинности, на документ ставится подпись (печать).
  
• теперь, когда вы предъявляете документ, все ориентируются на его подпись. Если подпись им знакома — документу доверяют и вся информация из него априори считается достоверной.

<Assertion ID="_311184a5-4c69-4c49-aa9f-a6b3bee96e32" IssueInstant="2014-02-02T08:16:37.209Z" Version="2.0" xmlns="urn:oasis:names:tc:SAML:2.0:assertion">
  <Issuer>STS</Issuer>
  <Signature xmlns="http://www.w3.org/2000/09/xmldsig#">
    <!-- Тут информация о подписи STS - это не интересно -->
  </Signature>
  <Subject>
    <SubjectConfirmation Method="urn:oasis:names:tc:SAML:2.0:cm:bearer"></SubjectConfirmation>
  </Subject>
  <Conditions NotBefore="2014-02-02T08:16:36.933Z" NotOnOrAfter="2014-02-02T08:36:36.933Z">
    <AudienceRestriction>
      <Audience>https://мой_WCF_Service/WcfService/Service.svc</Audience>
    </AudienceRestriction>
  </Conditions>
  <AttributeStatement>
    <Attribute Name="http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name">
      <AttributeValue>User1</AttributeValue>
    </Attribute>
    <Attribute Name="http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress">
      <AttributeValue>user1@companydomain.com</AttributeValue>
    </Attribute>
    <Attribute Name="http://schemas.xmlsoap.org/ws/2005/05/identity/claims/webpage">
      <AttributeValue>http://myhome.home</AttributeValue>
    </Attribute>
  </AttributeStatement>
  <AuthnStatement AuthnInstant="2014-02-02T08:16:36.450Z">
    <AuthnContext>
      <AuthnContextClassRef>urn:oasis:names:tc:SAML:2.0:ac:classes:Password</AuthnContextClassRef>
    </AuthnContext>
  </AuthnStatement>
</Assertion>

• смотрит, для какого именно сервера будет выдаваться токен (в терминологии WIF такой сервер-получатель токена называется Relying Party, RP). Если в списке его доверенных такого сервера то формируется ошибка и токен не выдается
  
• извлекает из своей базы данные пользователя (пользователя он берет из переданных credentials)
  
• генерирует ключи симметричного шифрования для клиента и сервера — этими ключами будет защищаться канал/сессия между клиентом и RP
  
• формирует токен, для RP (состоящий из данных пользователя и ключа шифрования), подписывает его своим закрытым ключом и шифрует открытым ключом RP.
  
• затем, зашифрованный пакет вкладывает в еще один пакет, предназначенный уже для клиента (там могут быть те же данные, но обычно там только шифрования для клиента). Этот пакет тоже подписывается
  
• результат возвращается клиенту (Security Token Response, STRes)

• Создать и правильно прописать SSL сертификаты для STS и WCF Service (если они на разных машинах, если на одной — хватит и одного).
  
• Создать и положить в хранилище сертификат для подписания. Thinktecture IdentityServer по умолчанию берет такие сертификаты из Local Machine / My, поэтому кладем туда. Обратите внимание, что для сертификата надо дать права на доступ к закрытым ключам ученой записи под которой запущен STS (самое простое — дать права IIS_IUSRS, хотя это и не совсем правильно)
  
• Аналогично создать и положить в хранилище сертификат для шифрования. Только теперь это нужно сделать на машине WCF Service + на базе этого сертификата сделать файл сертификата только с открытым ключом (.cer)

• Имхо, в разделе "General Configuration" лучше снять галочку "Only Users in the 'IdentityServerUsers' role can request tokens:" (иначе всех пользователей придется добавлять в эту группу)
  
• В разделе "Key Configuration" указать наш сертификат для подписи в Signing Certificate
  
• В Разделе Protocols, проверьте, что включен WS-Trust (нам нужен только он), а затем зайдите в сами настройки WS-Trust и проверьте что стоит галочка "Enable Mixed Mode Security Endpoints" (это так ребята обозначают возможность аутентификации по User/Password на STS
  
  
• В разделе "Relying Parties & Resources" создать новую запись об RP. Обратите внимание, здесь в качестве Encrypting Certificate нужно указать тот самый .cer который мы создали ранее на основе сертификата шифрования для WCF Service. В качестве Realm указывайте адрес сервиса в том виде, как он указывается в настройках WCF.
  
  
• Ну и конечно, создать пользователя, которого мы будем аутентифицировать.

<?xml version="1.0"?>
<configuration>
  <configSections>
    <!-- Обязательно указать эту секцию!!! Почему ее нет по умолчанию в machine.confug - ума не приложу -->
    <section name="system.identityModel" type="System.IdentityModel.Configuration.SystemIdentityModelSection, System.IdentityModel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089"/>
  </configSections>

  <system.serviceModel>
    <bindings>
      <ws2007FederationHttpBinding>
        <binding name="Default">
          <!--    Мы используем TransportWithMessageCredential безопасность, чтобы не заморачиваться с настройками,
                так как SSL мы уже настроили.
                В качестве issuerMetadata нужно указать адрес, который содержится на странице Application integration
                и называется "WS-Trust metadata"
          -->
          <security mode="TransportWithMessageCredential">
            <message>
              <issuerMetadata address="https://мой_STS/IdSrv/issue/wstrust/mex" />
            </message>
          </security>
        </binding>
      </ws2007FederationHttpBinding>
    </bindings>
    
    <behaviors>
      <serviceBehaviors>
        <behavior>
          <!-- Это чтобы не возиться с настройкой клиента... -->
          <serviceMetadata httpGetEnabled="true" httpsGetEnabled="true"/>
          <serviceDebug includeExceptionDetailInFaults="false"/>
          <!-- Здесь мы указываем, что в pipeline WCF будет работать WIF, конфигурация которой (DefaultIConf) описывается ниже-->
          <serviceCredentials identityConfiguration="DefaultIConf" useIdentityConfiguration="true" />
        </behavior>
      </serviceBehaviors>
    </behaviors>
    
    <services>
      <!-- Ну и сам сервис. Т.к. хостим под IIS, адрес не указываем, binding и contract - обязательно -->
      <service name="WcfService.Service">
        <endpoint binding="ws2007FederationHttpBinding" bindingConfiguration="Default" contract="WcfService.Service" />
      </service>
    </services>
  </system.serviceModel>

  <!-- Здесь указываются все настройки WIF, т.е., собственно, все настройки обработки токенов -->
  <system.identityModel>

    <!-- Это требование MS в WIF - создавать и использовать отдельные конфигурации -->
    <identityConfiguration name="DefaultIConf">
      <securityTokenHandlers>

        <securityTokenHandlerConfiguration>
          <!-- Здесь мы указываем, что не будем проверять какому именно серверу предназначен пришедший токен
                если все же хочется проверять, то нужно будет добавить к узлу audienceUris дочерний.
                Что-то типа <add value="https://мой_хост/WcfService/Service.svc"/> - главное следить, чтобы он совпадал 
                с тем, что указано в поле Realm/Scope Name на STS
          -->
          <audienceUris mode="Never" />

          <!--    Здесь указывается класс, который будет для пришедшего токена искать закрытый ключ для расшифровки.
                К сожалению, я не нашел как для этого параметра указать настройку (т.е. в каком хранилище искать сертификаты)
                это можно сделать, если задавть настройку программно (например, делать свой наследник текущего класса и там 
                в конструкторе заполнять нужные параметры, а здесь указывать наш класс).
                Однако по умолчанию этот класс ищет сертификаты в Local Machine / My так что просто положим его туда
          -->
          <serviceTokenResolver
              type="System.IdentityModel.Tokens.X509CertificateStoreTokenResolver, System.IdentityModel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089"/>

          <!--    Этот тэг задает список доверенных STS, т.е. тех от которых мы готовы получать токены.
                Опознаем мы их довольно просто - по thumbprint сертификата, которым они ставят подпись
                Информация о сертификате подписи добавляется в саму подпись, поэтому ничего регистрировать 
                дополнительно не надо, надо только указать строку thumbprint (имя произвольное)
          -->
          <issuerNameRegistry>
            <trustedIssuers>
              <add name="STS" thumbprint="9B14A55B4A435YYY8C88D14779F57193905C2"/>
            </trustedIssuers>
          </issuerNameRegistry>

        </securityTokenHandlerConfiguration>

      </securityTokenHandlers>
    </identityConfiguration>
  </system.identityModel>

</configuration>

<?xml version="1.0" encoding="utf-8" ?>
<configuration>

  <system.serviceModel>
    <bindings>
      <!-- !!! Должно быть 2 биндинга: ws2007FederationHttpBinding и ws2007HttpBinding  !!! -->
      <ws2007FederationHttpBinding>
        <binding name="WS2007FederationHttpBinding_Service">
          <security mode="TransportWithMessageCredential">
            <message>
              <!-- !!! Обратите внимание на адрес. Он должен совпадать с "WS-Trust mixed mode security (user name)" 
                  на странице Application integration  !!! 
              -->
              <issuer address="https://мой_STS/IdSrv/issue/wstrust/mixed/username"
                  binding="ws2007HttpBinding" bindingConfiguration="https://мой_STS/IdSrv/issue/wstrust/mixed/username" />
              <issuerMetadata address="https://мой_STS/IdSrv/issue/wstrust/mex" />
              <tokenRequestParameters>
                <trust:SecondaryParameters xmlns:trust="http://docs.oasis-open.org/ws-sx/ws-trust/200512">
                  <!-- Тут я выпущу кусок -->
                </trust:SecondaryParameters>
              </tokenRequestParameters>
            </message>
          </security>
        </binding>
      </ws2007FederationHttpBinding>

      <ws2007HttpBinding>
        <!--  !!! Модель безопасности должна быть TransportWithMessageCredential
              а  clientCredentialType должен стоять в UserName  !!! -->
        <binding name="https://мой_STS/IdSrv/issue/wstrust/mixed/username">
          <security mode="TransportWithMessageCredential">
            <transport clientCredentialType="None" />
            <message clientCredentialType="UserName" establishSecurityContext="false" />
          </security>
        </binding>
      </ws2007HttpBinding>
    </bindings>

    <client>
      <!-- Ну а тут просто адрес наших WCF Service и указание биндинга с контрактом -->
      <endpoint address="https://мой_WCF_Service/WcfService/Service.svc"
          binding="ws2007FederationHttpBinding" bindingConfiguration="WS2007FederationHttpBinding_Service"
          contract="ServiceReference.Service" name="WS2007FederationHttpBinding_Service" />
    </client>
  </system.serviceModel>
</configuration>

using (var client = new ServiceReference.ServiceClient())
{
    client.ClientCredentials.UserName.UserName = "User1";
    client.ClientCredentials.UserName.Password = "123456";

    Console.WriteLine(client.GetData());
}

namespace WcfService
{
    [ServiceContract]
    public class Service
    {
        [OperationContract]
        public string GetData()
        {
            var princinpal = OperationContext.Current.ClaimsPrincipal;
            var name = princinpal.Identity.Name;
            var email = princinpal.FindFirst(ClaimTypes.Email);
            var webPage = princinpal.FindFirst(ClaimTypes.Webpage);

            return string.Format("User: {0}, mail: {1}, web page: {2}", name, 
                email == null ? "" : email.Value,
                webPage == null ? "" : webPage.Value);
        }
    }
}

МР>namespace WcfService
МР>{
МР>    [ServiceContract]
МР>    public class Service
МР>    {
МР>        [OperationContract]
МР>        public string GetData()
МР>        {
МР>            var princinpal = OperationContext.Current.ClaimsPrincipal;
МР>            var name = princinpal.Identity.Name;
МР>            var email = princinpal.FindFirst(ClaimTypes.Email);
МР>            var webPage = princinpal.FindFirst(ClaimTypes.Webpage);

МР>            return string.Format("User: {0}, mail: {1}, web page: {2}", name, 
МР>                email == null ? "" : email.Value,
МР>                webPage == null ? "" : webPage.Value);
МР>        }
МР>    }
МР>}
МР>

<behaviors>
      <serviceBehaviors>
        <behavior>
          <!-- ... -->
          <serviceCredentials  useIdentityConfiguration="true"/>
<serviceAuthorization principalPermissionMode="Always"/>
        </behavior>
      </serviceBehaviors>
    </behaviors>

        [PrincipalPermission(SecurityAction.Demand, Role = @"admin")]
        public List<Items> GetItems()

• этот сервер и то, как он работает (мы сами используем самописный вариант на базе WIF 4.0).
  
• что поменялось в WIF после выхода 4.5

<EncryptedAssertion xmlns="urn:oasis:names:tc:SAML:2.0:assertion">
  <xenc:EncryptedData Type="http://www.w3.org/2001/04/xmlenc#Element" 
                      xmlns:xenc="http://www.w3.org/2001/04/xmlenc#">
    <xenc:EncryptionMethod Algorithm="http://www.w3.org/2001/04/xmlenc#aes256-cbc" />
    <KeyInfo xmlns="http://www.w3.org/2000/09/xmldsig#">
      <!-- Информация о ключе шифрования  -->
    </KeyInfo>
    <xenc:CipherData>
      <xenc:CipherValue>OQFpRRqqa5z8Rkgfs ... e9ltVY=</xenc:CipherValue>
    </xenc:CipherData>
  </xenc:EncryptedData>
</EncryptedAssertion>

• установить (или зашить в клиент) такой же ключ как на RP, а потом средствами WIF расшифровать токен. Откровенно говоря выглядит костыль-костылем... А в свете идеи "разные токены для разных RP" еще и портит все
  
• завести для клиента отдельную RP (а почему клиент не RP?) и уже сертифкат этой RP "зашивать" в клиента. В принципе, если бы мы не использовали SSL для передачи, это был бы самый правильный путь. А так, имхо, это излишне — все равно сертифкат для шифрования будет храниться на клиенте, а значит нет никакой особой проблемы его добыть.
  
• сделать п.2, но заставить STS не шифровать сертифкат.

• если включена опция принудительного шифрования — шифровать токен.
  
• если принудительное шифрование отключено, но в токене будут передаваться Symmetric Keys для защиты сессии между клиентом и RP — то все равно шифровать токен.

• SymmetricKey — ключи для симметричного шифрования (опция по умолчанию для выдачи токенов по WS-Trust). Здесь шифрование обязательно!
  
• AsymmetricKey — тоже все понятно. Я сам такими не пользовался ни разу. Подозреваю, что в токене будет просто указываться какой сертификат использовать (например его thumbprint), а сами сертификаты будут ставится на компьютеры. Думаю, здесь шифрование не нужно.
  
• BearerKey — "односторонние ключ" (мой перевод). Честно говоря, так до конца и не разобрался с термином, но что для нас важно — шифрование в этом случае тоже не используется.

var client = stsChannelFactory.CreateChannel();
var token = client.Issue(
    new RequestSecurityToken(RequestTypes.Issue)
    {
        AppliesTo = new EndpointReference("urn:Client"),
        KeyType = KeyTypes.Bearer
    });

<configuration>
  <configSections>
    <section name="system.identityModel" type="System.IdentityModel.Configuration.SystemIdentityModelSection, System.IdentityModel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089"/>
  </configSections>
  
  <system.identityModel>
    <identityConfiguration name="ClientConf">
      <securityTokenHandlers>
        <securityTokenHandlerConfiguration>
          <audienceUris mode="Never" />
          <issuerNameRegistry>
            <trustedIssuers>
              <add name="STS" thumbprint="9B14A55B4AB96F5D7188C88D14779F57193905C2"/>
            </trustedIssuers>
          </issuerNameRegistry>
        </securityTokenHandlerConfiguration>
      </securityTokenHandlers>
    </identityConfiguration>
  </system.identityModel>
  
  <system.serviceModel>
   <!-- А здесь без изменений -->
  </system.serviceModel>
</configuration>

var stsChannelFactory = new WSTrustChannelFactory("STS");
stsChannelFactory.Credentials.UserName.UserName = "User1";
stsChannelFactory.Credentials.UserName.Password = "123456";

var client = stsChannelFactory.CreateChannel();
var token = client.Issue(
    new RequestSecurityToken(RequestTypes.Issue)
    {
        AppliesTo = new EndpointReference("urn:Client"),
        KeyType = KeyTypes.Bearer
    }
    );

var identityConfiguration = new IdentityConfiguration("ClientConf");
// Нужный нам SAML токен лежит в token.TokenXml (ну и берем от него OuterXml, т.к. будем все парсить)
var xmlReader = XmlReader.Create(new StringReader(((GenericXmlSecurityToken)token).TokenXml.OuterXml));

var samlToken = identityConfiguration.SecurityTokenHandlers.ReadToken(xmlReader);
var claimsCollection = identityConfiguration.SecurityTokenHandlers.ValidateToken(samlToken)[0];

// В принципе получать именно principal не обязательно, но т.к. он используется везде, то и здесь сделаем так же
var principal = new ClaimsPrincipal(new ClaimsIdentity(claimsCollection));

<system.serviceModel>
    <bindings>
      <ws2007FederationHttpBinding>
        <binding name="Default">
                   <security mode="TransportWithMessageCredential">
            <message issuedKeyType="BearerKey">
              <issuerMetadata address="https://мой_STS/IdSrv/issue/wstrust/mex" />
            </message>
          </security>
        </binding>
      </ws2007FederationHttpBinding>
    </bindings>
 </system.identityModel>

<ws2007FederationHttpBinding>
  <binding name="Service">
    <security mode="TransportWithMessageCredential" >
      <message issuedKeyType="BearerKey"/>
    </security>
  </binding>
</ws2007FederationHttpBinding>

• это немного не ваш, как мне кажется, вариант
  
• Thinktecture не совсем заточен под этот вариант — нужны некоторые доработки. Т.е. делегирование-то он поддерживает, но у него идеология, что делегирвоание запрашивает не сервер/приложение, а конкретный пользователь. Т.е. сервер и клиент должны иметь свои учетные записи на Thinktecture, а это имеет свои проблемы (например, если будет учетная запись клиента, то его credentials придется зашить в приложение, и значит потенциально кто-то сможет получать токен "для клиентского приложения" и работать от него. А делать специальную обработку для защиты от такого не очень хочется).
  
• времени не хватает катастрофически Впрочем, это уже традиционный "отмаз".

• Пользователь А проходит авторизацию на STS и получает свой токен
  
• Этот токен, он передает пользователю B
  
• Пользователь B обращается к сервису RP по схеме с федеративной аутентификацией (т.е. тоже через получение токена на STS — причем этот STS не обязательно должен быть тем же, что и у пользователя A), но, помимо собственных credentials передает в запросе еще и токен, полученный от A (этот токен передается в специальном поле запроса, т.е. сам по себе он не является credential)
  
• STS-сервер получает запрос на токен, проверяет credential пользователя B, а затем, анализируя запрос, видит в нем токен от A, проверяет валидность этого токена и если все в порядке формирует токен для доступа к RP, но выданный на пользователя A.
  
• С этим токеном пользователь B обращается к RP, т.е. для RP он представлен как пользователь А (или имперсонирован)

• Реальные люди-пользователи. Для них разрешена аутентификация по пользователю/пароли и прямой запрос сертификата для себя. Делегирвоание запрещено
  
• Приложения-пользователи. Им разрешена аутентификация по сертификату, причем обрабатываются только запросы на делегирование (в которых есть вложенный сертификат на реального пользователя), остальные запрещаются.

<system.serviceModel>
  <bindings>
    <ws2007FederationHttpBinding>
      <binding name="Service">
        <security mode="TransportWithMessageCredential" >
          <message issuedKeyType="BearerKey">
            <issuer address="https://мой_STS/IdSrv/issue/wstrust/mixed/certificate"
                    binding="ws2007HttpBinding" bindingConfiguration="ForActAs" />
          </message>
        </security>
      </binding>
    </ws2007FederationHttpBinding>
    <ws2007HttpBinding>
      <binding name="ForIssue">
        <security mode="TransportWithMessageCredential">
          <message clientCredentialType="UserName" establishSecurityContext="false" />
        </security>
      </binding>
      <binding name="ForActAs">
        <security mode="TransportWithMessageCredential">
          <message clientCredentialType="Certificate" establishSecurityContext="false" />
        </security>
      </binding>
    </ws2007HttpBinding>
  </bindings>
  <client>
    <endpoint address="https://мой_WCF_Service/WcfService/Service.svc"
        binding="ws2007FederationHttpBinding" bindingConfiguration="Service"
        contract="ServiceReference.Service" name="Service" />
    <endpoint name="STS"
              address="https://мой_STS/IdSrv/issue/wstrust/mixed/username"
              binding="ws2007HttpBinding" bindingConfiguration="ForIssue"
              contract="System.ServiceModel.Security.IWSTrustChannelContract" />
  </client>
</system.serviceModel>

var stsChannelFactory = new WSTrustChannelFactory("STS");
stsChannelFactory.Credentials.UserName.UserName = "User1";
stsChannelFactory.Credentials.UserName.Password = "123456";

var client = stsChannelFactory.CreateChannel();
var token = client.Issue(
    new RequestSecurityToken(RequestTypes.Issue)
    {
        AppliesTo = new EndpointReference("urn:Client"),
        KeyType = KeyTypes.Bearer
    }
    );

// Здесь можно токен распаковать и получить данные на клиенте

var wcfServiceFactory = new ChannelFactory<ServiceReference.Service>("Service");
wcfServiceFactory.Credentials.UseIdentityConfiguration = true;
var cert = GetClientCertificate();
wcfServiceFactory.Credentials.ClientCertificate.Certificate = cert;

var channel = wcfServiceFactory.CreateChannelWithActAsToken(token);
Console.WriteLine(channel.GetData());

public X509Certificate2 GetClientCertificate()
{
    X509Store store = null;
    try
    {
        store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
        store.Open(OpenFlags.ReadOnly);
        return
            store.Certificates.Find(X509FindType.FindByThumbprint, "19B14A554EDHYF5D7188C88014779F57193905C2", false)
                .OfType<X509Certificate2>()
                .Single();
    }
    finally
    {
        if (store != null)
            store.Close();
    }
}

public void RequestSecuredWCFOne(GenericXmlSecurityToken token){
            using (var cf = new ChannelFactory<IService2>("WS2007FederationHttpBinding_IService2"))
            {
                cf.Credentials.UseIdentityConfiguration = true;
                var proxy = cf.CreateChannelWithIssuedToken(token);

                var data = proxy.GetData(1);
                Console.WriteLine(data);

                ((IDisposable)proxy).Dispose();
            }
        }

<system.identityModel.services>
    <federationConfiguration>
      <!--<serviceCertificate>
        <certificateReference x509FindType="FindByThumbprint" findValue="..." storeLocation="LocalMachine" storeName="My" />
      </serviceCertificate>-->
    </federationConfiguration>
  </system.identityModel.services>