abekthink’s blog

RSA Encryption with Python and Java and Swift

2018-07-01T19:28:50+08:00

我们经常会遇到这样的需求：需要各端（Server/Android/iOS/Web等）通信时进行加密，防止请求被拦截或者篡改。

本文以实际项目中的真实加密场景说明下，如何对请求进行加密签名，防止数据被篡改。

需求

客户端（Android/iOS/Web等）向服务端发送请求，需要对请求中的参数进行加密签名。

设计

这里采用了通用的RSA加密签名验证算法，整个流程主要包括如下两部分：

客户端：参数处理，生成签名（sign），向服务端发送带sign的请求。
服务端：参数处理，用请求中的sign进行签名验证，如果不通过则返回参数验证失败；否则，进行后续处理，并将结果返回。

这里为了方便说明，这里举一个简单例子来说明客户端和服务端的处理流程：

客户端

假设，客户端请求中包含name、age和career三个参数，为了防止数据被篡改，我们将三个参数进行标准化的字符串排序。比如请求中的参数为：

{
    "namge": "张三",
    "age": 25,
    "career": "后端研发工程师"
}

则将该结构体按照key排序后，生成相应字符串format_str，比如：

age=25&career=后端研发工程师&namge=张三

然后，在将以上字符串format_str进行RSA签名，生成相应的sign，比如：

mtttq1BIW2ENAc16sZspwGOdfh+Qu7idr8...

最终客户端，向后端请求的参数是：

{
    "namge": "张三",
    "age": 25,
    "career": "后端研发工程师",
    "sign": "mtttq1BIW2ENAc16sZspwGOdfh+Qu7idr8..."
}

服务端

服务端在接到请求后，如客户端一样生成相应的format_str（需要先将sign提取出来）：

age=25&career=后端研发工程师&namge=张三

然后，通过RSA验证算法，将format_str和请求中的sign参数进行验证，如果失败则是参数或者签名有误，服务端以此来判断参数是否有被篡改。

各语言加密方式

下面分别从Python、Java、Swift等主流语言，来分别说明各方是怎么加密和解密的。

说明

下面各语言代码示例都会用到公钥和私钥，这里简单声明下：

public_key = '''-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3...
-----END PUBLIC KEY-----
'''

private_key = '''-----BEGIN RSA PRIVATE KEY-----
MIICXAIBAAKBgQDu...
-----END RSA PRIVATE KEY-----
'''

备注：

基于刚刚假设的场景，客户端需要保存私钥，以便进行签名；服务端需要保存公钥，以便进行验证。
这里使用了PKCS1 PSS作为signature算法，SHA256为hash算法。
另外，这里采用了加盐方式，咱设salt_len为11。

Python

首先需要安装加密包依赖，使用pip install pycrypto命令即可。

导入依赖：

from Crypto.Signature import PKCS1_PSS
from Crypto.Hash import SHA256
from base64 import b64decode, b64encode

加密函数，用于生成sign：

def sign_with_pkcs1_pss(format_str):
    signer = PKCS1_PSS.new(private_key, saltLen=11)
    h = SHA256.new()
    h.update(format_str.encode())
    sign = b64encode(signer.sign(h)).decode("utf-8", "strict")
    reutrn sign

验证函数，用于验证参数是否正确：

def verify_with_pkcs1_pss(format_str, sign)
    verifier = PKCS1_PSS.new(public_key, saltLen=11)

    h = SHA256.new()
    h.update(format_str.encode())
    signature = b64decode(sign)
    if verifier.verify(h, signature):
        return True
    else:
        return False

备注：这里以python3环境举例。

Java(Android)

Java代码，用下面这段代码即可：

package io.github.abekthink.rsa.demo;

import android.util.Base64;

import java.io.File;
import java.io.InputStreamReader;
import java.io.ByteArrayInputStream;
import java.security.AlgorithmParameters;
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Security;
import java.security.Signature;
import java.security.spec.MGF1ParameterSpec;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.PSSParameterSpec;
import java.security.spec.X509EncodedKeySpec;

import org.bouncycastle.util.io.pem.PemObject;
import org.bouncycastle.util.io.pem.PemReader;
import org.bouncycastle.util.io.pem.PemWriter;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

