标签: srp-protocol

在任何主流浏览器中是否有RFC 5054的计划或现有实现？

如果还没有人实现,那么哪些主流浏览器在他们的路线图上有它？哪里？

亚马逊提供iOS,Android和Javascript Cognito SDK,提供高级身份验证用户操作.

例如,请参见用例4:

https://github.com/aws/amazon-cognito-identity-js

但是,如果您使用的是python/boto3,那么您只需要一对基元:cognito.initiate_auth和cognito.respond_to_auth_challenge.

我试图使用这些原语以及pysrplib与USER_SRP_AUTH流进行身份验证,但我所拥有的是不起作用.

在调用RespondToAuthChallenge操作时出现"出错(NotAuthorizedException)总是失败:用户名或密码不正确." (使用JS SDK查找用户名/密码对.)

我的怀疑是我正在构建错误的挑战响应(步骤3),和/或当它想要base64时传递Congito十六进制字符串,反之亦然.

有没有人得到这个工作？有谁看到我做错了什么？

我试图复制authenticateUser在Javascript SDK中找到的调用的行为:

https://github.com/aws/amazon-cognito-identity-js/blob/master/src/CognitoUser.js#L138

但我做错了什么,无法弄清楚是什么.

#!/usr/bin/env python
import base64
import binascii
import boto3
import datetime as dt
import hashlib
import hmac

# http://pythonhosted.org/srp/
# https://github.com/cocagne/pysrp
import srp

bytes_to_hex = lambda x: "".join("{:02x}".format(ord(c)) for c in x)

cognito = boto3.client('cognito-idp', region_name="us-east-1")

username = "foobar@foobar.com"
password = "123456"

user_pool_id = u"us-east-1_XXXXXXXXX"
client_id = u"XXXXXXXXXXXXXXXXXXXXXXXXXX"

# Step 1:
# Use SRP lib …

我正在尝试通过ruby​​ SDK使用 AWS Cognito 服务进行用户身份验证。

我可以使用这些方法进行注册、确认注册过程

  resp = client.sign_up({ client_id: "ClientIdType",
                          secret_hash: "SecretHashType",
                          username: "UsernameType",
                          password: "PasswordType",
                          user_attributes: [{ name:"AttributeNameType", 
                                    value: "AttributeValueType",
                                     }],
                          validation_data: [{
                          name: "AttributeNameType",
                          value: "AttributeValueType",
                                  }]
                          })

并使用确认注册

  resp = client.confirm_sign_up({client_id: "ClientIdType",
                                 secret_hash: "SecretHashType",
                                 username: "UsernameType",
                                 confirmation_code: "ConfirmationCodeType"
                                })

但是，在尝试通过 initiate_auth 登录用户时，我收到错误Missing required parameter SRP_A

cog_provider.initiate_auth({client_id: "xxxxxxxxx", auth_parameters: { username: "xxx", password: "xxx"}, auth_flow: "USER_SRP_AUTH"})

SRP_A 表示在哪里可以找到它。

我已经搜索过这个问题，建议使用admin_initiate_auth登录用户的方法，我认为这不是最佳实践。

根据要求,我需要打开设备注册Always.但是,我们的SRP流程开始失败,出现以下问题.

{ code: 'UnknownError', message: 'Unknown error, the response body from fetch is: undefined' }

在做了一些研究之后,我发现了一个类似的帖子,但似乎唯一的解决方案是关闭设备注册.

在运行node get-token.js脚本以检索我们的CI/CD测试管道的令牌时失败了.

    cognitoUser.authenticateUser(authCfg, {
        onSuccess: function (result) {
            console.log("Result : ", result);
            const token = result.getAccessToken().getJwtToken();
            resolve(token)
        },
        onFailure: function(err) {
            console.error("Failure : ", err);
            console.log(new Error().stack);
            reject(new Error("An error occurred: " + err))
        },
        newPasswordRequired: function (userAttributes, requiredAttributes) {
            cognitoUser.completeNewPasswordChallenge(p, userAttributes, this);
        },
    });

