vertx 异步编程指南 step7-保护和控制访问

保护和控制访问与Vert.x很容易。在本节中，我们将：

1. 从HTTP转移到HTTPS，以及

2. 使用基于组的权限将用户身份验证添加到Web应用程序，以及

3. 使用JSON Web令牌（JWT）控制对Web API的访问。

证书可以存储在Java KeyStore文件中。您可能需要用于测试目的的自签名证书，以下是如何在server-keystore.jksKeyStore中创建一个密码为secret：

1.  
   keytool -genkey
2.  
   -alias test
3.  
   -keyalg RSA
4.  
   -keystore server-keystore.jks
5.  
   -keysize 2048
6.  
   -validity 360
7.  
   -dname CN=localhost
8.  
   -keypass secret
9.  
   -storepass secret

然后，我们可以更改HTTP服务器创建，以传递一个HttpServerOptions对象来指定我们需要SSL，并指向我们的KeyStore文件：

1.  
   HttpServer server = vertx.createHttpServer(new HttpServerOptions()
2.  
   .setSsl(true)
3.  
   .setKeyStoreOptions(new JksOptions()
4.  
   .setPath("server-keystore.jks")
5.  
   .setPassword("secret")));

我们可以将浏览器指向https：// localhost：8080 /，但由于证书是自签名的，所以任何优秀的浏览器都会正确地产生安全警告：

最后但并非最不重要的是，我们需要更新测试用例，ApiTest因为原始代码是用于通过Web客户端发出HTTP请求的：

1.  
   webClient = WebClient.create(vertx, new WebClientOptions()
2.  
   .setDefaultHost("localhost")
3.  
   .setDefaultPort(8080)
4.  
   .setSsl(true) (1)
5.  
   .setTrustOptions(new JksOptions().setPath("server-keystore.jks").setPassword("secret")));

1. 确保SSL。

2. 由于证书是自签名的，我们需要明确信任它，否则Web客户端连接将失败，就像Web浏览器一样。

访问控制和认证

Vert.x为执行身份验证和授权提供了广泛的选项。官方支持的模块涵盖了JDBC，MongoDB，Apache Shiro，OAuth2以及众所周知的提供者和JWT（JSON Web令牌）。

虽然下一部分将介绍JWT，但本部分重点介绍如何使用Apache Shiro，这在验证必须由LDAP或Active Directory服务器支持时特别有用。在我们的例子中，我们只是将凭据存储在属性文件中以保持简单，但对LDAP服务器的API使用保持不变。

目标是要求用户使用wiki进行身份验证，并拥有基于角色的权限：

• 没有角色只允许阅读页面，

• 具有作家角色允许编辑页面，

• 具有编辑角色允许创建，编辑和删除页面，

• 具有管理角色相当于具有所有可能的角色。

警告	由于Apache Shiro的内部运作，Vert.x Shiro集成有一些问题。有些部分阻塞会影响性能，有些数据是使用线程本地状态存储的。您不应该尝试滥用暴露的内部状态API。

将Apache Shiro身份验证添加到路由

第一步是将vertx-auth-shiro模块添加到Maven依赖关系列表中：

1.  
   <dependency>
2.  
   <groupId>io.vertx</groupId>
3.  
   <artifactId>vertx-auth-shiro</artifactId>
4.  
   </dependency>

我们使用的属性文件定义如下，位于src/main/resources/wiki-users.properties：

1.  
   user.root=w00t,admin
2.  
   user.foo=bar,editor,writer
3.  
   user.bar=baz,writer
4.  
   user.baz=baz
5.  
    
6.  
   role.admin=*
7.  
   role.editor=create,delete,update
8.  
   role.writer=update

带user前缀的条目是一个用户帐户，其中第一个值条目是密码可能跟随的角色。在这个例子中，用户bar有密码baz，是一个writer，并且writer有update权限。

回到HttpServerVerticle课程代码，我们使用Apache Shiro创建认证提供者：

1.  
   AuthProvider auth = ShiroAuth.create(vertx, new ShiroAuthOptions()
2.  
   .setType(ShiroAuthRealmType.PROPERTIES)
3.  
   .setConfig(new JsonObject()
4.  
   .put("properties_path", "classpath:wiki-users.properties")));

