爬虫案例之网易有道翻译Python代码改写

于 2023-05-13 20:43:00 发布
阅读量1k 收藏 10
点赞数 6
文章标签： python 爬虫 java 前端 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Chimengmeng/article/details/130664974
版权

网易有道翻译之逆向破解[Python代码改写]

***用到的知识点：

(1)requests模块和session模块，发起请求

  • 什么是session对象？
    • 该对象和requests模块用法几乎一致.
    • 对于在请求过程中产生了cookie的请求
    • 如果该请求是使用session发起的,则cookie会被自动存储到session中.
session = requests.Session()

详见博客：https://www.cnblogs.com/dream-ze/p/17176494.html

(2)headers头部伪装，随机UA伪装

# UA伪装之随机headers模块
from fake_useragent import UserAgent

headers = {'User-Agent': UserAgent().random,} # 这里的random方法不需要random模块支持

(3)md5加密算法，加密数据

# md5加密模块
from hashlib import md5
# 如果需要十六进制的结果与二进制的结果之间的转换，需要的模块
import binascii

# 【1】准备数据
data = '你好' #这里是字符串类型
# 字符串转二进制数据方式一
encode_data = s.encode()
# 字符串转二进制数据方式二
encode_data = b'你好'

# 【2】数据加密
# 构建md5对象
md5_obj = md5()
# 将数据更新到md5算法中进行数据加密 (参数为二进制数据的明文数据)
#(方法一)：直接在加密算法中进行转码
md5_obj.update("你好".encode("utf-8"))
md5_obj.update(data.encode("utf-8"))
#(方法二)：先将明文数据进行转码，再传入到加密算法中
md5_obj.update(encode_data)


# 【3】数据提取
# 拿到加密字符串 # 十六进制的结果
result_16 = obj.hexdigest()
# 拿到加密字符串 # 二进制的结果
result_2 = obj.digest()
# 拿到加密字符串 # 十六进制的结果与二进制的结果之间的转换 (参数为result_16 或 result_2) 
result_change = binascii.unhexlify(result_16)

详见博客：https://www.cnblogs.com/dream-ze/p/17362507.html

(4)AES加密算法，解密部分

# 从算法模块中导入AES加密算法
from Crypto.Cipher import AES
# 导入base64编码模块
import base64

# --------【一】解密部分解释--------#

# (1)将base64数据进行解码
# 先将base64数据解码
base_data = final_data
# encrypt_data = base64.b64decode(这里的数据是二进制数据)
encrypt_data = base64.b64decode(base_data.encode())
# 因为base64编码前就需要转换为二进制数据，所以下面的解码部分转换出来的也是二进制数据

# (2) 重新生成aes对象，将密文数据进行解密
# 声明key：key的长度必须是16的倍数且key为二进制数据(即转码)
key = b'1314521131452121'
# 声明iv：iv是CBC模式特有的参数，为数据偏移量,iv的长度必须是16的倍数且iv为二进制数据(即转码)
iv = b'8384582838458221'
# 创建aes对象 aes对象 = AES.new(必须参数key, 密文加密模式, 数据偏移量)
aes = AES.new(key, AES.MODE_CBC, iv)
# (3)解密
# 因为base64编码前就需要转换为二进制数据，所以解码部分解出来的也是二进制数据
# 解密后的密文变量名 = aes.decrypt(需要解密的二进制密文数据)
plain_data = aes.decrypt(encrypt_data)

详见博客：https://www.cnblogs.com/dream-ze/p/17381270.html

(5)base64编码，解码、base64变种

# # ###########  ----------------【部分一：base64解码】 ----------------  ###########
    # # ###########  ----------------(方法一) ----------------  ###########
    # 观察发现base64编码后的数据不是标准的base64编码，存在变种，'-', '/'  ---  '_', '+'  将变种编码转换为标准编码
    # standard_base64_data = ret.replace('-', '/').replace('_', '+')
    # # 将标准的base64编码数据进行解码
    # decode_base64_data = base64.b64decode(standard_base64_data.encode())
    # ###########  ----------------(方法二) ----------------  ###########
    # 观察发现base64编码后的数据不是标准的base64编码，存在变种，'-', '/'  ---  '_', '+'  调用base64内部自带的标准化方法，将变种编码转换为标准编码并解码
    # altchars=b"-_" 参数为需要替换的变种编码
    standard_base64_data = base64.b64decode(ret.encode(), altchars=b"-_")

详见博客：https://www.cnblogs.com/dream-ze/p/17380722.html

(6)json模块，序列化与反序列化

dataDict = json.loads(decrypt_data.decode())

详见博客：https://www.cnblogs.com/dream-ze/p/17337544.html

(7)pad和unpad模块，补全数据长度，去除不必要的数据长度

# pad：模块(填充数据长度)
from Crypto.Util.Padding import pad, unpad

# 以16进制去除解密数据中可能会填充的数据
decrypt_data = unpad(decrypt_data, 16)

