标签: express-session

我尝试在NodeJS中使用Redis的标准会话持久性:

var express = require('express');
var RedisStore = require('connect-redis')(express);
var app = module.exports = express.createServer();

// Configuration

app.configure(function(){
  app.use(express.bodyParser());
  app.use(express.cookieParser());
  app.use(express.session({ 
    secret: "keyboard cat", 
    store: new RedisStore, 
    key: 'sid' 
  }));
});


app.get('/', function (req, res) {
  if (req.session.isValid) {
    console.log("There is an existing session.");
  }
  else {
    req.session.isValid = true;
    console.log("New session.");
    console.log('Old session ID: ' + req.header('Cookie'));
    console.log('New session ID: ' + req.session.id);
  }

  res.render('index', {'title': s});
});
app.listen(4000);

从理论上讲,我应该看到"新会议"这一行.网站的一次和所有后续调用应导致"存在现有会话".不幸的是,每次调用都会重新生成新的会话ID.浏览器中的cookie工作正常,内容正确传输,我可以看到它

req.header('Cookie')

这是控制台日志的样子:

[app.js] New session.
[app.js] Old session ID: …

这是一个使用快速会话存储的简单连接,即使文本是正确的,它仍然会发出这个错误.我很确定与"新MongoStore"对象初始化有关.

var express = require('express'),
    expressSession = require('express-session');

var MongoStore = require('connect-mongo/es5')(expressSession);
var sessionStore = new MongoStore({
  host: '127.0.0.1',
  port: '27017',
  db: 'session'
});

var app = express()
    .use(expressSession({
      secret: 'my secret sign key',
      store: sessionStore
     }))
    .use('/home', function (req, res) {
      if (req.session.views) {
        req.session.views++;
      }
      else {
        req.session.views = 1;
      }
      res.end('Total views for you:' + req.session.views);
    })
    .use('/reset', function(req, res) {
      delete req.session.views;
      res.end('Cleared all your views');
    })
    .listen(3000);

我有一个 React 应用程序调用 node.js/Express 中的 API。

前端部署在 Netlify (https)，​​后端部署在 Heroku (https)。

我的问题：

• 在开发环境（本地主机）中工作的一切
• 在生产（Netlify/Heroku）中，用于注册和登录的 api 调用似乎有效，但会话 cookie 未存储在浏览器中。因此，对 API 中受保护路由的任何其他调用都会失败（因为我没有收到用户凭据）。

说话很便宜，给我看代码....

后端（Express API）：

• 我正在使用护照（本地策略）、express-session、cors。

应用程序.js

require('./configs/passport');

// ...

const app = express();

// trust proxy (https://stackoverflow.com/questions/64958647/express-not-sending-cross-domain-cookies)
app.set("trust proxy", 1); 

