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();
            }
        }

<?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>

<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 придется зашить в приложение, и значит потенциально кто-то сможет получать токен "для клиентского приложения" и работать от него. А делать специальную обработку для защиты от такого не очень хочется).
  
• времени не хватает катастрофически Впрочем, это уже традиционный "отмаз".

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

• Пользователь А проходит авторизацию на 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();
    }
}

МР>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()