详见博客：

【一】分析网站

  • 网站主页

  • 打开开发者模式进行抓包分析

  • 一共抓到了三个包，逐个分析抓到的包里，我们可以发现
    • 第一个包的请求方式为post请求
    • 且载荷中带着一系列的数据

  • post请求所携带的数据data

i: apple
from: auto
to: 
domain: 0
dictResult: true
keyid: webfanyi
sign: c56f096d38dc6fbbf217842ddcd092ce
client: fanyideskweb
product: webfanyi
appVersion: 1.0.0
vendor: web
pointParam: client,mysticTime,product
mysticTime: 1683975605075
keyfrom: fanyi.web

  • 从上述分析以及再次抓包可以发现：

    • i ： 是我们输入的值
    • sign：每次都会发生变化
      • 可能是有加密算法进行加密返回
    • mysticTime：每次都会发生变化
      • 根据经验和验证知道这是时间错

  • 再观察返回的response数据可以发现是一堆字符

    • 通过观察可以发现，是base64编码返回的结果
    • 并且可以发现，其不是标准的base64编码的数据，而是进行了变种
Z21kD9ZK1ke6ugku2ccWu-MeDWh3z252xRTQv-wZ6jddVo3tJLe7gIXz4PyxGl73nSfLAADyElSjjvrYdCvEP4pfohVVEX1DxoI0yhm36ytQNvu-WLU94qULZQ72aml6JKK7ArS9fJXAcsG7ufBIE0gd6fbnhFcsGmdXspZe-8 whVFbRB_8Fc9JlMHh8DDXnskDhGfEscN_rfi-A-AHB3F9Vets82vIYpkGNaJOft_JA-m5cGEjo-UNRDDpkTz_NIAvo5PbATpkh7PSna2tHcE6Hou9GBtPLB67vjScwplB96-zqZKXJJEzU5HGF0oPDY_weAkXArzXyGLBPXFCnn_IWJDkGD4vqBQQAh2n52f48GD_cb-PSCT_8b-ESsKUI9NJa11XsdaUZxAc8TzrYnXwdcQbtl_kZGKhS6_rCtuNEBouA_lvM2CbS7TTtV2U4zVmJKpp-c6nt3yZePK3Av01GWn1pH_3sZbaPEx8DUjSbdp4i4iK-Mj4p2HPoph67DR7B9MFETYku_28SgP9xsKRRvFH4aHBHESWX4FDbwaU=

【二】逆向处理一

【1】包的分析处理

  • 首先，我们知道这个请求的网站是：

    https://dict.youdao.com/webtranslate

  • 返回的数据也是从这个网站返回的

  • 那么，所有的请求和加密操作一定会经过这个网站的调用

  • 以此为关键点，我们进行关键字搜索

    即在开发者模式搜索 webtranslate 关键字

  • 得到搜索结果，该结果就是调用此网址的一个函数位置
  • 我们进入到这个函数里面

  • 我们可以清楚地看到，在函数的内部存在我们请求的网址

  • 在该位置打上断点，重新发起请求

    • 如果被断住，则是我们想要的数据位置
    • 如果没被断住，则二次请求，查看其他位置

  • 在该位置被断住
  • 在控制台，输入各个函数或参数即可查看这个参数的结果
  • 通过分析这行代码
y = (e,t)=>Object(a["d"])("https://dict.youdao.com/webtranslate", Object(n["a"])(Object(n["a"])({}, e), O(t)), {
                headers: {
                    "Content-Type": "application/x-www-form-urlencoded"
                }
            })

  • 我们可以发现

    • "https://dict.youdao.com/webtranslate"

      • 这个参数是我们请求的网址

    • Object(n["a"])(Object(n["a"])({}, e), O(t))

      • 这个参数是一个函数调用，我们在控制台将这行代码进行打印查看结果

    • 我们发现其返回的结果正是我们刚才data数据的一部分

      {i: 'apple', from: 'auto', to: '', domain: '0', dictResult: true, …}
appVersion: "1.0.0"
client: "fanyideskweb"
dictResult: true
domain: "0"
from: "auto"
i: "apple"
keyfrom: "fanyi.web"
keyid: "webfanyi"
mysticTime: 1683977202745
pointParam: "client,mysticTime,product"
product: "webfanyi"
sign: "77ca196b587d32de00b9b249153ed901"
to: ""
vendor: "web"

