jmeter对请求参数的签名处理

最新推荐文章于 2024-02-23 19:11:13 发布
最新推荐文章于 2024-02-23 19:11:13 发布
阅读量5.5k 收藏 6
点赞数 2
分类专栏： Testing 文章标签： 压力测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38317509/article/details/79163127
版权

1.首先在本地写好签名的算法，本文采用RSA签名。
public final class Base64 {

static private final int     BASELENGTH           = 128;
static private final int     LOOKUPLENGTH         = 64;
static private final int     TWENTYFOURBITGROUP   = 24;
static private final int     EIGHTBIT             = 8;
static private final int     SIXTEENBIT           = 16;
static private final int     FOURBYTE             = 4;
static private final int     SIGN                 = -128;
static private final char    PAD                  = '=';
static private final boolean fDebug               = false;
static final private byte[]  base64Alphabet       = new byte[BASELENGTH];
static final private char[]  lookUpBase64Alphabet = new char[LOOKUPLENGTH];

static {
    for (int i = 0; i < BASELENGTH; ++i) {
        base64Alphabet[i] = -1;
    }
    for (int i = 'Z'; i >= 'A'; i--) {
        base64Alphabet[i] = (byte) (i - 'A');
    }
    for (int i = 'z'; i >= 'a'; i--) {
        base64Alphabet[i] = (byte) (i - 'a' + 26);
    }

    for (int i = '9'; i >= '0'; i--) {
        base64Alphabet[i] = (byte) (i - '0' + 52);
    }

    base64Alphabet['+'] = 62;
    base64Alphabet['/'] = 63;

    for (int i = 0; i <= 25; i++) {
        lookUpBase64Alphabet[i] = (char) ('A' + i);
    }

    for (int i = 26, j = 0; i <= 51; i++, j++) {
        lookUpBase64Alphabet[i] = (char) ('a' + j);
    }

    for (int i = 52, j = 0; i <= 61; i++, j++) {
        lookUpBase64Alphabet[i] = (char) ('0' + j);
    }
    lookUpBase64Alphabet[62] = (char) '+';
    lookUpBase64Alphabet[63] = (char) '/';

}

private static boolean isWhiteSpace(char octect) {
    return (octect == 0x20 || octect == 0xd || octect == 0xa || octect == 0x9);
}

private static boolean isPad(char octect) {
    return (octect == PAD);
}

private static boolean isData(char octect) {
    return (octect < BASELENGTH && base64Alphabet[octect] != -1);
}

/**
 * Encodes hex octects into Base64
 *
 * @param binaryData Array containing binaryData
 * @return Encoded Base64 array
 */
public static String encode(byte[] binaryData) {

    if (binaryData == null) {
        return null;
    }

    int lengthDataBits = binaryData.length * EIGHTBIT;
    if (lengthDataBits == 0) {
        return "";
    }

    int fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP;
    int numberTriplets = lengthDataBits / TWENTYFOURBITGROUP;
    int numberQuartet = fewerThan24bits != 0 ? numberTriplets + 1 : numberTriplets;
    char encodedData[] = null;

    encodedData = new char[numberQuartet * 4];

    byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0;

    int encodedIndex = 0;
    int dataIndex = 0;
    if (fDebug) {
        System.out.println("number of triplets = " + numberTriplets);
    }

    for (int i = 0; i < numberTriplets; i++) {
        b1 = binaryData[dataIndex++];
        b2 = binaryData[dataIndex++];
        b3 = binaryData[dataIndex++];

        if (fDebug) {
            System.out.println("b1= " + b1 + ", b2= " + b2 + ", b3= " + b3);
        }

        l = (byte) (b2 & 0x0f);
        k = (byte) (b1 & 0x03);

        byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
        byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);
        byte val3 = ((b3 & SIGN) == 0) ? (byte) (b3 >> 6) : (byte) ((b3) >> 6 ^ 0xfc);

        if (fDebug) {
            System.out.println("val2 = " + val2);
            System.out.println("k4   = " + (k << 4));
            System.out.println("vak  = " + (val2 | (k << 4)));
        }

        encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
        encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];
        encodedData[encodedIndex++] = lookUpBase64Alphabet[(l << 2) | val3];
        encodedData[encodedIndex++] = lookUpBase64Alphabet[b3 & 0x3f];
    }

    // form integral number of 6-bit groups
    if (fewerThan24bits == EIGHTBIT) {
        b1 = binaryData[dataIndex];
        k = (byte) (b1 & 0x03);
        if (fDebug) {
            System.out.println("b1=" + b1);
            System.out.println("b1<<2 = " + (b1 >> 2));
        }
        byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
        encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
        encodedData[encodedIndex++] = lookUpBase64Alphabet[k << 4];
        encodedData[encodedIndex++] = PAD;
        encodedData[encodedIndex++] = PAD;
    } else if (fewerThan24bits == SIXTEENBIT) {
        b1 = binaryData[dataIndex];
        b2 = binaryData[dataIndex + 1];
        l = (byte) (b2 & 0x0f);
        k = (byte) (b1 & 0x03);

        byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
        byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);

        encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
        encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];
        encodedData[encodedIndex++] = lookUpBase64Alphabet[l << 2];
        encodedData[encodedIndex++] = PAD;
    }

    return new String(encodedData);
}