该ShiroAuth对象实例然后用于处理服务器端用户会话：

1.  
   Router router = Router.router(vertx);
2.  
    
3.  
   router.route().handler(CookieHandler.create());
4.  
   router.route().handler(BodyHandler.create());
5.  
   router.route().handler(SessionHandler.create(LocalSessionStore.create(vertx)));
6.  
   router.route().handler(UserSessionHandler.create(auth)); (1)
7.  
    
8.  
   AuthHandler authHandler = RedirectAuthHandler.create(auth, "/login"); (2)
9.  
   router.route("/").handler(authHandler); (3)
10.  
    router.route("/wiki/*").handler(authHandler);
11.  
    router.route("/action/*").handler(authHandler);
12.  
     
13.  
    router.get("/").handler(this::indexHandler);
14.  
    router.get("/wiki/:page").handler(this::pageRenderingHandler);
15.  
    router.post("/action/save").handler(this::pageUpdateHandler);
16.  
    router.post("/action/create").handler(this::pageCreateHandler);
17.  
    router.get("/action/backup").handler(this::backupHandler);
18.  
    router.post("/action/delete").handler(this::pageDeletionHandler);

1. 我们为所有路由安装用户会话处理程序。

2. 这会自动将请求重定向到/login没有用户会话的请求时。

3. 我们安装authHandler了所有需要身份验证的路由。

最后，我们需要创建3条路线来显示登录表单，处理登录表单提交和注销用户：

1.  
   router.get("/login").handler(this::loginHandler);
2.  
   router.post("/login-auth").handler(FormLoginHandler.create(auth)); (1)
3.  
    
4.  
   router.get("/logout").handler(context -> {
5.  
   context.clearUser(); (2)
6.  
   context.response()
7.  
   .setStatusCode(302)
8.  
   .putHeader("Location", "/")
9.  
   .end();
10.  
    });

1. FormLoginHandler是处理登录提交请求的助手。默认情况下，它希望HTTP POST请求具有：username作为登录名，password密码以及return_url成功时重定向到的URL。

2. 注销用户很简单，就像从当前清除它一样RoutingContext。

该loginHandler方法的代码是：

1.  
   private void loginHandler(RoutingContext context) {
2.  
   context.put("title", "Login");
3.  
   templateEngine.render(context, "templates", "/login.ftl", ar -> {
4.  
   if (ar.succeeded()) {
5.  
   context.response().putHeader("Content-Type", "text/html");
6.  
   context.response().end(ar.result());
7.  
   } else {
8.  
   context.fail(ar.cause());
9.  
   }
10.  
    });
11.  
    }

HTML模板位于src/main/resources/templates/login.ftl：

1.  
   <#include "header.ftl">
2.  
    
3.  
   <div class="row">
4.  
    
5.  
   <div class="col-md-12 mt-1">
6.  
   <form action="/login-auth" method="POST">
7.  
   <div class="form-group">
8.  
   <input type="text" name="username" placeholder="login">
9.  
   <input type="password" name="password" placeholder="password">
10.  
    <input type="hidden" name="return_url" value="/">
11.  
    <button type="submit" class="btn btn-primary">Login</button>
12.  
    </div>
13.  
    </form>
14.  
    </div>
15.  
     
16.  
    </div>
17.  
     
18.  
    <#include "footer.ftl">

登录页面如下所示：

支持基于角色的功能

只有当用户拥有足够的权限时才能激活功能。在以下屏幕截图中，管理员可以创建一个页面并执行备份：

相比之下，没有角色的用户不能执行这些操作：

为此，我们可以访问RoutingContext用户参考，并查询权限。以下是indexHandler处理器方法的实现方式：