import org.apache.commons.codec.binary.Base64;

public class RSAAlgorithm {

    static {
        Security.addProvider(new BouncyCastleProvider());
    }

    public static PrivateKey getPrivateKey(String pemFormatKey) throws Exception {
        KeyFactory factory = KeyFactory.getInstance("RSA", "BC");

        PemReader pemReader = new PemReader(new InputStreamReader(
                new ByteArrayInputStream(pemFormatKey.getBytes("UTF-8"))));
        pemObject = pemReader.readPemObject();
        byte[] content = pemObject.getContent();
        PKCS8EncodedKeySpec privKeySpec = new PKCS8EncodedKeySpec(content);
        return factory.generatePrivate(privKeySpec);
    }


    public static String signPSS(String plainText, PrivateKey privateKey) throws Exception {
        Signature privateSignature = Signature.getInstance("SHA256withRSA/PSS");
        AlgorithmParameters pss = privateSignature.getParameters();
        PSSParameterSpec spec = new PSSParameterSpec("SHA-256", "MGF1",
                new MGF1ParameterSpec("SHA-256"), 11, 1);
        privateSignature.setParameter(spec);
        privateSignature.initSign(privateKey);
        privateSignature.update(plainText.getBytes(UTF_8));

        byte[] signature = privateSignature.sign();
        Base64.encode(signature,Base64.DEFAULT);
        return Base64.encodeBase64String(signature);
    }

    public static String generateSign(String formatStr) throws Exception {
        String prikey = "-----BEGIN RSA PRIVATE KEY-----\n" + "..." + "-----END RSA PRIVATE KEY-----";
        PrivateKey privateKey = getPrivateKeyFrom(prikey);
        String signature = signPSS(formatStr, privateKey);
    }

    public static PublicKey getPublicKey(String pemFormatKey) throws Exception {
        KeyFactory factory = KeyFactory.getInstance("RSA", "BC");

        PemReader pemReader = new PemReader(new InputStreamReader(
                new ByteArrayInputStream(public_key.getBytes("UTF-8"))));
        pemObject = pemReader.readPemObject();
        byte[] content = pemObject.getContent();
        X509EncodedKeySpec pubKeySpec = new X509EncodedKeySpec(content);
        return factory.generatePublic(pubKeySpec);
    }

    public static boolean verifyPSS(String plainText, String signature, String pomPubKey) throws Exception {
        PublicKey publicKey = getPublicKey(pomPubKey);
        Signature publicSignature = Signature.getInstance("SHA256withRSA/PSS");
        AlgorithmParameters pss = publicSignature.getParameters();
        PSSParameterSpec spec = new PSSParameterSpec("SHA-256", "MGF1",
                new MGF1ParameterSpec("SHA-256"), 11, 1);
        publicSignature.setParameter(spec);
        publicSignature.initVerify(publicKey);
        publicSignature.update(plainText.getBytes(UTF_8));

        byte[] signatureBytes = Base64.decodeBase64(signature);
        return publicSignature.verify(signatureBytes);
    }

    public static String verifySign(String formatStr, String sign) throws Exception {
        String pubkey = "-----BEGIN PUBLIC KEY-----\n" + "..." + "-----END PUBLIC KEY-----";
        return RSAAlgorithm.verifyPSS(formatStr, sign, pubkey)
    }
}

Android端：

需要在gradle配置dependencies项中，增加如下依赖：

implementation('org.bouncycastle:bcprov-jdk15on:1.54')
implementation('commons-codec:commons-codec:1.2')

同时，将上述代码中做出如下调整：将 KeyFactory factory = KeyFactory.getInstance("RSA", "BC"); 修改为： KeyFactory factory = KeyFactory.getInstance("RSA", new BouncyCastleProvider());

Swift

public struct RSA {

    public static func publicKey() -> Data {
        let publicKeyPEM = """
        -----BEGIN PUBLIC KEY-----
        ...
        -----END PUBLIC KEY-----
        """

        let publicKeyDER = try! SwKeyConvert.PublicKey.pemToPKCS1DER(publicKeyPEM)
        return publicKeyDER
    }