/**
 * Decodes Base64 data into octects
 *
 * @param encoded string containing Base64 data
 * @return Array containind decoded data.
 */
public static byte[] decode(String encoded) {

    if (encoded == null) {
        return null;
    }

    char[] base64Data = encoded.toCharArray();
    // remove white spaces
    int len = removeWhiteSpace(base64Data);

    if (len % FOURBYTE != 0) {
        return null;//should be divisible by four
    }

    int numberQuadruple = (len / FOURBYTE);

    if (numberQuadruple == 0) {
        return new byte[0];
    }

    byte decodedData[] = null;
    byte b1 = 0, b2 = 0, b3 = 0, b4 = 0;
    char d1 = 0, d2 = 0, d3 = 0, d4 = 0;

    int i = 0;
    int encodedIndex = 0;
    int dataIndex = 0;
    decodedData = new byte[(numberQuadruple) * 3];

    for (; i < numberQuadruple - 1; i++) {

        if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))
            || !isData((d3 = base64Data[dataIndex++]))
            || !isData((d4 = base64Data[dataIndex++]))) {
            return null;
        }//if found "no data" just return null

        b1 = base64Alphabet[d1];
        b2 = base64Alphabet[d2];
        b3 = base64Alphabet[d3];
        b4 = base64Alphabet[d4];

        decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
        decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
        decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);
    }

    if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))) {
        return null;//if found "no data" just return null
    }

    b1 = base64Alphabet[d1];
    b2 = base64Alphabet[d2];

    d3 = base64Data[dataIndex++];
    d4 = base64Data[dataIndex++];
    if (!isData((d3)) || !isData((d4))) {//Check if they are PAD characters
        if (isPad(d3) && isPad(d4)) {
            if ((b2 & 0xf) != 0)//last 4 bits should be zero
            {
                return null;
            }
            byte[] tmp = new byte[i * 3 + 1];
            System.arraycopy(decodedData, 0, tmp, 0, i * 3);
            tmp[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);
            return tmp;
        } else if (!isPad(d3) && isPad(d4)) {
            b3 = base64Alphabet[d3];
            if ((b3 & 0x3) != 0)//last 2 bits should be zero
            {
                return null;
            }
            byte[] tmp = new byte[i * 3 + 2];
            System.arraycopy(decodedData, 0, tmp, 0, i * 3);
            tmp[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
            tmp[encodedIndex] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
            return tmp;
        } else {
            return null;
        }
    } else { //No PAD e.g 3cQl
        b3 = base64Alphabet[d3];
        b4 = base64Alphabet[d4];
        decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
        decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
        decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);

    }

    return decodedData;
}

/**
 * remove WhiteSpace from MIME containing encoded Base64 data.
 *
 * @param data  the byte array of base64 data (with WS)
 * @return      the new length
 */
private static int removeWhiteSpace(char[] data) {
    if (data == null) {
        return 0;
    }

    // count characters that's not whitespace
    int newSize = 0;
    int len = data.length;
    for (int i = 0; i < len; i++) {
        if (!isWhiteSpace(data[i])) {
            data[newSize++] = data[i];
        }
    }
    return newSize;
}

}
　　
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

public class RSA
{
private static final String SIGN_ALGORITHMS = “MD5WithRSA”;

/**
* RSA验签名检查
* @param content 待签名数据
* @param sign 签名值
* @param ali_public_key  爱贝公钥
* @param input_charset 编码格式
* @return 布尔值
*/
public static boolean verify(String content, String sign, String iapp_pub_key, String input_charset)
{
    try
    {
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        byte[] encodedKey = Base64.decode(iapp_pub_key);
        PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));


        java.security.Signature signature = java.security.Signature
        .getInstance(SIGN_ALGORITHMS);

        signature.initVerify(pubKey);
        signature.update( content.getBytes(input_charset) );
        return signature.verify( Base64.decode(sign) );

    }
    catch (Exception e)
    {
        e.printStackTrace();
    }

    return false;
}