1.  
   private void indexHandler(RoutingContext context) {
2.  
   context.user().isAuthorised("create", res -> { (1)
3.  
   boolean canCreatePage = res.succeeded() && res.result(); (2)
4.  
   dbService.fetchAllPages(reply -> {
5.  
   if (reply.succeeded()) {
6.  
   context.put("title", "Wiki home");
7.  
   context.put("pages", reply.result().getList());
8.  
   context.put("canCreatePage", canCreatePage); (3)
9.  
   context.put("username", context.user().principal().getString("username")); (4)
10.  
    templateEngine.render(context, "templates", "/index.ftl", ar -> {
11.  
    if (ar.succeeded()) {
12.  
    context.response().putHeader("Content-Type", "text/html");
13.  
    context.response().end(ar.result());
14.  
    } else {
15.  
    context.fail(ar.cause());
16.  
    }
17.  
    });
18.  
    } else {
19.  
    context.fail(reply.cause());
20.  
    }
21.  
    });
22.  
    });
23.  
    }

1. 这是如何进行权限查询的。请注意，这是一个异步操作。

2. 我们使用结果...

3. ...在HTML模板中利用它。

4. 我们也可以访问用户登录。

模板代码已被修改为仅基于以下值来呈现特定片段canCreatePage：

1.  
   <#include "header.ftl">
2.  
    
3.  
   <div class="row">
4.  
    
5.  
   <div class="col-md-12 mt-1">
6.  
   <#if context.canCreatePage>
7.  
   <div class="float-xs-right">
8.  
   <form class="form-inline" action="/action/create" method="post">
9.  
   <div class="form-group">
10.  
    <input type="text" class="form-control" id="name" name="name" placeholder="New page name">
11.  
    </div>
12.  
    <button type="submit" class="btn btn-primary">Create</button>
13.  
    </form>
14.  
    </div>
15.  
    </#if>
16.  
    <h1 class="display-4">${context.title}</h1>
17.  
    <div class="float-xs-right">
18.  
    <a class="btn btn-outline-danger" href="/logout" role="button" aria-pressed="true">Logout (${context.username})</a>
19.  
    </div>
20.  
    </div>
21.  
     
22.  
    <div class="col-md-12 mt-1">
23.  
    <#list context.pages>
24.  
    <h2>Pages:</h2>
25.  
    <ul>
26.  
    <#items as page>
27.  
    <li><a href="/wiki/${page}">${page}</a></li>
28.  
    </#items>
29.  
    </ul>
30.  
    <#else>
31.  
    <p>The wiki is currently empty!</p>
32.  
    </#list>
33.  
     
34.  
    <#if context.canCreatePage>
35.  
    <#if context.backup_gist_url?has_content>
36.  
    <div class="alert alert-success" role="alert">
37.  
    Successfully created a backup:
38.  
    <a href="${context.backup_gist_url}" class="alert-link">${context.backup_gist_url}</a>
39.  
    </div>
40.  
    <#else>
41.  
    <p>
42.  
    <a class="btn btn-outline-secondary btn-sm" href="/action/backup" role="button" aria-pressed="true">Backup</a>
43.  
    </p>
44.  
    </#if>
45.  
    </#if>
46.  
    </div>
47.  
     
48.  
    </div>
49.  
     
50.  
    <#include "footer.ftl">

该代码类似于确保更新或删除页面仅限于某些角色，并可从指南Git存储库中获得。

确保检查也是在HTTP POST请求处理程序上完成，而不仅仅是在呈现HTML页面时进行。事实上，恶意攻击者仍然可以制作请求并执行操作，而无需进行身份验证。以下是如何通过将pageDeletionHandler代码包装在最上面的权限检查中来保护页面删除：

1.  
   private void pageDeletionHandler(RoutingContext context) {
2.  
   context.user().isAuthorised("delete", res -> {
3.  
   if (res.succeeded() && res.result()) {
4.  
    
5.  
   // Original code:
6.  
   dbService.deletePage(Integer.valueOf(context.request().getParam("id")), reply -> {
7.  
   if (reply.succeeded()) {
8.  
   context.response().setStatusCode(303);
9.  
   context.response().putHeader("Location", "/");
10.  
    context.response().end();
11.  
    } else {
12.  
    context.fail(reply.cause());
13.  
    }
14.  
    });
15.  
     
16.  
    } else {
17.  
    context.response().setStatusCode(403).end();
18.  
    }
19.  
    });
20.  
    }