    public static func privateKey() -> Data {
        let privateKeyPEM = """
        -----BEGIN RSA PRIVATE KEY-----
        ...
        -----END RSA PRIVATE KEY-----
        """

        let privateKeyDER = try! SwKeyConvert.PrivateKey.pemToPKCS1DER(privateKeyPEM)
        return privateKeyDER
    }

    public static func sign(_ message: String) -> String? {
        guard let data = message.data(using: .utf8) else { return nil }
        let sign = try? CC.RSA.sign(data, derKey: privateKey(), padding: .pss,
                                    digest: .sha256, saltLen: 11)
        return sign?.base64EncodedString()
    }

//    public static func sign(_ parameters: [String: Any]) -> String? {
//        let message = parameters
//            .sorted(by: { $0.key < $1.key })
//            .map({ $0 + "=" + "\($1)" })
//            .joined(separator: "&")
//        guard let data = message.data(using: .utf8) else { return nil }
//        let sign = try? CC.RSA.sign(data, derKey: privateKey(), padding: .pss,
//                                    digest: .sha256, saltLen: 11)
//        return sign?.base64EncodedString()
//    }

    public static func verify(_ message: String, sign: Data) -> String? {
        guard let data = message.data(using: .utf8) else { return nil }
        let verified = try? CC.RSA.verify(testMessage, derKey: pubKey, padding: padding,
                                          digest: .sha256, saltLen: 11, signedData: sign!)

        return verified
    }
}

参考文档

Robot Framework教程 —— 整合Jenkins

2018-01-19T17:25:10+08:00

本文主要讲下如何使用Robot Framework搭建自己的自动化测试框架，包括如下几部分：

安装

网上安装Jenkins的文章很多，这里不详细介绍了，具体可以查看如下文档：

创建任务

在Jenkins首页左边导航栏点击新建任务，创建一个freestyle类型的任务。如下图：

上一篇文章我们已经写了一批测试示例，所以这里我们只要引用就可以了。

为了能够及时的获取最新代码进行测试，我们需要对Jenkins里GitHub相关的配置进行下设置：

在General部分，填写下GitHub project字段：git@github.com:abekthink/robot-framework-demo.git
在源码管理部分，选择Git选项，然后填写Repository URL字段：git@github.com:abekthink/robot-framework-demo.git

然后我们在构建部分，选择Execute shell配置一个shell脚本：

mkdir -p reports/robot-framework-demo
/usr/local/bin/robot --outputdir reports/robot-framework-demo test3.robot

这样就完成了整个任务的配置，不过这时候产出的文件我们并不能直接看到测试报告。所以，下一节我们会讲下使用Robot Framework plugin来更加直观的查看测试结果。

配置测试插件

按照首页 -> 系统管理 -> 管理插件打开插件管理的页面。在页面选择可选插件，然后搜索robot，结果中有个Robot Framework plugin，这个就是我们想要的，我们安装即可。

插件安装完成后，我们就可以直接应用在我们刚才的任务里了。打开刚才任务的配置页面，在构建后操作部分：

选择Publish Robot Framework test results进行编辑。
在Directory of Robot output字段里填写刚才报表的产出目录reports/robot-framework-demo。
在Thresholds for build result 部分可以配置项目在什么情况下显示蓝灯和黄灯，这里配置了当测试用例20%失败时则显示黄灯。

配置完成后，可以去任务里立即构建，查看刚刚配置的结果。

无法查看HTML

为了查看具体的测试结果，我们去打开Robot Framework plugin产生的report.html和log.html，最后发现无法打开，报出如下错误：

在Google上查询了相关问题，分析得来主要是因为在Jenkins 1.641引入了CSP头保护本地文件。所以要解决这个问题有两个版本：一个是直接修改Java启动时CSP有关的参数；另一个是增加groovy文件，在Jenkins启动时生效。这里我们采用了第一种，比较简单直接，直接修改tomcat中的catalina.sh，在文件最上面增加如下几行：

JENKINS_CSP_OPTS="sandbox allow-scripts; default-src 'none'; img-src 'self' data: ; style-src 'self' 'unsafe-inline' data: ; script-src 'self' 'unsafe-inline' 'unsafe-eval' ;"
JENKINS_OPTS="-Dhudson.model.DirectoryBrowserSupport.CSP=\"$JENKINS_CSP_OPTS\""
CATALINA_OPTS="$JENKINS_OPTS $CATALINA_OPTS"