app.use(
  session({
    secret: process.env.SESSION_SECRET,
    cookie: {
      sameSite: process.env.NODE_ENV === "production" ? 'none' : 'lax',
      maxAge: 60000000,
      secure: process.env.NODE_ENV === "production",
    },
    resave: true,
    saveUninitialized: false,
    ttl: 60 * 60 * 24 * 30 …

我正在使用 npm 包进行 Typescript 项目。我想向 Express.Session 接口添加一个属性。

示例类：

class User {
    name: string;
    email: string;
    password: string;
}

export = User;

接口定义的新 d.ts 文件（不想编辑 express-session.d.ts）：

declare namespace Express {
    interface Session {
        user: User
    }
}

应用程序

import User = require('./User');

function (req: express.Request, res: express.Response) {
    req.session.user //I want to use it like this.
}

问题是，在 de d.ts 文件中不知道该用户。但是既不需要也不需要导入用户文件来解决这个问题。

如何将我自己的类添加到会话界面？

目前还不清楚在使用Redis Cloud和Heroku的情况下使用的正确配置参数是什么,并且无法在线找到正常运行的示例.

这是我目前的代码:

const express = require('express')
const session = require('express-session')
const RedisStore = require('connect-redis')(session);
...
const server = express()

server.use(bodyParser.json())
server.use(bodyParser.urlencoded({ extended: false }))

server.use(cookieParser())

server.use(session({
  secret: token_secret,
  // create new redis store.
  store: new RedisStore({ url: 'redis://rediscloud:...@...redislabs.com:11111'}),
  resave: true,
  saveUninitialized: true
}));

在Redis Cloud和Heroku作为会话存储(使用快速会话)的情况下,我是否应该重新保存并将unitialized设置为true或false？

另外,cookieParser是否影响会话并且需要在那里？或者它是独立的,只是解析来自客户端的cookie,与Redis的服务器端会话存储无关？此外,cookie解析器是否应该将秘密传递给函数？

最后,bodyParser应该在server.use(session)之前还是之后,urlencoded extended应该设置为true还是false？

我目前有一个React App(via create-react-app)和一个Express服务器用于我的API调用.它们都是单独运行的,并且一直工作正常,直到我遇到这个问题:

我也在使用express-session和passport进行用户身份验证.我能够对用户进行身份验证,但会话不会在API调用之间持续存在.如果我成功登录,下次进行API调用时,req.sessionID将会有所不同,req.isAuthenticated()并将返回false.

这是我的服务器代码:

'use strict'

var express         = require('express');
var path                = require('path');
var bodyParser      = require('body-parser');
var cookieParser    = require('cookie-parser');
var mongoose      = require('mongoose');
var passport      = require('passport');
var session       = require('express-session');
var cors          = require('cors');
var flash         = require('connect-flash');

var store         = require('./store');
var database      = require('./database');

var app     = express();
var port    = process.env.port || 3001;
var router  = express.Router();

var promise = mongoose.connect('mongodb://localhost:27017/lifeless-db', …

所以我使用express-session包来设置cookie和会话。它还连接到我的 MongoDB 存储来存储会话。当用户登录时，会话会很好地存储在数据库中，但浏览器中没有 cookie。我的应用程序正在运行http://localhost:8080/，我的服务器正在运行http://localhost:5500/。

索引.js：

const express = require('express');
const app = express();
const bodyParser = require('body-parser');
const expressSession = require('express-session');
const mStore = require('./model/database.js').Mstore;
const routes = require('./control/router.js');
const mongooseConnect = require('./model/database.js').mongooseConnect;


app.use(
   expressSession({ 
      secret: 'my secret', 
      resave: false, 
      saveUninitialized: false,
      store: mStore
   }),
   bodyParser.urlencoded({ extended: true }),
   bodyParser.json(),
   routes
);


mongooseConnect(() => app.listen(process.env.PORT || 5500));

路由器.js：

const express = require('express');
const router = express.Router();
const notesModel = require('../model/database.js').notesModel;
const userModel …

app.use(session({
    secret: "testing credentials",
    store: sessionStore,
    resave: true,
    saveUninitialized: true,
    cookie  : {
        httpOnly: true,
        //secure: true,
        maxAge  : 60 * 60 * 1000 
    }
}));

我正在解决我新开发的网站上的一些安全问题。并且在网上查了一些资料，如果设置了secure=true，那就更安全了。但是，如果设置secure: true，则每次用户发送另一个请求时，会话中的信息都会丢失。有没有办法解决这个问题？如果 cookie: 中不包含“secure: true”，则会话将持续该 maxAge。

当不使用安全 cookie true 设置时，我的应用程序用户登录工作正常。当我启用安全 cookie 时，登录似乎顺利通过，但似乎 cookie 未保存且用户未登录。

换句话说，这有效：

app = express();
app.use(session({
    secret: 'secret code',
    store: sessionStore,
    resave: false,
    saveUninitialized: false,
    cookie: {
        secure: false,
        maxAge: 5184000000 // 60 days
        }
}));

这不起作用（用户无法登录）：

app = express();
app.set('trust proxy');
app.use(session({
    secret: config.cookieSecret,
    store: sessionStore,
    resave: false,
    saveUninitialized: false,
    proxy: true,
    secureProxy: true,
    cookie: {
        secure: true,
        httpOnly: true,
        maxAge: 5184000000 // 60 days
        }
}));

在 cloudflare 和 nginx 背后。这是在我的 nginx 配置中：

location ~ / {
    proxy_set_header Host $host;
    proxy_set_header …

我是 NodeJS 的初学者。我正在研究一个简单的基于会话的用户授权来尝试一下，它工作得很好，因为互联网上有很多很容易理解的示例。我使用了express-session和以下代码：

app.use(session({
    key: 'userid',
    secret: 'hojoborolo',
    resave: false,
    saveUninitialized: false,
    cookie: {
        expires: 600000
    }
}));

创建了一个简单的会话，然后我可以使用req.session对象访问该会话。

我访问了快速会话文档以获取有关会话数据的更多信息。它明确表示“会话数据不保存在cookie本身中，只是保存会话ID。会话数据存储在服务器端。默认的服务器端会话存储是MemoryStore。”

像PHP一样，简单的PHPSESSID会话数据存储在/tmp服务器端默认临时目录下的文件中，MemoryStore这些数据在服务器端的位置以及如何存储并利用它？基本上如何MemoryStore运作？

PS：来自 PHP 背景