使用JWT验证Web API请求

JSON Web Tokens（RFC 7519）是发布包含声明的 JSON编码标记的标准，通常标识用户和权限，但声明可以是任何事情。

令牌由服务器发出，并使用服务器密钥进行签名。客户端可以将令牌发送回以及随后的请求：客户端和服务器都可以检查令牌是否真实且未改变。

警告	JWT令牌签名时，其内容未加密。它必须通过安全通道（例如HTTPS）进行传输，并且它不应该有敏感数据作为声明（例如，密码，私人API密钥等）。

添加JWT支持

我们首先将vertx-auth-jwt模块添加到Maven依赖关系中：

1.  
   <dependency>
2.  
   <groupId>io.vertx</groupId>
3.  
   <artifactId>vertx-auth-jwt</artifactId>
4.  
   </dependency>

我们将有一个JCEKS密钥库来保存我们测试的密钥。以下是如何keystore.jceks使用各种长度的适当键生成一个文件：

1.  
   keytool -genseckey -keystore keystore.jceks -storetype jceks -storepass secret -keyalg HMacSHA256 -keysize 2048 -alias HS256 -keypass secret
2.  
   keytool -genseckey -keystore keystore.jceks -storetype jceks -storepass secret -keyalg HMacSHA384 -keysize 2048 -alias HS384 -keypass secret
3.  
   keytool -genseckey -keystore keystore.jceks -storetype jceks -storepass secret -keyalg HMacSHA512 -keysize 2048 -alias HS512 -keypass secret
4.  
   keytool -genkey -keystore keystore.jceks -storetype jceks -storepass secret -keyalg RSA -keysize 2048 -alias RS256 -keypass secret -sigalg SHA256withRSA -dname "CN=,OU=,O=,L=,ST=,C=" -validity 360
5.  
   keytool -genkey -keystore keystore.jceks -storetype jceks -storepass secret -keyalg RSA -keysize 2048 -alias RS384 -keypass secret -sigalg SHA384withRSA -dname "CN=,OU=,O=,L=,ST=,C=" -validity 360
6.  
   keytool -genkey -keystore keystore.jceks -storetype jceks -storepass secret -keyalg RSA -keysize 2048 -alias RS512 -keypass secret -sigalg SHA512withRSA -dname "CN=,OU=,O=,L=,ST=,C=" -validity 360
7.  
   keytool -genkeypair -keystore keystore.jceks -storetype jceks -storepass secret -keyalg EC -keysize 256 -alias ES256 -keypass secret -sigalg SHA256withECDSA -dname "CN=,OU=,O=,L=,ST=,C=" -validity 360
8.  
   keytool -genkeypair -keystore keystore.jceks -storetype jceks -storepass secret -keyalg EC -keysize 256 -alias ES384 -keypass secret -sigalg SHA384withECDSA -dname "CN=,OU=,O=,L=,ST=,C=" -validity 360
9.  
   keytool -genkeypair -keystore keystore.jceks -storetype jceks -storepass secret -keyalg EC -keysize 256 -alias ES512 -keypass secret -sigalg SHA512withECDSA -dname "CN=,OU=,O=,L=,ST=,C=" -validity 360

我们需要在API路由上安装JWT令牌处理程序：

1.  
   Router apiRouter = Router.router(vertx);
2.  
    
3.  
   JWTAuth jwtAuth = JWTAuth.create(vertx, new JsonObject()
4.  
   .put("keyStore", new JsonObject()
5.  
   .put("path", "keystore.jceks")
6.  
   .put("type", "jceks")
7.  
   .put("password", "secret")));
8.  
    
9.  
   apiRouter.route().handler(JWTAuthHandler.create(jwtAuth, "/api/token"));

我们通过/api/token作为JWTAuthHandler对象创建的参数来指定该URL将被忽略。的确，这个URL被用来生成新的JWT令牌：

