python3 requests 模拟用户登陆失败

Question

使用python3的Requests库模拟登陆失败。

相关代码

import requests, bs4

login_url = 'https://accounts.104.com.tw/login'
login_data = {
    'username': 'user01', 
    'password': '*****', 
}

headers = {
    'User-Agent': 'Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.181 Mobile Safari/537.36'
    }
    
s= requests.Session()
r = requests.get(login_url, headers=headers)

# 获取实际访问地址（这里的地址会含有sessionDadaKey等随机信息）
referer_url = r.url

print(r)
print(r.url)

# 跳转到目标地址
k = s.post(referer_url, login_data)

print(k);    // 不论登陆是否成功，这里都会是<Response [200]>
print(k.url);

使用以上代码始终登陆不上，请问问题出在哪？感激不尽

更新：
将上面的k = s.post(referer_url, login_data)改为k = s.post(referer_url, data=login_data)依然不行。

这个网站登陆过程会经过很多次跳转，比较复杂，是在不知道该怎么处理，求助....

Answer 1

报错信息traceback提供一下

Answer 2

如果不是出现异常的话，你需要弄清楚对方接受数据的方式到底是params还是form-data还是x-www-form-urlencoded，或者有可能是网站有其他的预检机制

Answer 3

通过分析登陆请求，你可以发现登陆传递的数据是下面几种：

并没有，username和password，它提交的数据应该是username和password甚至还有链接上面的随机字符串，一起加密后的SAMLResponse字段，下面是我登陆时，把浏览器里面的SAMLResponse复制过去执行，可以正常登陆，所以现在解决方案有两个
1、你去查看一下它前端加密方式
2、使用selenium，模拟点击登陆按钮

import requests, bs4


login_url = 'https://accounts.104.com.tw/login'
login_data = {
    'loginBy': 'saml',
    'queryString':'',
    'RelayState': 'http://accounts.104.com.tw/login',
    'SAMLResponse':'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',
}

headers = {
    'User-Agent': 'Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.181 Mobile Safari/537.36'
}

s = requests.Session()
r = requests.get(login_url, headers=headers)

# 获取实际访问地址（这里的地址会含有sessionDadaKey等随机信息）
referer_url = r.url

print("随机访问地址",referer_url)

print(r)

# 跳转到目标地址
#https://accounts.104.com.tw/acs
#k = s.post(referer_url, login_data)
k = s.post('https://accounts.104.com.tw/acs', login_data)

print(k);
#不论登陆是否成功，这里都会是 < Response[200] >
print(k.url);

我运行后的结果：

随机访问地址 https://signin.104.com.tw?sessionDataKey=c53eb488-0018-49c4-9349-edcf3cab5dde&relyingParty=myaccount&type=samlsso&sp=myaccount&authenticators=FacebookAuthenticator%3Afacebook&BasicAuthenticator%3ALOCAL%3ALOCAL&RelayState=aHR0cDovL2FjY291bnRzLjEwNC5jb20udHcvbG9naW4%3D
<Response [200]>
<Response [200]>
https://accounts.104.com.tw