/**
* RSA签名
* @param content 待签名数据
* @param privateKey 商户私钥
* @param input_charset 编码格式
* @return 签名值
*/
public static String sign(String content, String privateKey, String input_charset)
{
    try
    {
        PKCS8EncodedKeySpec priPKCS8    = new PKCS8EncodedKeySpec( Base64.decode(privateKey) );
        KeyFactory keyf                 = KeyFactory.getInstance("RSA");
        PrivateKey priKey               = keyf.generatePrivate(priPKCS8);

        java.security.Signature signature = java.security.Signature
            .getInstance(SIGN_ALGORITHMS);

        signature.initSign(priKey);
        signature.update( content.getBytes(input_charset) );

        byte[] signed = signature.sign();

        return Base64.encode(signed);
    }
    catch (Exception e)
    {
        e.printStackTrace();
    }

    return null;
}

}
　　
package com.zyzxpay.sign;

public class SignHelper
{
// 字符编码格式 ，目前支持 utf-8
public static String input_charset = “utf-8”;

public static boolean verify(String content, String sign, String pubKey)
{
    // 目前版本，只支持RSA
    return RSA.verify(content, sign, pubKey, input_charset);
}

public static String sign(String content, String privateKey)
{
    return RSA.sign(content, privateKey, input_charset);
}

}

2.将以上3个类生成jar包，在jmeter的计划中引入。
这里写图片描述
3.添加http请求，并在该请求下添加用户变量，存储我们用来签名的数据，也可用上个接口的响应结果存储起来作为要签名的数据。
这里写图片描述
在http请求的参数中，引用变量${content}

4.在http请求下添加BeanShell PreProcessor，处理签名的参数，并存在sign中供http请求调用，先导入签名类：import com.paydela.*;
这里写图片描述

import com.paydela.*;

System.out.println(vars.get(“content”));
System.out.println(vars.get(“aaa”));
String content =vars.get(“content”);
String result = SignHelper.sign(content, “”);
System.out.println(result);
vars.put(“sign”,result);

5.在http请求中用${sign}来引用签名后的数据

6.在http请求下添加BeanShell PostProcessor，用来处理响应结果

import java.io.UnsupportedEncodingException;