【2】sign 值 和 t 值的逆向

  • 事实证明，我们没有选错位置

    • 我们也可以在控制台查看其他参数的结果

  • 通过分析发现 O 函数正是我们想要找的函数

  • 我们在 O 函数处打上断点，再次进行请求

  • 将鼠标悬浮在 O 函数上，进入到其调用函数里面

  • 进入到函数调用处

  • 我们可以看到，这里有一个t变量的声明

    • 且这个赋值函数正是时间函数，也就是时间戳

    • 这里我们将其用Python代码改写

      # 构建时间戳，参照逆向，可发现其时间戳为13位，所以要 *1000 。时间戳为整数类型，所以要int
    mysticTime = int(time.time() * 1000)

  • 我们向下看，则可以发现，sign 值正是由 h 函数生成

  • 同样的方法，我们进入到函数 h 中，分析其代码

  • 进入到 h 函数

  • 观察发现，需要两个参数，一个参数是 t ，另一个参数是 e

  • 这里我们进入到这个断点的函数，观察其生成值

  • 我们可以看到传入的值

    e : 1683977894302
t : fsdsogkndfokasodnaso

  • 再次发起请求，观察这两个值是否会发生变化

    • 发起请求后发现，e发生了变化正是时间戳
    • t没有发生变化，是定值

  • 分析这个js代码，h 函数的方法是什么

    v(`client=${d}&mysticTime=${e}&product=${u}&key=${t}`)

# 这段函数其实是ES6的语法，类似于Python中的
name = 'dream'
age = 22
ptint(f'你好，我叫{name}，我今年{}')

#而在ES6语法中相当于
consolo.log(`你好，我叫${name}，我今年${name}`)

  • 由此我们知道，其返回的正式一段文本字符串，我们在控制台打印这段函数调用，查看其结果

`client=${d}&mysticTime=${e}&product=${u}&key=${t}`

'client=fanyideskweb&mysticTime=1683977894302&product=webfanyi&key=fsdsogkndfokasodnaso'

  • 由此，我们用Python代码改写生成

    # 构建时间戳，参照逆向，可发现其时间戳为13位，所以要 *1000 。时间戳为整数类型，所以要int
    mysticTime = int(time.time() * 1000)
# 逆向可知sign值得构建中，这个参数为固定值
    # 固定值 key
    key = 'fsdsogkndfokasodnaso'
    # 构建 sign_before , 未加密之前的明文数据
    sign_before = f'client=fanyideskweb&mysticTime={mysticTime}&product=webfanyi&key={key}'

  • 有上面分析的 js 代码可知

  • h 函数的最终返回值为

    return v(`client=${d}&mysticTime=${e}&product=${u}&key=${t}`)

  • 那下一步，我们就要查看这个参数传进去的 v 函数的调用关系及返回结果

  • 同样的方法，我们悬浮进入 v 函数

  • 可以看到我们的 v 函数正是，其上面的代码部分

    function v(e) {
                return r.a.createHash("md5").update(e.toString()).digest("hex")
            }

  • 其中的参数e就是我们刚才生成的一串字符串

  • 分析这段代码，我们不难看出，这正是一个md5加密，并且返回的是其16进制的字符串

  • 我们这里用Python代码进行改写

    # 构建 md5对象
    alg = md5()
    # 将数据进行更新加密
    alg.update(sign_before.encode("utf-8"))
    # 获取加密数据中心的hex值
    sign = alg.hexdigest()

  • 至此我们的 sign 值和 t 值 就已经完全逆向出来了

  • 总结：

    • 首先要根据关键字，找到根源
    • 接着要根据这个关键字所在的函数找到其参数生成的位置以及参数的调用关系
    • 通过值得比较和调用关系的确定，进入到相应的调用函数中
    • 分析其代码生成的方式
    • 最后根据我们的知识对其进行逆向
    • 最后得到我们想要的结果

【3】sign 值 和 t 值的获取