将Tomcat关闭然后重新启动，就能正常查看相关报表了。

配置自动化

我们希望当代码提交时就能进行立即触发Jenkins任务的构建和测试，这样整个自动化才能完全实现，所以，这里提一下如何进行配置。

这里依然拿robot-framework-demo来举例：

首先在Jenkins上该任务的设置页面的构建触发器板块，将GitHub hook trigger for GITScm polling选项打勾。
然后，去GitHub上robot-framework-demo项目设置里配置Webhooks，创建一个新的webhook。
- URL的格式是$JENKINS_BASE_URL/github-webhook/，这里的JENKINS_BASE_URL就是你Jenkins服务的链接地址。
- Trigger类型的话可以只选择Push事件。

配置完成后，当项目的master有代码push时，即可触发webhook；然后触发Jenkins上的任务进行构建，这样就是实时查看最新的测试报告了。

参考文档

Robot Framework教程 —— 关键字

2018-01-18T23:58:56+08:00

本文主要讲下如何使用Robot Framework搭建自己的自动化测试框架，包括如下几部分：

声明

框架支持多种方式撰写测试数据和用例，包括HTML、TSV、纯文本、reStructuredText等。本文主要讲解纯文本方式，如果想看其他几种方式，请查看测试数据格式。

一个简单的示例

让我们直接看一个简单的示例，从而初步理解框架是如何进行测试的。

*** Settings ***

*** Test Cases ***
Test Robot Framework Logging
    Log    "Test Logging"

Settings部分是空的，因为我们并没有引用标准测试库或者外部测试类。现在我们可以忽略它。 Test Cases部分，我们定义了一个测试用例。它执行了一个关键字Log，我们传递一个Test Loging的字符串参数给它。这里有几点需要注意下，关键字与参数之间要至少有2个空格以上。另外，在每一个测试用例下的每一行，都要有至少2个空格以上的缩进。在这个例子中，很明显的看到我们都保留了4个空格，但往往这点容易被人忽略。

以上测试用例，我们可以使用robot或者java命令来去运行测试。如下：

pybot --outputdir ./reports test0.robot
java -jar /usr/local/opt/robotframework/robotframework-3.0.2.jar --outputdir ./report test0.robot

命令行能够支持多种选项，在这上面这个例子中，我们只使用了--outputdir选项来指定测试日志和报告存储的目录。

关键字 —— 编程语言

使用关键字就像学习了一门新的编程语音。关键字语法包括内置、标注和外部测试库。内置库可以直接使用，无需显式声明import。标准库也是框架的一部分，但是需要在Settings块内显式地声明import。外部库必须单独安装，然后按照标准库的方式导入。下面举一个例子：

*** Settings ***
Library     String


*** Test Cases ***
Test Robot Framework Logging
    Log    Test Logging
    Log Many    First Entry   Second Entry   Third Entry
    Log To Console    Display to console while Robot is running

Test For Loop
    : FOR    ${INDEX}    IN RANGE    1    3
    \    Log    ${INDEX}
    \    ${RANDOM_STRING}=    Generate Random String    ${INDEX}
    \    Log    ${RANDOM_STRING}

首先，我们扩展了第一个测试用例，增加了几行调用不同的关键字。尽管这三行都是打日志，但在测试用例定义下执行多个关键字是我们最常用的测试方式。第二个测试用例实现了一个循环，以及如何执行一个关键字将结果赋值到一个变量中。因为关键字Generate Random String来自于String Library，所以我需要在Settings块下import它。

写自己的关键字

到现在为止，已经学习了怎么是怎么使用保留的关键字。下面我们写自己的第一个关键字：

*** Settings ***

*** Test Cases ***
Test Robot Framework Logging
    Log    Test Logging

Test My Robot Framework Logging
    My Logging    My Message    WARN

*** Keywords ***
My Logging
    [Arguments]    ${msg}    ${level}
    Log    ${msg}    ${level}

自己的关键字需要写在Keywords块下。语法和写测试用例一样，最大的不同是可以再自己的关键字里传递参数。

管理关键字 —— 资源文件