1.  
   apiRouter.get("/token").handler(context -> {
2.  
    
3.  
   JsonObject creds = new JsonObject()
4.  
   .put("username", context.request().getHeader("login"))
5.  
   .put("password", context.request().getHeader("password"));
6.  
   auth.authenticate(creds, authResult -> { (1)
7.  
    
8.  
   if (authResult.succeeded()) {
9.  
   User user = authResult.result();
10.  
    user.isAuthorised("create", canCreate -> { (2)
11.  
    user.isAuthorised("delete", canDelete -> {
12.  
    user.isAuthorised("update", canUpdate -> {
13.  
     
14.  
    String token = jwtAuth.generateToken( (3)
15.  
    new JsonObject()
16.  
    .put("username", context.request().getHeader("login"))
17.  
    .put("canCreate", canCreate.succeeded() && canCreate.result())
18.  
    .put("canDelete", canDelete.succeeded() && canDelete.result())
19.  
    .put("canUpdate", canUpdate.succeeded() && canUpdate.result()),
20.  
    new JWTOptions()
21.  
    .setSubject("Wiki API")
22.  
    .setIssuer("Vert.x"));
23.  
    context.response().putHeader("Content-Type", "text/plain").end(token);
24.  
    });
25.  
    });
26.  
    });
27.  
    } else {
28.  
    context.fail(401);
29.  
    }
30.  
    });
31.  
    });

1. 我们预计登录名和密码信息已通过HTTP请求标头传递，我们使用上一节的Apache Shiro身份验证提供程序进行身份验证。

2. 一旦成功，我们可以查询角色。

3. 我们生成令牌username，canCreate，canDelete和canUpdate索赔。

每个API处理程序方法现在可以查询当前的用户主体和声明。这是如何apiDeletePage做到的：

1.  
   private void apiDeletePage(RoutingContext context) {
2.  
   if (context.user().principal().getBoolean("canDelete", false)) {
3.  
   int id = Integer.valueOf(context.request().getParam("id"));
4.  
   dbService.deletePage(id, reply -> {
5.  
   handleSimpleDbReply(context, reply);
6.  
   });
7.  
   } else {
8.  
   context.fail(401);
9.  
   }
10.  
    }

使用JWT令牌

为了说明如何使用JWT令牌，让我们为root用户创建一个新的令牌：

$ http --verbose --verify no GET https://localhost:8080/api/token login:root password:w00t
GET /api/token HTTP/1.1
Accept: */*
Accept-Encoding: gzip, deflate
Connection: keep-alive
Host: localhost:8080
User-Agent: HTTPie/0.9.8
login: root
password: w00t



HTTP/1.1 200 OK
Content-Length: 242
Content-Type: text/plain
Set-Cookie: vertx-web.session=8cbb38ac4ce96737bfe31cc0ceaae2b9; Path=/

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VybmFtZSI6InJvb3QiLCJjYW5DcmVhdGUiOnRydWUsImNhbkRlbGV0ZSI6dHJ1ZSwiY2FuVXBkYXRlIjp0cnVlLCJpYXQiOjE0ODk0NDE1OTAsImlzcyI6IlZlcnQueCIsInN1YiI6Ildpa2kgQVBJIn0=.RmtJb81QKVUFreXL-ajZ8ktLGasoKEqG8GSQncRWrN8=

响应文本是令牌值并应保留。

我们可以检查执行不带令牌的API请求会导致拒绝访问：

$ http --verbose --verify no GET https://localhost:8080/api/pages
GET /api/pages HTTP/1.1
Accept: */*
Accept-Encoding: gzip, deflate
Connection: keep-alive
Host: localhost:8080
User-Agent: HTTPie/0.9.8



HTTP/1.1 401 Unauthorized
Content-Length: 12

Unauthorized

发送JWT令牌与请求一起使用AuthorizationHTTP请求头，其值必须是Bearer <token value>。以下是如何通过传递已发布给我们的JWT令牌来修复上面的API请求：