System.out.println(prev.getResponseCode());
String str = prev.getResponseDataAsString();
/*
String result = ${__urldecode(str)};
System.out.println(“————”+result);
*/
String result = “”;
try {
result = java.net.URLDecoder.decode(str, “UTF-8”);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
System.out.println(“result:”+result);

vars.put(“result”,result);

7.添加结果树、debug等，运行后便可以看到签名的请求数据以及响应结果
这里写图片描述

小肃先生
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
软件测试技能，JMeter压力测试教程，请求头部自动签名带上X-sign参数（二十二）
02-11 1538
目录：导读一、前言二、实现方式三、添加 BeanShell 预处理程序 一、前言 接口请求 body 带有 sign 签名参数，sign 签名是根据请求 body 除去 sign 本身参数后，拼接请求参数最后 md5 加密生成的 前面一篇是把 sign 前面参数放到请求的 body 里面，这篇继续讲把签名参数放到请求头部的情况 二、实现方式 http 请求需要进行签名校验 X-Sign，放到请求头部 Content-Type: application/json; charset=UTF-8 X-Sign:
软件测试技能，JMeter压力测试教程，请求body自动签名带上sign参数（二十一）
02-10 1720
目录：导读一、前言二、sign签名三、BeanShell 预处理程序四、查看结果树 一、前言 接口请求body带有sign签名参数，sign签名是根据请求body除去sign本身参数后，拼接请求参数最后md5加密生成的 使用 jmeter 测试接口，我们希望在请求之前修改 post body 里面的 sign 参数的值为签名的值 二、sign签名 签名一篇的实现方式是添加 BeanShell 预处理程序，生成sign值，设置一个变量，然后在请求的body里面引用变量 可以参考前面这篇：https://blo
使用Postman和JMeter进行signature签名
最新发布
jj2772367224的博客
02-23 1727
​ 有些接口的请求会带上sign（签名）进行请求，各接口对sign的签名内容、方式可能不一样，但一般都是从接口的入参中选择部分内容组成一个字符串，然后再进行签名操作, 将结果赋值给sign;完整规范的接口文档都会有sign的算法描述。这里通过Postman的Pre-request Script以及JMeter的BeanShell前置处理器进行接口签名的处理。
Jmeter 接口测试中的签名处理
Summer_CSND的博客
12-05 1752
Jmeter 接口测试中的签名处理
jmeter获取加密签名方法
qyykaola的博客
05-16 772
第一种方法： ${__time(/1000,)} 直接通过jmeter自带函数获取时间戳前十位，方便快捷，但是不方便计算签名 第二种方法：Beanshell获取，这种既可以获取时间戳又可以计算签名 import org.apache.commons.codec.digest.DigestUtils; import java.util.Date; //没有第三方jar包，请放心 import //获取时间戳前十位 long timestamp = new Date().getTime()..
jmeter 使用beanshell 调用 java 代码解决请求签名相关问题
淡漠Vip的博客
11-01 4180
jemeter 简单引用java jar包例子
JMeter beanShell修改http请求参数
11-29
JMeter beanShell修改http请求参数，尝试对http进行修改。
JMETER HTTP 请求
04-24
JMETER 中间sample 是真正干活的家伙，性能测试过程中间通过sample 中间的组件向服务器发送请求，同时，从服务器端返回响应。由于sample 中间组件较多，不会对所有的sample 中间的所有组件进行讲解，只会讲解比较...
Jmeter JDBC请求常见问题解决方案
08-19
主要介绍了Jmeter JDBC请求常见问题解决方案,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Jmeter工具对验证码的处理方法
11-02
本文档里面详细描述了利用Jmeter工具怎样处理登录验证码的方法和步骤
Jmeter命令行执行脚本如何设置动态参数
08-18
主要介绍了Jmeter命令行执行脚本如何设置动态参数,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
jmeter压测学习34-签名sign(BeanShell 预处理程序)
qq_27371025的博客
06-19 1408
前言 一般公司对外的接口都会用到sign签名，对不同的客户提供不同的apikey ,这样可以提高接口请求的安全性，避免被人抓包后乱请求。 之前讲过用python代码实现sign签名，这次介绍jmeter上如何实现sign签名，思路都是差不多的。 sign签名 签名参数sign生成的方法 第1步: 将所有参数（注意是所有参数），除去sign本身，以及值是空的参数，按参数名字母升序排序。 第2步: 然后把排序后的参数按参数1值1参数2值2…参数n值n（这里的参数和值必须是传输参数的原始值，不能是经过处理的，如
jmeter 接口测试 签名_[接口测试]JMeter中的字符串加密处理
weixin_39835965的博客
01-17 605
接口测试过程中，经常会遇到带Token或签名等的请求。这里所谓的Token或签名，是一串加密后的字符串，作为请求体或请求头或URL中的一个参数放在Request中。一 采用MD5算法MD5是一种常见的消息摘要算法，采用加密函数对原始消息进行处理，如果消息在途中改变了，则接收者通过对收到消息的新产生的摘要与原摘要比较，就可知道消息是否被改变了。因此消息摘要保证了消息的完整性。JMeter内置__MD...
使用Jmeter对SHA1加密接口进行性能测试
08-19 712
1、首先了解原理，就是需要对如下三个参数进行SHA1加密，(AppSecret + Nonce + CurTime)，三个参数拼接的字符串，进行SHA1哈希计算，转化成16进制字符(String，小写) 2、CheckSum有效期：出于安全性考虑，每个checkSum的有效期为5分钟(用CurTime计算)，建议每次请求都生成新的checkSum，同时请确认发起请求的服务器是与标准时间同步的，比如有NTP服务。 ...
Jmeter测试签名接口获得sign串
热门推荐
潜行100的博客
01-12 1万+
参数签名可以保证开发的者的信息被冒用后，信息不会被泄露和受损。原因在于接入者和提供者都会对每一次的接口访问进行签名和验证。 签名sign的方式是目前比较常用的方式。 举例（根据项目具体情况而定，这里只是一个例子，参数排列和内容由项目框架决定，自行同开发沟通）： 第1步：接入者把需求访问的接口的所有必要的参数信息（注意是所有参数），除去sign本身，以及值是空的参数，按参数名字母顺序排序。
jmeter 接口测试 签名_JMeter处理接口签名(sign)
weixin_40008870的博客
01-17 2657
先贴脚本, 大神请直取新建线程组 → http取样器 → 前置处理器 → bean shell 预处理程序import org.apache.commons.codec.digest.DigestUtils;import java.util.Date;//没有第三方jar包，请放心 importDate date = new Date();//将时间戳截取到秒的量级(长度共10位)，大神可以考虑地...
http接口请求参数签名工具类的实现和测试代码
动感超人的专栏
09-14 4777
http接口请求参数签名工具类的实现和测试代码，包括测试例子，在接口开发中可以直接使用和参考，保证数据不对篡改的一种机制。
jmeter http请求参数是raw
05-19
需要注意的是，使用Raw参数类型时，JMeter并不会对请求体中的数据进行编码或转义，而是直接发送原始文本数据。因此需要确保请求体中的数据符合对应的格式要求，并且不包含特殊字符或控制字符等不允许出现的内容。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值