def get_sign():
    '''
    word：需要传入的单词/句子
    # 逆向获取到时间戳和sign值
    :return: 返回获取到md5加密值
    '''
    # 构建session对象：携带cookie，防止cookie过期
    session = requests.Session()
    # 有道翻译对应的主网址
    main_url = 'https://dict.youdao.com/webtranslate'
    # headers 请求头
    headers = {
        'Accept': 'application/json, text/plain, */*',
        'Accept-Encoding': 'gzip, deflate, br',
        'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8',
        'Cache-Control': 'no-cache',
        'Connection': 'keep-alive',
        'Content-Length': '239',
        'Content-Type': 'application/x-www-form-urlencoded',
        'Host': 'dict.youdao.com',
        'Origin': 'https://fanyi.youdao.com',
        'Pragma': 'no-cache',
        'Referer': 'https://fanyi.youdao.com/',
        'Sec-Fetch-Dest': 'empty',
        'Sec-Fetch-Mode': 'cors',
        'Sec-Fetch-Site': 'same-site',
        'Cookie': 'OUTFOX_SEARCH_USER_ID=-2102182500@10.110.96.154; OUTFOX_SEARCH_USER_ID_NCOO=1723343714.3489342; YOUDAO_MOBILE_ACCESS_TYPE=0',
        'User-Agent': UserAgent().random,

    }
    # 构建sign值和时间戳
    # 构建时间戳，参照逆向，可发现其时间戳为13位，所以要 *1000 。时间戳为整数类型，所以要int
    mysticTime = int(time.time() * 1000)
    # 逆向可知sign值得构建中，这个参数为固定值
    # 固定值 key
    key = 'fsdsogkndfokasodnaso'
    # 构建 sign_before , 未加密之前的明文数据
    sign_before = f'client=fanyideskweb&mysticTime={mysticTime}&product=webfanyi&key={key}'
    # 进行编码，转为二进制数据
    sign_encode = sign_before.encode('utf-8')
    # 构建 md5对象
    alg = md5()
    # 将数据进行更新加密
    alg.update(sign_before.encode("utf-8"))
    # 获取加密数据中心的hex值
    sign = alg.hexdigest()
    # 构建 post 请求所需要的data参数
    word = input('请输入内容：')
    data = {
        'i': word,  # 传入的参数(单词/句子)
        'from': 'auto',
        'to': '',
        'dictResult': 'true',
        'keyid': 'webfanyi',
        'sign': sign,  # sign值 -- md5加密
        'client': 'fanyideskweb',
        'product': 'webfanyi',
        'appVersion': '1.0.0',
        'vendor': 'web',
        'pointParam': 'client,mysticTime,product',
        'mysticTime': mysticTime,  # --- 时间戳生成
        'keyfrom': 'fanyi.web',
    }
    # 发送请求，获取到加密的base64编码返回结果
    response = session.post(url=main_url, headers=headers, data=data)
    ret = response.text
    # 返回数据，等待下一步调用
    return ret

【二】逆向处理二

【1】承上启下

  • 从上面我们进行逆向，返回的结果就是我们响应中的base64变种编码数据
  • 接下来我们需要进行的操作就是将base64编码数据进行解码
  • 我们知道，我们的base64编码解码后的数据也不是明文数据，一定还存在加密算法
  • 所以我们接下来的就是进行解码和解密

【2】js 代码分析

  • 再次回到我们这个网址调用的地方，我们知道这个函数就是将我们的数据发送到这网站，并携带一定的请求头

  • 那我们只需要找到这个参数到底是被传入到那个函数进行调用，我们就知道了解密的位置

  • 通过观察这行js代码，我们分析得到

    y = (e,t)=>Object(a["d"])("https://dict.youdao.com/webtranslate", Object(n["a"])(Object(n["a"])({}, e), O(t)), {
                headers: {
                    "Content-Type": "application/x-www-form-urlencoded"
                }
            })

  • 最后调用的函数是

    Object(a["d"])

  • 同样的方法我们进入到这个函数

  • 分析这段 js 代码

    function l(e, t, o) {
            return new Promise((n,c)=>{
                a["a"].post(e, t, o).then(e=>{
                    n(e.data)
                }
                ).catch(e=>{
                    c(e)
                }
                )
            }
            )
        }

  • 我们可以知道

    • Promise 函数是 JS 函数中的一个回调函数

  • 通过断点分析这段函数中传入的参数 e t o 正是我们前面对应的，请求网址，data参数 ，和请求头
  • 我们再次分析我们请求网址所在的哪行代码
  • 我们需要明白的思路是
    • 我们需要调用一个函数，如果调用的这个函数的参数是下一个函数所生成的，那我们就要先执行第二个函数，将第二个函数的返回值，给第一个函数进行调用。
  • 由此，我们可以利用调用堆栈，调用堆栈就是函数之间逐级的调用关系，其中越靠上表示越被后调用
  • 那我们想知道是哪个函数想获得这个函数的调用值进行二次解析
  • 那我们只需要向上返回一层

  • 我们现在执行的是 y 函数 ，他的上一级调用函数就是 ln 函数 ，ln函数需要对 y 函数的结果进行运算。而我们 y 函数的调用结果我们已经解析出来了，正是我们得到的 base64编码数据