当然，随着关键字定义越来越多，测试用例文件会越来越复杂，不容易管理。为了解决这个，可以考虑在所谓的资源文件里定义新的关键字，然后这些资源文件可以与测试库一样被导入进测试用例文件。

资源文件如下：

*** Keywords ***
My Logging
    [Arguments]    @{arg}
    Log Many    @{arg}

测试用例文件如下：

*** Settings ***
Resource        resource-0.txt

*** Variables ***
${MESSAGE}    "Test My Logging 3"

*** Test Cases ***
Test Robot Framework Logging
    Log    "Test Logging"

Test My Logging
    My Logging    "Test My Logging 1"    "Test My Logging 2"    ${MESSAGE}

在上面这个例子中，测试用例文件和资源文件必须在同一个目录下；当然，也可以把资源文件放在子目录下，在import时也需要使用那个相对路径。另外，上面例子中还使用了Variables块来定义变量。

高级功能

现在已经学会了写自己关键字、资源文件和测试用例文件的基本知识。当然还会有一些更高级的功能。下面列了两个你可能会使用到的功能。

设置和拆卸

下面这个列子显示了在执行关键字前，需要做的准备工作以及测试完成后做的清理工作。

*** Settings ***
Suite Setup       Setup Actions
Suite Teardown    Teardown Actions

*** Test Cases ***
Test Robot Framework Logging
    Log    Test Logging

*** Keywords ***
Setup Actions
    Log    Setup Actions done here

Teardown Actions
    Log    Teardown Actions done here

打标签

打标签和关键字并没有关系，但是这是一个很好的方式，在测试完成后产生的测试报表中有利于更好地理解报表。

*** Settings ***
Suite Setup       Setup Actions
Suite Teardown    Teardown Actions

*** Test Cases ***
Test Robot Framework Logging
    [Tags]    sample   logging
    Log    Test Logging

*** Keywords ***
Setup Actions
    Log    Setup Actions done here

Teardown Actions
    Log    Teardown Actions done here

这些标签在报表中会进行汇总，你可以查看有多少测试用例与这些标签有关。

报告与日志文件

Robot Framework框架产生的报告和日志文件功能是非常强大的。

正如上面的截图，显示了测试结果不同维度的统计。你可以看到有多少测试用例打上了同一个标签。另外，你还可以按照测试套件查看统计，如下图。

值得高兴的是你还可以继续深挖，点击某一个具体用例查看其具体的结果。这样会打开一个新的日志页面。这个页面可以查看每一个关键字被执行的结果。如果一个用例执行失败了，可以非常方便地查看到具体是什么原因导致的。

参考文档

Robot Framework教程 —— 安装

2018-01-17T20:54:16+08:00

本文主要讲下如何使用Robot Framework搭建自己的自动化测试框架，包括如下几部分：

介绍

主要特性

它是一款基于Python的，可扩展的关键字驱动（keyword-driven）的自动化测试框架。
采用简单易用的表格式语法统一创建测试用例。
高复用性：提供了关键字语法，可以使用现有的关键字创建高级的关键字。
提供HTML格式的测试结果报表，简单易读。
跨平台和应用，不依赖相关环境。
提供简单API库创建自定义测试库，可以在本地使用Python或者Java运行。
提供命令行CLI界面和基于XML的输出文件。
支持Selemium页面测试，Java GUI测试，运行进程，Telnet，SSH等。
支持创建数据驱动（data-driven）的测试用例。
内置支持变量，尤其适用于在不同环境下进行测试。
提供标签分类和可以指定测试用例执行。
易于与源码控制整合，测试套件可以是文件或者字典，可以按照源码版本进行管理。
提供测试用例和测试套件级别的设置（setup）和拆卸（teardown）
模块化架构：支持为多种不同类型接口的应用提供创建针对性测试用例

架构设计

Robot Framework是一个通用的，独立于应用和技术的框架。它有一个高度模块化的体系结构，如下图：

这里进行几点说明：

测试数据（Test Data）可以采用简单易编辑的表格形式进行撰写。
框架启动时，它可以获取测试数据，执行测试用例，并生成日志和报表。
核心的框架并不了解测试以下的系统，一般都是通过测试库（Test Libraries）进行交互。
库既可以直接使用应用接口，也可以使用低级别的测试工具（Test Tools）作为驱动。