$ http --verbose --verify no GET https://localhost:8080/api/pages 'Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VybmFtZSI6InJvb3QiLCJjYW5DcmVhdGUiOnRydWUsImNhbkRlbGV0ZSI6dHJ1ZSwiY2FuVXBkYXRlIjp0cnVlLCJpYXQiOjE0ODk0NDE1OTAsImlzcyI6IlZlcnQueCIsInN1YiI6Ildpa2kgQVBJIn0=.RmtJb81QKVUFreXL-ajZ8ktLGasoKEqG8GSQncRWrN8='
GET /api/pages HTTP/1.1
Accept: */*
Accept-Encoding: gzip, deflate
Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VybmFtZSI6InJvb3QiLCJjYW5DcmVhdGUiOnRydWUsImNhbkRlbGV0ZSI6dHJ1ZSwiY2FuVXBkYXRlIjp0cnVlLCJpYXQiOjE0ODk0NDE1OTAsImlzcyI6IlZlcnQueCIsInN1YiI6Ildpa2kgQVBJIn0=.RmtJb81QKVUFreXL-ajZ8ktLGasoKEqG8GSQncRWrN8=
Connection: keep-alive
Host: localhost:8080
User-Agent: HTTPie/0.9.8



HTTP/1.1 200 OK
Content-Length: 99
Content-Type: application/json
Set-Cookie: vertx-web.session=0598697483371c7f3cb434fbe35f15e4; Path=/

{
    "pages": [
        {
            "id": 0,
            "name": "Hello"
        },
        {
            "id": 1,
            "name": "Apple"
        },
        {
            "id": 2,
            "name": "Vert.x"
        }
    ],
    "success": true
}

调整API测试夹具

本ApiTest类需要进行更新，以支持JWT令牌。

我们添加一个新字段来检索要在测试用例中使用的令牌值：

private String jwtTokenHeaderValue;

我们添加第一步来检索经过身份验证的JTW令牌foo：

1.  
   @Test
2.  
   public void play_with_api(TestContext context) {
3.  
   Async async = context.async();
4.  
    
5.  
   Future<String> tokenRequest = Future.future();
6.  
   webClient.get("/api/token")
7.  
   .putHeader("login", "foo") (1)
8.  
   .putHeader("password", "bar")
9.  
   .as(BodyCodec.string()) (2)
10.  
    .send(ar -> {
11.  
    if (ar.succeeded()) {
12.  
    tokenRequest.complete(ar.result().body()); (3)
13.  
    } else {
14.  
    context.fail(ar.cause());
15.  
    }
16.  
    });
17.  
    // (...)

1. 凭证作为标题传递。

2. 响应有效载荷是text/plain类型的，因此我们将其用于身体解码编解码器。

3. 一旦成功，我们tokenRequest用令牌值完成未来。

现在使用JWT令牌将其作为头传递给HTTP请求：

1.  
   Future<JsonObject> postRequest = Future.future();
2.  
   tokenRequest.compose(token -> {
3.  
   jwtTokenHeaderValue = "Bearer " + token; (1)
4.  
   webClient.post("/api/pages")
5.  
   .putHeader("Authorization", jwtTokenHeaderValue) (2)
6.  
   .as(BodyCodec.jsonObject())
7.  
   .sendJsonObject(page, ar -> {
8.  
   if (ar.succeeded()) {
9.  
   HttpResponse<JsonObject> postResponse = ar.result();
10.  
    postRequest.complete(postResponse.body());
11.  
    } else {
12.  
    context.fail(ar.cause());
13.  
    }
14.  
    });
15.  
    }, postRequest);
16.  
     
17.  
    Future<JsonObject> getRequest = Future.future();
18.  
    postRequest.compose(h -> {
19.  
    webClient.get("/api/pages")
20.  
    .putHeader("Authorization", jwtTokenHeaderValue)
21.  
    .as(BodyCodec.jsonObject())
22.  
    .send(ar -> {
23.  
    if (ar.succeeded()) {
24.  
    HttpResponse<JsonObject> getResponse = ar.result();
25.  
    getRequest.complete(getResponse.body());
26.  
    } else {
27.  
    context.fail(ar.cause());
28.  
    }
29.  
    });
30.  
    }, getRequest);
31.  
    // (...)

1. 我们将带有Bearer前缀的令牌存储在下一个请求的字段中。

2. 我们将令牌作为头部传递。