在提出这个问题时,我正在寻找实施我自己的AuthenticationProvider的指导.我的意思是:

到目前为止,我已经了解到,如果用户已经过身份验证,Spring Security会询问AuthenticationProvider对象.目前我正在使用DaoAuthenticationProvider来处理我自己的用户UserDetailService返回的用户名和密码.一切都很棒!Spring支持很多不同的AuthenticationProvider,例如有一个用于LDAP,Jdbc,DAO(如上所述),我甚至可以找到一个用于Kerberos.但是,SRP没有身份验证提供程序,因此需要编写一个.

我的问题如下:

当我们使用DaoAuthenticationProvider即用户/密码认证时,我们有一个html表单,其中输入用户名和密码,然后一个按钮负责提交这两个参数.买入的barameteres通过某些传输通道传输到服务器,即只需点击一下,我们就能够在同一个http请求中发送所有数据,即验证所需的全部数据.这可以在UsernamePasswordAuthenticationFilter中看到.这里的方法"attemptAuthentication"采用"HttpServletRequest request",其中包括用户名和密码.直到现在一切都好.

 public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
        ...
        }

好吧,在简单的SRP中我们还有一个用户名和密码的表单,除了密码!!!必须!不能通过网络转移.为了实现该约束,必须在客户端和服务器之间进行"讨论",即必须交换以下参数.

1)用户名(I),

2)一个名为"A"的值

3)一个名为"B"的值

4)一个名为"M1"的值

5)一个名为"M2"的值

那么,让我们假设有一个名为"SrpAuthenticationProcessingFilter"的过滤器,如果新的身份验证协议更像是我在RFC 5054中的对话,那么过滤器应该如何.

   Client                                            Server

   Client Hello (I)        -------->
                                               Server Hello
                                               Certificate*
                                        Server Key Exchange (N, g, s, B)
                           <--------      Server Hello Done
   Client Key Exchange (A) -------->
   [Change cipher spec]
   Finished                -------->
                                       [Change cipher spec]
                           <--------               Finished

   Application Data        <------->       Application Data

在这里,我们有一个需要的客户

• a)首先发送他的用户名(I)
• b)然后服务器需要用值B进行响应(在这种情况下,N,g,s不是必需的)
• c)客户发送它的"价值A"
• d)客户端使用来自服务器的值B并基于该值计算密钥.
• e)服务器也根据值A计算密钥.
• f)客户端将值M1发送到服务器.
• g)服务器获取M1值并基于具有M1值作为参数的公式,他能够验证密钥是否匹配,如果所购买方的计算密钥匹配则用户被认证,并且产品即共享密钥可以进一步用于其他处理.

与用户名和密码身份验证相反,这些是7个步骤而不是1个步骤.其中3个需要在SrpAuthenticationProcessingFilter之前发生.现在我知道有可能将用户名与"值A"一起发送,从而缩短了步骤数,但我想严格遵循RFC.从来没有采取简单的方法吗？

问题实际上是我在哪里放置可以响应客户端和服务器之间的乒乓(对话)的代码,即上面提到的前3个步骤a,b和c.它应该将它们放在SrpEntryPoint对象中还是其他位置.if else然后是在SpringSecurity的背景下？

我可以解决这个问题的一种方法是使用websockets,但我还想使该身份验证独立于任何第5-7层协议,如websockets,http,spdy等.这意味着第一个实现应该是简单的http请求/响应,然后是任何其他协议.

因此,目前实施SRP可能是正确的结构是:

• SRPAuthenticationEntryPoint实现了org.springframework.security.web.AuthenticationEntryPoint - …

关于SRP协议:http: //en.wikipedia.org/wiki/Secure_remote_password_protocol

我可以看到会话密钥(K)的生成是完全安全的,但在最后一步中,用户发送K(M)证明.如果网络不安全且midlle中的攻击者捕获了M,他就可以在没有K的情况下进行身份验证.