安装

安装一般有两种方式：Python环境下直接进行安装；或者Java环境下直接使用一个独立Jar包。

Python

最简单直接的方式，直接使用pip命令进行安装。

# Install the latest version
pip install robotframework

# Upgrade to the latest version
pip install --upgrade robotframework

当然，也可以将Github源码下载下来，进行手动安装：

python setup.py install
jython setup.py install
ipy setup.py install
pypy setup.py install

备注：不同的python环境请使用对应的解释器。

Java

Java相对简单些，直接去Maven中心仓库下载最新的Jar包即可，包的命名是robotframework-<version>.jar。使用时直接执行如下类似指令即可：

java -jar robotframework-3.0.2.jar mytests.robot
java -jar robotframework-3.0.2.jar --variable name:value mytests.robot

参考文档

使用JWT保证服务间通信的安全

2017-12-19T21:08:10+08:00

本文主要讲下JWT(JSON Web Token)的基本原理，以及为什么使用它，如何使用它。

什么是JWT

先看看JWT的定义：

A JSON Web Token (JWT) is a JSON object that is defined in RFC 7519 as a safe way to represent a set of information between two parties. The token is composed of a header, a payload, and a signature.

翻译过来就是说：JWT是一种基于RFC 7519标准的JSON对象，主要是为了双方通信的安全而制定的。它包含头部（header），载荷（payload）和签名（signature）三部分。

为什么使用JWT

说到这里，就要说下传统的基于session的用户认证方式以及基于token的区别了。

基于session的用户认证方式

大家都知道，http是一种无状态的协议，用户登录成功后如果下次再次访问还需要再次认证，或者下次访问时携带相关的认证信息也是可以的。 session认证就是后面这种实现方式：当用户登录成功后，由服务端为用户生成相应的认证信息存储在服务端，并在请求响应返回前，将认证信息写入响应的cookie内；这样，用户下一次请求时携带之前cookie的认证信息即可，服务端在收到请求后，对cookie里的信息与服务端的session进行比对认证，验证通过后即可进行后续处理。

这种方式的缺点是：

如果客户端不能支持cookie功能，接入会非常困难。
服务端存储了用户的session信息，这些信息随着用户量的增大，服务端的空间开销都会不断增加。
服务器的session信息是需要独立存储的，如果数据分散存放在各个服务器，那么还要考虑用户是在哪台服务器登录了，难于扩展和维护。

基于token的用户认证方式

基于token的用户认证是一种服务端无状态的认证方式，服务端无需存储用户的认证信息或者会话信息，并且任何服务器拿到token都能进行用户认证。

主要流程大致如下：

用户使用密码登录或者第三方登录。
服务器收到用户的登录信息进行身份认证；通过身份验证后，服务器生成token，并将其返回。
客户端收到token后存储在本地，并在后续的请求中均携带该token。
服务器收到后续的用户请求时，用请求的token进行用户认证，验证通过后即可进行后续处理。

这种认证方式相对简单，而且可扩展性很强，无需考虑服务器的单点问题等。我这里选用了JWT作为token的生成策略。

JWT生成与验证

JWT格式

刚才已经提到，JWT包含三个组件：头部，载荷和签名。其格式大致如下：

header.payload.signature

这里举一个比较真实的例子，如下：

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1aWQiOiIzMmNkOGI4M2RjZTk0MDBjOGNjOWRiNmVkNjdhZjBkOSIsImlzcyI6ImFiZWt0aGluay5naXRodWIuaW8iLCJleHAiOjE1MTM3NjA1MjksImlhdCI6MTUxMzI2MDUyOSwiYXVkIjoic29tZW9uZSIsInN1YiI6ImFiZWt0aGluay5naXRodWIuaW8ifQ.O0laKQkICjLO5V4gY_LWqADdEtjCgqM_deFHduqBMTk

header主要包含着token是如何加密生成的信息，是一个类似如下格式的JSON对象：

{
    "typ": "JWT",
    "alg": "HS256"
}

这里，typ指定了这个对象是一个JWT对象，alg指明了用于生成JWT签名组件用到的算法。在这个例子中，我们用到了HMAC-SHA256算法（只要提供一个secret即可进行加密的算法）。