【3】逆向算法分析

  • 我们进入到 ln 函数的调用方法中

    an["a"].getTextTranslateResult(Object(nn["a"])(Object(nn["a"])({
                i: e.data.keyword,
                from: e.data.from,
                to: e.data.to
            }, n), {}, {
                dictResult: !0,
                keyid: "webfanyi"
            }), o).then(o=>{
                an["a"].cancelLastGpt();
                const n = an["a"].decodeData(o, sn["a"].state.text.decodeKey, sn["a"].state.text.decodeIv)
                  , a = n ? JSON.parse(n) : {};
                console.log("解密后的接口数据：", a),
                0 === a.code ? e.success && t(e.success)(a) : e.fail && t(e.fail)(a)
            }

  • 从 这个函数的名字我们不难理解，正是得到文本翻译结果的意思

  • 这也表明我们的思路是正确的

  • 再往下进行分析代码

  • 我们看到了很眼熟的代码

    const n = an["a"].decodeData(o, sn["a"].state.text.decodeKey, sn["a"].state.text.decodeIv)

  • 从这段代码，我们不难看出，正是进行了解密动作，同时从函数中的结构我们也不难发现 ， 非常 符合我们 AES 中的 CBC 加密模式。参数分别对应 (加密数据，key值，iv偏移量)

  • 接下来我们在该处进行断点

  • 从这个位置我们可以很明显的看到，传入进来的 O 值正是我们解密后的base64编码数据，
  • 这也更加印证了我们的思路是正确的，并没有跑偏

【4】逆向算法解密

  • 接下来我们的思路也很明确
  • 首先，我们要分析代码，找到我们加密所用到的key和iv
  • 然后进行base64编码的解码
  • 最后进行算法解密
  • 在断点位置，我们查看这两个值

  • 通过反复断点，重新进入，分析发现这两个值是定值，并不是随机变化的
decodeKey:"ydsecret://query/key/B*RGygVywfNBwpmBaZg*WT7SIOUP2T0C9WHMZN39j^DAdaZhAnxvGcCY6VYFwnHl"
decodeIv:"ydsecret://query/iv/C@lZe2YzHtZ2CYgaXKSVfsb7Y4QWHjITPPZ0nQp87fBeJ!Iv6v^6fvi2WN@bYpJ4"

  • 我们知道，我们AES算法中传入进去的是二进制数据，这是字符串，显然不是，那我们就需要知道这个数据是如何编程二进制的(要考虑到其他的加密方式，而不是简单的就将字符串变成二进制就完事了)

  • 我们进入到decode函数中查看其内部代码

  • 在这里我们看到了他完整的AES对象生成过程

  • 进入到该断点位置

  • 从这里我们可以看到，我们的 key 和 iv 传给了我们的 g 函数进行了加密
  • 我们进入到 g 函数

  • 在这里我们很明显的可以看到，他也是一个md5加密，但是这次取的是2进制的字符串
function g(e) {
                return r.a.createHash("md5").update(e).digest()
            }
  • 至此，我们的所有参数就都逆向生成完了，接下来需要做的就是Python改写代码
  • 小结：
    • 首先我们要明白各个函数之间的调用关系
    • 处理好各个函数之间的调用关系至关重要
    • 知道了各个函数之间的调用关系后，我们再逐层进行分析
    • 同时注意每一步出现的每个参数，每一个函数的意义，明白这些才能让我们的解密过程变得更快
    • 最后要有耐心
def decript_data(ret):
    # # ###########  ----------------【部分一：base64解码】 ----------------  ###########
    # # ###########  ----------------(方法一) ----------------  ###########
    # 观察发现base64编码后的数据不是标准的base64编码，存在变种，'-', '/'  ---  '_', '+'  将变种编码转换为标准编码
    # standard_base64_data = ret.replace('-', '/').replace('_', '+')
    # # 将标准的base64编码数据进行解码
    # decode_base64_data = base64.b64decode(standard_base64_data.encode())
    # ###########  ----------------(方法二) ----------------  ###########
    # 观察发现base64编码后的数据不是标准的base64编码，存在变种，'-', '/'  ---  '_', '+'  调用base64内部自带的标准化方法，将变种编码转换为标准编码并解码
    # altchars=b"-_" 参数为需要替换的变种编码
    standard_base64_data = base64.b64decode(ret.encode(), altchars=b"-_")

    # # ###########  ----------------【部分二：AES解密】 ----------------  ###########
    # (1) AES 解密 之 key / iv 参数的获取
    # 秘钥key : 二进制数据
    # 未加密之前的key
    key_before = "ydsecret://query/key/B*RGygVywfNBwpmBaZg*WT7SIOUP2T0C9WHMZN39j^DAdaZhAnxvGcCY6VYFwnHl"
    # 调用加密函数进行加密，得到加密后的key
    key = get_encrypt_key_iv(key_before)
    # 偏移量 IV : 二进制数据
    # 未加密之前的key
    iv_before = "ydsecret://query/iv/C@lZe2YzHtZ2CYgaXKSVfsb7Y4QWHjITPPZ0nQp87fBeJ!Iv6v^6fvi2WN@bYpJ4"
    # 调用加密函数进行加密，得到加密后的key
    iv = get_encrypt_key_iv(iv_before)
    # (2) AES 解密 之 数据的解密
    # 实例化 AES对象
    aes = AES.new(key=key, mode=AES.MODE_CBC, iv=iv)
    # 调用数据解密方法进行解密 # 参数为解码后的base64编码数据(二进制)
    decrypt_data = aes.decrypt(standard_base64_data)
    # 以16进制去除解密数据中可能会填充的数据
    decrypt_data = unpad(decrypt_data, 16)
    # 将获取到的数据进行 json 序列化 # 参数为解密数据进行转码后的数据
    dataDict = json.loads(decrypt_data.decode())
    # 提取翻译后的结果
    translate_result = [lineDict.get("tgt") for lineDict in dataDict.get("translateResult")[0]]
    # 如果是长句子，考虑到每一句话的拼接
    translate_result = "\n".join(translate_result)
    print(translate_result)

【三】代码完善

# requests:发送请求模块
import requests
# UA伪装之随机headers模块
from fake_useragent import UserAgent
# 时间模块
import time
# md5加密模块
from hashlib import md5
# AES 加密模块
from Crypto.Cipher import AES
# base64编码模块
import base64
# json 序列化模块
import json
# pad：模块(填充数据长度)
from Crypto.Util.Padding import pad, unpad


def get_sign():
    '''
    word：需要传入的单词/句子
    # 逆向获取到时间戳和sign值
    :return: 返回获取到md5加密值
    '''
    # 构建session对象：携带cookie，防止cookie过期
    session = requests.Session()
    # 有道翻译对应的主网址
    main_url = 'https://dict.youdao.com/webtranslate'
    # headers 请求头
    headers = {
        'Accept': 'application/json, text/plain, */*',
        'Accept-Encoding': 'gzip, deflate, br',
        'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8',
        'Cache-Control': 'no-cache',
        'Connection': 'keep-alive',
        'Content-Length': '239',
        'Content-Type': 'application/x-www-form-urlencoded',
        'Host': 'dict.youdao.com',
        'Origin': 'https://fanyi.youdao.com',
        'Pragma': 'no-cache',
        'Referer': 'https://fanyi.youdao.com/',
        'Sec-Fetch-Dest': 'empty',
        'Sec-Fetch-Mode': 'cors',
        'Sec-Fetch-Site': 'same-site',
        'Cookie': 'OUTFOX_SEARCH_USER_ID=-2102182500@10.110.96.154; OUTFOX_SEARCH_USER_ID_NCOO=1723343714.3489342; YOUDAO_MOBILE_ACCESS_TYPE=0',
        'User-Agent': UserAgent().random,

    }
    # 构建sign值和时间戳
    # 构建时间戳，参照逆向，可发现其时间戳为13位，所以要 *1000 。时间戳为整数类型，所以要int
    mysticTime = int(time.time() * 1000)
    # 逆向可知sign值得构建中，这个参数为固定值
    # 固定值 key
    key = 'fsdsogkndfokasodnaso'
    # 构建 sign_before , 未加密之前的明文数据
    sign_before = f'client=fanyideskweb&mysticTime={mysticTime}&product=webfanyi&key={key}'
    # 进行编码，转为二进制数据
    sign_encode = sign_before.encode('utf-8')
    # 构建 md5对象
    alg = md5()
    # 将数据进行更新加密
    alg.update(sign_before.encode("utf-8"))
    # 获取加密数据中心的hex值
    sign = alg.hexdigest()
    # 构建 post 请求所需要的data参数
    word = input('请输入内容：')
    data = {
        'i': word,  # 传入的参数(单词/句子)
        'from': 'auto',
        'to': '',
        'dictResult': 'true',
        'keyid': 'webfanyi',
        'sign': sign,  # sign值 -- md5加密
        'client': 'fanyideskweb',
        'product': 'webfanyi',
        'appVersion': '1.0.0',
        'vendor': 'web',
        'pointParam': 'client,mysticTime,product',
        'mysticTime': mysticTime,  # --- 时间戳生成
        'keyfrom': 'fanyi.web',
    }
    # 发送请求，获取到加密的base64编码返回结果
    response = session.post(url=main_url, headers=headers, data=data)
    ret = response.text
    # 返回数据，等待下一步调用
    return ret


def get_encrypt_key_iv(text):
    '''

    :param text: 传入的key / iv
    :return: 返回加密后的 key / iv
    '''
    # 构建md5对象
    m = md5()
    # 传入数据进行，md5加密数据更新
    m.update(text.encode())
    # 返回加密数据的digest值
    return m.digest()


def decript_data(ret):
    # # ###########  ----------------【部分一：base64解码】 ----------------  ###########
    # # ###########  ----------------(方法一) ----------------  ###########
    # 观察发现base64编码后的数据不是标准的base64编码，存在变种，'-', '/'  ---  '_', '+'  将变种编码转换为标准编码
    # standard_base64_data = ret.replace('-', '/').replace('_', '+')
    # # 将标准的base64编码数据进行解码
    # decode_base64_data = base64.b64decode(standard_base64_data.encode())
    # ###########  ----------------(方法二) ----------------  ###########
    # 观察发现base64编码后的数据不是标准的base64编码，存在变种，'-', '/'  ---  '_', '+'  调用base64内部自带的标准化方法，将变种编码转换为标准编码并解码
    # altchars=b"-_" 参数为需要替换的变种编码
    standard_base64_data = base64.b64decode(ret.encode(), altchars=b"-_")

    # # ###########  ----------------【部分二：AES解密】 ----------------  ###########
    # (1) AES 解密 之 key / iv 参数的获取
    # 秘钥key : 二进制数据
    # 未加密之前的key
    key_before = "ydsecret://query/key/B*RGygVywfNBwpmBaZg*WT7SIOUP2T0C9WHMZN39j^DAdaZhAnxvGcCY6VYFwnHl"
    # 调用加密函数进行加密，得到加密后的key
    key = get_encrypt_key_iv(key_before)
    # 偏移量 IV : 二进制数据
    # 未加密之前的key
    iv_before = "ydsecret://query/iv/C@lZe2YzHtZ2CYgaXKSVfsb7Y4QWHjITPPZ0nQp87fBeJ!Iv6v^6fvi2WN@bYpJ4"
    # 调用加密函数进行加密，得到加密后的key
    iv = get_encrypt_key_iv(iv_before)
    # (2) AES 解密 之 数据的解密
    # 实例化 AES对象
    aes = AES.new(key=key, mode=AES.MODE_CBC, iv=iv)
    # 调用数据解密方法进行解密 # 参数为解码后的base64编码数据(二进制)
    decrypt_data = aes.decrypt(standard_base64_data)
    # 以16进制去除解密数据中可能会填充的数据
    decrypt_data = unpad(decrypt_data, 16)
    # 将获取到的数据进行 json 序列化 # 参数为解密数据进行转码后的数据
    dataDict = json.loads(decrypt_data.decode())
    # 提取翻译后的结果
    translate_result = [lineDict.get("tgt") for lineDict in dataDict.get("translateResult")[0]]
    # 如果是长句子，考虑到每一句话的拼接
    translate_result = "\n".join(translate_result)
    print(translate_result)


def choose_y_n(choose_result):
    if choose_result == 'y':
        use()
    else:
        print('感谢您的使用！祝您生活愉快！')


def use():
    ret = get_sign()
    decript_data(ret)
    choose_result = input('继续使用请输入y:::')
    choose_y_n(choose_result)


if __name__ == '__main__':
    use()
Chimengmeng
关注
  • 6
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
有道翻译爬虫
heima201907的博客
01-03 272
有道翻译采用js加密的方式，阻碍我们使用代码进行翻译。分析发送请求时提交的Form Data，数据中的salt（盐）和sign（签名）是常见的js加密方式，salt是一个很长的随机串，是防止程序员使用字典反推（{明文：密文}--{密文：明文}）的形式破解加密方式（增加了原字符串的数量，使破解难以完成）。sign也是一种js加密方式。 sign的加密方式使用了md5加密算法，即消息摘...
Python爬虫实现简单的爬取有道翻译功能示例
09-20
主要介绍了Python爬虫实现简单的爬取有道翻译功能,结合实例形式分析了Python基于urllib库实现的爬虫爬取有道翻译相关定义与数据交互功能操作技巧,需要的朋友可以参考下
爬虫—有道翻译
weixin_43726170的博客
06-21 1049
’’’ 目标：爬取有道翻译数据 作用：在本地进行翻译，并将所用单词与翻译保存于本地文件夹 推荐：基础学习者 ‘’' import requests,time,hashlib #导入所需模块，hashlib为md5加密所需模块 def youdao(susu): #data上传需要修改的数据 salt = int(time.time()*10000) ts = salt//10 value =“fa...
爬虫有道翻译
hao_1314_wen的博客
09-04 383
import urllib.request import urllib.parse req = urllib.request.Request('http://fanyi.youdao.com/translate_o?smartresult=dict&smartresult=rule') data = {} data['action'] = 'FY_BY_CLICKBUTTION' da...
爬虫-有道翻译
一岁一骷髅的博客
09-24 135
import requests,time,hashlib def getMd5(value): md5 = hashlib.md5() md5.update(value.encode()) return md5.hexdigest() def request_html(url,word): salt_p = time.time() salt = str(...
爬虫 有道翻译
weixin_45576204的博客
09-09 973
```python import hashlib import time import random import requests headers={ 'Cookie': 'OUTFOX_SEARCH_USER_ID=-2006006658@10.108.160.17; OUTFOX_SEARCH_USER_ID_NCOO=637053778.397833; UM_distinctid=174569dbd3e165-064df79033d73e-f7b1332-144000-174569dbd.
有道翻译Python爬虫（sign算法）
最新发布
03-17
总的来说，通过理解和应用这个项目中的Python sign加密算法，开发者可以更有效地构建有道翻译API的爬虫，从而获取并处理大量的翻译数据，为数据分析、文本处理或其他自然语言处理任务提供支持。同时，这也是一种学习...
有道翻译_python翻译_python爬虫_
09-30
标题中的“有道翻译_python翻译_python爬虫_”表明我们将探讨如何使用Python编程语言来实现一个基于有道翻译API的翻译工具。这个工具可能利用网络爬虫技术来抓取或发送请求到有道翻译的服务器，获取翻译结果。 在...
Python语言之爬虫之伪装浏览器用有道翻译
08-01
Python代码，伪装成浏览器去利用有道的资源，然后做成的翻译器，可以连续输入词条翻译
用python3 urllib破解有道翻译反爬虫机制详解
09-18
主要介绍了python破解网易反爬虫机制详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
爬虫之有道翻译
Never-Giveup的博客
05-19 7031
有道翻译采用js加密的方式，阻碍我们使用代码进行翻译。所以本文手把手教你破解有道js加密方式1. 首先不考虑js加密情况1.1 第一步打开有道翻译首页，简单输入一个单词，在检查->Network中分析请求响应1.2 查看请求的url地址和请求方式，请求体1.3 代码实现，加上请求头，请求体from urllib import request,parse def youdao(): ...
使用Python实现基于API的网易有道翻译功能
kkill_youokk_的博客
12-15 737
使用Python实现基于API的网易有道翻译功能 1.打开有道翻译页面 2.在浏览器页面左键-检查-Network 3.进行翻译的操作，右键下面红色部分，Copy link address 粘贴出来为http://fanyi.youdao.com/translate_o?smartresult=dict&smartresult=rule 因为有道做了加密处理，所以要去掉_o 使用这个API： http://fanyi.youdao.com/translate?smartresult=dict&amp
Python简单爬虫有道翻译，有GUI窗口，用到request库和tkinter
FANtastic_Y的博客
10-31 384
from tkinter import * import requests root=Tk() Label(root,text="待翻译").grid(row=0,column=0) Label(root,text="已翻译").grid(row=1,column=0) v1=StringVar() v2=StringVar() e1=Entry(root,textvariable=v1,bac...
Python爬虫有道词典翻译的代码
Ljt101222的博客
07-21 844
import urllib.request import urllib.parse import json import time while(1): content = input("请输入你要翻译的内容(按q键退出)：") if content=='q': break val="http://fanyi.youdao.com/translate?sma...
基本爬虫爬取有道翻译
hello world 的博客
05-08 1121
对于我这个爬虫新手，今天要记录一篇在学习爬虫中的一个小实例，尝试用爬虫爬取有道翻译 在写爬虫之前，我们先要打开有道翻译，看一看在翻译的过程中我们的电脑发出了怎样的请求，是对于那个网址发出的，以及电脑收到的response在那个地方，我们先打开有道翻译，打开控制台进行抓包，看到如下画面 我们看到一共发送了五个请求，而我们所需要的翻译结果在第一个请求中，我们要求翻译的内容是“人生苦短，我用python”，在这个请求的preview中，可以看到翻译的结果。 那这个请求对应的url就是写爬虫所需要的url，找到这
python爬取有道翻译的代码_有道翻译的爬取
weixin_39968861的博客
11-25 178
有道翻译的爬取Python作为爬虫的强大人尽皆知，一个人不使用python爬取些什么，那么他的Python生涯一定是不完整的，这里简单写一下用Python爬取有道翻译的教程。关于有道翻译的爬取网上链接很多，这里爬取的时候发现有道反爬虫机制有一个小bug，直接绕过就可以了。话不多说，现在开始。一 服务器数据的获取右击检查、点击network在翻译框输入任意字符后点击headers将每一项挨个点开，寻...
有道翻译（源代码）
weixin_30457881的博客
11-05 506
import urllib.requestimport urllib.parseimport jsonimport timewhile True: content = input("请输入要翻译的内容（输入q退出程序）：") if content == 'q': break # F12看翻译的时候fanyi.youdao.com的network的url和form...
有道精品课python-网易词典在线翻译
weixin_37988176的博客
11-01 757
文 | 八月哥近期研究调查了超过50+教育类公众号，从中筛选了10家较为优质的，他们有个共同的特点，全部都有APP，而且用户最少是以百万为计，这样的流量大牛，他们的公众号究竟做的怎么样呢？感兴趣的朋友可以看下。▼第一维度：基本信息1、命名这10家平台，从名字来说，基本是和APP名字吻合的，比如学霸君、小伴龙、宝宝巴士、英语流利说等有同名APP，另外，哈哈儿童网 的app叫哈哈儿童，但是 小思成长日...
破解有道翻译
Taneost的博客
09-23 2744
破解有道翻译 1、先获取到翻译的接口（http://fanyi.youdao.com/translate_o?smartresult=dict&smartresult=rule） 2、想要翻译单词，肯定要提交表单，查看Network中From-Data所提交的内容 3、分析提交内容发现，i是你所提交的内容，salt是时间戳，ts是时间戳少一位，sign是通过加密算法加密，通过页面返回的JS...
python爬虫有道翻译
09-15
在给定的引用中，代码示例展示了一个简单的Python爬虫有道翻译程序。该程序使用requests库发送POST请求，将待翻译的内容作为请求参数发送给有道翻译网站。然后，通过解析返回的JSON数据，获取翻译结果并将其打印出来...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值