在上一节中我们完成了一个功能性的API，它能够创建用户，并且只允许用户操作自己添加的宠物。
在这一节中我们将着手创建一个OAuth2.0服务器，并允许授权用户或授权应用程序访问API接口。我们将通过OAuth2orize集成到我们的应用程序中来实现。
应用客户端（三方应用）
我们需要做的第一件事是添加一个新的模型，新的控制器，新的接口，用来创建新的应用客户端。
在models文件夹中创建client.js
var mongoose = require('mongoose');
var clientSchema = new mongoose.Schema({
name: { type: String, unique: true, required: true }, // 用于识别这个应用
id: { type: String, required: true }, // for oauth2.0 flow
secret: { type: String, required: true }, // for oauth2.0 flow
userId: { type: String, required: true } // 用于识别哪个用户添加了这个应用
});
module.exports = mongoose.model('client', clientSchema);
在controller文件夹中创建client.js
var Client = require('../models/client');
var postClients = function(req, res) {
var client = new Client();
client.name = req.body.name;
client.id = req.body.id;
client.secret = req.body.secret;
client.userId = req.user._id;
client.save(function(err) {
if (err) {
res.json({ message: 'error', data: err });
return;
}
res.json({ message: 'Client added to the locker!', data: client });
})
}
var getClients = function(req, res) {
Client.find({ userId: req.user._id }, function(err, clients) {
if (err) {
res.json({ message: 'error', data: err });
return;
}
res.json({ message: 'done', data: clients });
})
}
module.exports = {
postClients: postClients,
getClients: getClients
}
在server.js中增加clients路由
var clientController = require('./controllers/client');
...
router.route('/clients')
.post(authController.isAuthenticated, clientController.postClients)
.get(authController.isAuthenticated, clientController.getClients);
验证应用客户端
之前我们通过BasicStrategy对用户进行了认证，现在需要采用相同的方式对客户进行验证。
更新controller/auth.js，添加一个新的BasicStrategy,并设置一个导出，用于验证客户端进行身份验证。
var Client = require('../models/client');
...
passport.use('client-basic', new BasicStrategy(
function(username, password, callback) {
Client.findOne({ id: username }, function (err, client) {
if (err) { return callback(err); }
// No client found with that id or bad password
if (!client || client.secret !== password) { return callback(null, false); }
// Success
return callback(null, client);
});
}
));
...
exports.isClientAuthenticated = passport.authenticate('client-basic', { session : false });
在这里我们调用passport.use时不只提供了一个BasicStrategy对象。在这里我们给它了另一个名字client-basic，如果没有这个，我们将无法同时运行两个BasicStrategy。
我们新的BasicStrategy实现是使用提供的客户端ID来查找和客户端，并验证密码是否正确，如果验证通过则返回这个客户端。
授权码
我们需要创建另一个模型用来存储我们的授权码。这些是OAuth2流程中的一部分，我们拿到这个授权码后，用授权码来交换访问令牌。
我们需要创建code的模型。
在models文件夹中添加code.js
var mongoose = require('mongoose');
var codeSchema = new mongoose.Schema({
value: { type: String, required: true }, // 用于存储授权码,考虑加密
redirectUri: { type: String, required: true },
userId: { type: String, required: true },
clientId: { type: String, required: true }
});
module.exports = mongoose.model('code', codeSchema);
这是个非常简单的模型，用于存储授权码的值，redirectUri是存储在初始授权过程中提供的重写向Uri。userId用来存储用户的ID,clientId用来存储客户端的ID。
另外，考虑的安全性，需要对授权码进行加密。
访问令牌
现在我们需要创建存储我们的访问令牌的模型。访问信息是OAuth2.0流程中的最后一步，通过访问令牌，应用客户端可以代表用户请求资源。
在models文件夹中创建token.js
// Load required packages
var mongoose = require('mongoose');
// Define our token schema
var TokenSchema = new mongoose.Schema({
value: { type: String, required: true },
userId: { type: String, required: true },
clientId: { type: String, required: true }
});
// Export the Mongoose model
module.exports = mongoose.model('Token', TokenSchema);
本示例中访问令牌未进行加密，实际使用中一定要加密。
使用访问令牌进行身份验证
此前我们通过添加了第二个BasicStrategy，用来验证来自客户端的请求。现在我们要创建一个BearerStategy，这将允许我们通过OAuth令牌对代表用户的请求进行身份验证。
首先我们安装这个包：
npm install passport-http-bearer --save
更新controllers/auth.js文件，在passport中增加一个新的BearerStategy，并设置一个导出，用于验证应用客户端请求是否通过身份验证。
var BearerStrategy = require('passport-http-bearer').Strategy
var Token = require('../models/token');
...
passport.use(new BearerStrategy(
function(accessToken, callback) {
Token.findOne({value: accessToken }, function (err, token) {
if (err) { return callback(err); }
// No token found
if (!token) { return callback(null, false); }
User.findOne({ _id: token.userId }, function (err, user) {
if (err) { return callback(err); }
// No user found
if (!user) { return callback(null, false); }
// Simple example with no scope
callback(null, user, { scope: '*' });
});
});
}
));
...
exports.isBearerAuthenticated = passport.authenticate('bearer', { session: false });
这个新策略将允许我们使用Oauth 令牌接受来自应用客户端的请求，并让我们验证这些请求。
用于授权应用客户端访问的简单UI
更新server.js
var ejs = require('ejs');
...
// Create our Express application
var app = express();
// Set view engine to ejs
app.set('view engine', 'ejs');
接着我们创建一个视图，让用户授权或拒绝应用客户端访问其账户。
views文件夹中创建dialog.ejs
<!DOCTYPE html>
<html>
<head>
<title>Beer Locker</title>
</head>
<body>
<p>Hi
<%= user.username %>!</p>
<p><b><%= client.name %></b> is requesting <b>full access</b> to your account.</p>
<p>Do you approve?</p>
<form action="/api/oauth2/authorize" method="post">
<input name="transaction_id" type="hidden" value="<%= transactionID %>">
<div>
<input type="submit" value="Allow" id="allow">
<input type="submit" value="Deny" name="cancel" id="deny">
</div>
</form>
</body>
</html>
稍后我们将跳到这个页面。
启用session
OAuth2orize需要请求session状态用来正确的完成授权过程。为了做到这一点，我们需要安装express-session包。
更新server.js
var session = require('express-session');
...
// Set view engine to ejs
app.set('view engine', 'ejs');
// Use the body-parser package in our application
app.use(bodyParser.urlencoded({
extended: true
}));
// Use express session support since OAuth2orize requires it
app.use(session({
secret: 'Super Secret Session Key',
saveUninitialized: true,
resave: true
}));
创建OAuth2 controller
首先，安装 oauth2orize包
npm install oauth2orize --save
在controllers文件夹中创建oauth2.js
加载需要的包
// Load required packages
var oauth2orize = require('oauth2orize')
var User = require('../models/user');
var Client = require('../models/client');
var Token = require('../models/token');
var Code = require('../models/code');
创建OAuth2服务
// 创建OAuth2.0服务
var server = oauth2orize.createServer();
注册序列化和反序列化访问
// 注册 序列化 serializeClient 方法
// 当client重定向用户到用户授权页面，授权过程被启动，为完成这个过程，用户必做批准授权请求
// 因为这可能涉及多个HTTP请求/响应交换，交易需要存储的会话中
server.serializeClient(function(client, callback) {
return callback(null, client._id);
});
// 注册 反序列化 deserializeClient 方法
server.deserializeClient(function(id, callback) {
Client.findOne({ _id: id }, function(err, client) {
if (err) {
return callback(err);
}
return callback(null, client);
})
});
注册授权码模式
server.grant(oauth2orize.grant.code(function(client, redirectUri, user, ares, callback) {
console.log("code oauth2orize");
console.log(client);
var code = new Code({
value: uid(16),
redirectUri: redirectUri,
userId: client.userId,
clientId: client._id
});
code.save(function(err) {
if (err) {
return callback(err);
}
console.log(code);
return callback(null, code.value);
});
}));
授权码交换访问令牌
server.exchange(oauth2orize.exchange.code(function(client, code, redirectUri, callback) {
console.log("exchange oauth2orize");
console.log(client);
console.log(code);
Code.findOne({ value: code }, function(err, authCode) {
if (err) {
return callback(err);
}
if (authCode === null) {
return callback(null, false);
}
if (client._id.toString() !== authCode.clientId) {
return callback(null, false);
}
if (redirectUri !== authCode.redirectUri) {
return callback(null, false);
}
// code被使用后删除
authCode.remove(function(err) {
if (err) {
return callback(err);
}
// 创建新的access token
var token = new Token({
value: uid(256),
clientId: authCode.clientId,
userId: authCode.userId
});
console.log(token);
token.save(function(err) {
if (err) {
return callback(err);
}
return callback(null, token);
})
})
})
}))
请求用户授权
exports.authorization = [
server.authorization(function(clientId, redirectUri, callback) {
console.log(clientId);
Client.findOne({ id: clientId }, function(err, client) {
if (err) {
return callback(err);
}
console.log(client);
return callback(null, client, redirectUri);
});
}),
function(req, res) {
console.log(req.oauth2);
res.render('dialog', {
transactionID: req.oauth2.transactionID,
user: req.user,
client: req.oauth2.client
});
}
]
用户决定授权
// User decision endpoint
exports.decision = [
server.decision()
]
用户批准或拒绝后的处理，调用server.grant处理提交的数据
应用客户端令牌交换
exports.token = [
server.token(),
server.errorHandler()
]
客户端得到授权码之后server.token函数将调用server.exchange来用授权码交换令牌。
sever.js中添加Oauth2.0路由
var oauth2Controller = require('./controllers/oauth2');
...
// 创建oauth2 授权接口
router.route('/oauth2/authorize')
.get(authController.isAuthenticated, oauth2Controller.authorization) // 启动授权过程
.post(authController.isAuthenticated, oauth2Controller.decision); // 用户决定授权后的调整
// 创建oauth2 访问令牌接口
router.route('/oauth2/token')
.post(authController.isClientAuthenticated, oauth2Controller.token); // 得到code后的调用
api接口增加访问令牌授权
目前，我们使用用户名/密码的BasicStrategy进行授权，我们需要增加BearerStrategy用来允许它使用访问令牌授权。
更新controllers/auth.js中的isAuthenticated
exports.isAuthenticated = passport.authenticate(['basic', 'bearer'], { session : false });
我们在接口上使用了isAuthenticated，所以更新isAuthenticated将允许授权用户名/密码和访问令牌。
使用我们的OAuth2.0服务器
image.png
点击 Allow后跳到
image.png
为什么会返回404页面呢，在OAuth2.0的授权流程中，当客户端得到授权码后，是由客户端的服务端发送一个请求，用授权码来获取访问令牌的。
在这里我们使用Postman来模仿这个客户端的服务端
image.png
image.png
接下来我们测试我们的访问令牌
image.png
随意玩一下。 随便改变访问令牌，会发现你是未经授权的。 切换回用户名和密码来验证用户仍然有权访问。