payload

payload也是一个JSON对象，它主要包含了一些用户的有效信息，例如：

{
  "uid": "32cd8b83dce9400c8cc9db6ed67af0d9",
  "iss": "abekthink.github.io",
  "exp": 1513760529,
  "iat": 1513260529,
  "aud": "someone",
  "sub": "abekthink.github.io"
}

标准中的保留字如下：

变量名	英文全写	备注
iss	Issuer	该JWT的发布者
sub	Subject	该JWT面向的主体或者用户
aud	Audience	接收该JWT的用户
exp	Expiration Time	过期时间（单位为秒）
nbf	Not Before	开始时间（单位为秒），在该时间之前无效
iat	Issued At	发布时间（单位为秒）
jti	JWT ID	JWT唯一标识，区分不同发布者的统一的标识

字段的具体说明可以参考RFC 7519。

备注： header和payload部分，均采用base64加密。所以，任何人均可以解密出来，建议不要放用户敏感信息。

signature

最后一部分是签名信息，它由header、payload以及secret三部分生成而来。

首先，将header和payload分别用base64url加密，然后两段加密后的字符串用.连接起来；之后，将拼接后的字符串，用secret进行hash加密得到最终签名的部分，加密的算法就是之前header里alg指定的算法。这里用一段伪代码来表示签名的生成过程：

// signature algorithm
data = base64urlEncode(header) + "." + base64urlEncode(payload)
signature = Hash(data, secret);

JWT生成

将加密后的header、payload和signature三部分用.连接起来，即最后的JWT。

// header(after base64url)
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9

// payload(after base64url)
eyJ1aWQiOiIzMmNkOGI4M2RjZTk0MDBjOGNjOWRiNmVkNjdhZjBkOSIsImlzcyI6ImFiZWt0aGluay5naXRodWIuaW8iLCJleHAiOjE1MTM3NjA1MjksImlhdCI6MTUxMzI2MDUyOSwiYXVkIjoic29tZW9uZSIsInN1YiI6ImFiZWt0aGluay5naXRodWIuaW8ifQ

// signature
O0laKQkICjLO5V4gY_LWqADdEtjCgqM_deFHduqBMTk

// final jwt
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1aWQiOiIzMmNkOGI4M2RjZTk0MDBjOGNjOWRiNmVkNjdhZjBkOSIsImlzcyI6ImFiZWt0aGluay5naXRodWIuaW8iLCJleHAiOjE1MTM3NjA1MjksImlhdCI6MTUxMzI2MDUyOSwiYXVkIjoic29tZW9uZSIsInN1YiI6ImFiZWt0aGluay5naXRodWIuaW8ifQ.O0laKQkICjLO5V4gY_LWqADdEtjCgqM_deFHduqBMTk

备注： 这里hash算法用的是HS256（即HMAC-SHA256），所以它只需要一个secret即可以完成JWT的生成和验证，该secret仅保存在服务端，必须保密；如果想要安全系数更高，建议采用使用公钥私钥的RS256（即RSA-SHA256）算法。

JWT验证

前面已经详细地介绍了JWT是如何生成的，这里主要说下，当用户发来一个JWT，服务端如何进行验证。

服务端收到JWT，主要的验证流程如下：

先验证签名是否一致，即通过header和payload，再加上服务器的secret再次生成签名，看是否与JWT的第三部分一致。如果不一致说明token被篡改，应该拒绝该请求。
验证iss、sub、aud是否与之前生成token的相应配置一致。
验证nbf和exp是否在合理的有效期内。

第一步服务端必须进行验证；后面的两部分可依据自己的应用场景进行选择性处理。

注意事项

这里再次提醒下大家要注意的几点：

JWT生成过程中不要放用户的敏感信息，因为很容易泄露。
出于安全考虑，建议对iss、sub、aud、nbf和exp字段均进行验证。
请尽量使用https协议。
别重复造轮子，现在有很多现成的JWT开源库，包括c、python、java、nodejs、javascript、ruby、go等各种主流语言的版本。

参考文档

一小时内使用Jekyll搭建自己的GitHub博客

2017-12-17T20:18:00+08:00

这里主要讲下自己是怎么一步一步从零开始搭建自己的博客的。