我正在尝试使用 Cognito 对 Java 应用程序进行身份验证。我在 python 中使用了运行良好的保证库。但我现在想在java中做同样的事情。

我用我的 Python 函数对保证库进行身份验证

def SRPauthentication(organizationAdmin,
                     password,
                     pool_id,
                     client_id,
                     client):
    aws = AWSSRP(username=organizationAdmin,
                 password=password,
                 pool_id=pool_id,
                 client_id=client_id,
                 client=client)
    tokens = aws.authenticate_user()
    authorization_token= tokens['AuthenticationResult']['IdToken']
    return authorization_token 

有了这个，我可以轻松访问一些安全的 API。现在我想用 Java 做同样的事情，但我有问题。

到目前为止，这是我的解决方案是这种方法：

  public static void GetCreds()
      {

          AWSCognitoIdentityProvider identityProvider = AWSCognitoIdentityProviderClientBuilder.defaultClient();
          AdminInitiateAuthRequest adminInitiateAuthRequest = new AdminInitiateAuthRequest().
                  withAuthFlow(AuthFlowType.USER_SRP_AUTH).
                  withClientId("234234234234").withUserPoolId("eu-central-1_sdfsdfdsf")
                  .addAuthParametersEntry("USERNAME", "UserK").
                   addAuthParametersEntry("PASSWORD","#######);

          adminInitiateAuthRequest.getAuthFlow();
          AdminInitiateAuthResult adminInitiateAuth = identityProvider.adminInitiateAuth(adminInitiateAuthRequest);
            System.out.println(adminInitiateAuth.getAuthenticationResult().getIdToken());
      }

当我运行它时，我得到一个异常：

Exception in thread "main" `com.amazonaws.services.cognitoidp.model.AWSCognitoIdentityProviderException: User: arn:aws:iam::XXXXXXXXXXXXXXXXX:user/khan is not authorized to perform: cognito-idp:AdminInitiateAuth on resource: arn:aws:cognito-idp:eu-central-1:XXXXXXXX:userpool/eu-central-1_XXXXXXX …

我正在使用 boto3 和授权库来尝试对设备进行身份验证，以在识别后跳过多因素身份验证。我已经通过了用户/密码身份验证，但似乎无法找出验证设备的正确方法。以下是我的代码：

from warrant import aws_srp
from warrant.aws_srp import AWSSRP
import boto3
client = boto3.client('cognito-idp')
import datetime

username='xxx'
password='xxx'
client_id='xxx'

aws = AWSSRP(username=username, password=password, pool_id='xxx',
client_id=client_id, client=client)

auth_init = client.initiate_auth(
    AuthFlow='USER_SRP_AUTH',
    AuthParameters={
        'USERNAME': username,
    'SRP_A': aws_srp.long_to_hex(aws.large_a_value),
    },
    ClientId=client_id,
)

cr = aws.process_challenge(auth_init['ChallengeParameters'])
response = client.respond_to_auth_challenge(
    ClientId=client_id,
    ChallengeName=auth_init['ChallengeName'],
    ChallengeResponses=cr
)

response = client.respond_to_auth_challenge(
    ClientId=client_id,
    ChallengeName='SMS_MFA',
    Session=response['Session'],
    ChallengeResponses={
        'USERNAME': username,
        'SMS_MFA_CODE':'xxx'
    }
)

response_dev = client.confirm_device(
    AccessToken=response['AuthenticationResult']['AccessToken'],
    DeviceKey=response['AuthenticationResult']['NewDeviceMetadata']['DeviceKey'],
DeviceSecretVerifierConfig={ 
    "PasswordVerifier": aws_srp.long_to_hex(aws.large_a_value),
    "Salt": aws_srp.long_to_hex(aws.small_a_value)
}
)

response = client.update_device_status(
    AccessToken=response['AuthenticationResult']['AccessToken'],
    DeviceKey=device,
    DeviceRememberedStatus='remembered' …