安装ruby

如果你的本机是macOSx，则执行如下命令即可完成ruby的安装：

brew install ruby

如果机器是其他操作系统，这里就不详述了，可以去参考下Ruby官方安装文档。

另外，如果gem没有安装成功，可以参考RubyGems去安装gem。

安装Jekyll

在命令行里执行如下命令，即可完成jekyll的安装：

gem install jekyll bundler

备注： bundler类似于python的pip工具，用于管理项目中的包依赖等，非常好用；另外，bundler需要项目根目录有一个Gemfile文件，类似python项目的的requirements.txt文件。

创建自己的GitHub Pages

请进入GitHub Pages，按照步骤创建自己的站点。

如果需要本地配置，请参考GitHub Pages本地设置。

初始化自己的站点

在命令行里执行如下命令，即可完成jekyll站点的初始化：

jekyll new myblog

进入项目，即可进行本地测试：

cd myblog/
bundle exec jekyll serve

添加Jekyll主题

我自己选择了Minimal Mistakes主题。

创建或者编辑根目录下的Gemfile，增改或者增加如下代码：

source "https://rubygems.org"

gem "github-pages", group: :jekyll_plugins
gem "jekyll-remote-theme"

执行如下命令，确保包依赖安装完毕：

bundle update

修改根目录下的_config.yml文件：

增加remote_theme: "mmistakes/minimal-mistakes"。

然后将jekyll-remote-theme添加至自己_config.yml文件中plugins数组中，例如:

plugins:
  - jekyll-remote-theme

最后，你可以使用bundle exec jekyll serve测试主题是否添加成功了。

撰写博文

撰写博文时，需要将文件放在_post目录下，文件名的格式一般为YEAR-MONTH-DAY-title.MARKUP。

当YEAR是一个四位数时，MONTH和DAY必须都是两位数，MARKUP是文件名后缀，下面两个是正确的例子：

2016-06-04-hello-world.md
2017-08-18-writing-blogs.markdown

如何撰写不熟悉markdown文件，请参考：

Mastering Markdown。
Learning-Markdown。

配置评论

在配置staticman V2时，需要关注以下几点：

reCaptcha的密钥等设置，需要在_config.yml和staticman.yml两个文件中都添加。
reCaptcha的secret需要进行staticman密钥加密。

本地无法启动问题

在本地启动时如果出现如下报错，基本上是因为国内网络下载或者unzip解压有问题导致。

jekyll 3.6.2 | Error:  Zip end of central directory signature not found

出现这种问题，可以考虑采取以下两种方式：

第一种：将依赖的包解压换成rubyzip，例如：

gem 'jekyll-remote-theme', github: 'benbalter/jekyll-remote-theme', branch: 'rubyzip'

第二种：如果是remote_theme无法下载，可以考虑将依赖提前下载安装，theme直接使用，例如：

首先，将gem "minimal-mistakes-jekyll"加入到Gemfile中
然后，执行bundle install更新依赖
最后，在_config.yml文件中设置theme: minimal-mistakes-jekyll，需要将原来的remote_theme设置移除

abekthink’s blog

RSA Encryption with Python and Java and Swift

需求

设计

客户端

服务端

各语言加密方式

说明

Python

Java(Android)

Swift

参考文档

Robot Framework教程 —— 整合Jenkins

安装

创建任务

配置测试插件

无法查看HTML

配置自动化

参考文档

Robot Framework教程 —— 关键字

声明

一个简单的示例

关键字 —— 编程语言

写自己的关键字

管理关键字 —— 资源文件

高级功能

设置和拆卸

打标签

报告与日志文件

参考文档

Robot Framework教程 —— 安装

介绍

主要特性

架构设计

相关截图

安装

Python

Java

参考文档

使用JWT保证服务间通信的安全

什么是JWT

为什么使用JWT

基于session的用户认证方式

基于token的用户认证方式

JWT生成与验证

JWT格式

header

payload

signature

JWT生成

JWT验证

注意事项

参考文档

一小时内使用Jekyll搭建自己的GitHub博客

安装ruby

安装Jekyll

创建自己的GitHub Pages

初始化自己的站点

添加Jekyll主题

撰写博文

配置评论

本地无法启动问题

参考文档