token 订阅
在计算机身份认证中是令牌(临时)的意思,在词法分析中是标记的意思。一般作为邀请、登录系统使用。 展开全文
在计算机身份认证中是令牌(临时)的意思,在词法分析中是标记的意思。一般作为邀请、登录系统使用。
信息
学    科
信息技术(IT)
外文名
Token
词    性
名词
中文名
令牌,标记
Token令牌
(信息安全术语)Token, 令牌,代表执行某些操作的权利的对象访问令牌(Access token)表示访问控制操作主体的系统对象邀请码,在邀请系统中使用Token, Petri 网(Petri net)理论中的Token密保令牌(Security token),或者硬件令牌,例如U盾,或者叫做认证令牌或者加密令牌,一种计算机身份校验的物理设备会话令牌(Session token),交互会话中唯一身份标识符令牌化技术 (Tokenization), 取代敏感信息条目的处理过程
收起全文
精华内容
参与话题
问答
  • 本文介绍jwt token在laravel中的安装使用,解决token验证的问题 一、查看laravel版本选定适合自己框架的jwt版本,不同版本之间会有意想不到的惊喜(坑) 根据自己laravel版本不同使用jwt-auth版本建议如下: ...

    本文介绍jwt token在laravel中的安装使用,解决token验证的问题

    一、查看laravel版本选定适合自己框架的jwt版本,不同版本之间会有意想不到的惊喜(坑)

    根据自己 laravel版本不同使用jwt-auth版本建议如下:

     

    Laravel versionjwt-auth version
    4.* 0.3.* 0.4.*
    5.* && <5.5 0.5.*
    5.* 1.0.*

    以上只是参考,本人在laravel5.4也成功使用了1.0.0-rc.3版本下面详细描述下具体的安装以及使用

    通过composer安装的两种方式

    1>composer require tymon/jwt-auth 1.0.0-rc.3(本人使用的版本)直接在项目目录下执行该命令等待安装即可

    2>打开composer.json在require中添加如下,然后执行composer update即可,但是这样会把composer.json中其他的扩展也一并更新了

    "require": {
    "tymon/jwt-auth": "1.0.0-rc.3"
    },

    将jwt加载到项目中之后进行一下配置首先

    执行命令:

    php artisan vendor:publish --provider="Tymon\JWTAuth\Providers\LaravelServiceProvider"
    该命令的含义是发布jwt的配置文件,文件位置存储在config下该文件中存储了一系列的jwt的配置例如生存时间,token刷新时间等等创建之后执行命令
    php artisan jwt:secret,该命令为创建jwt secret秘钥在,env文件中可以看到

    然后在服务容器中创建jwt的服务提供者打开config/app.php在'providers'数组中添加

    Tymon\JWTAuth\Providers\LaravelServiceProvider::class,或者该版本指定的添加服务提供者之后在该文件下aliases中添加门面
    'JWTAuth' => Tymon\JWTAuth\Facades\JWTAuth::class,
    'JWTFactory' => Tymon\JWTAuth\Facades\JWTFactory::class,
    添加门面之后在控制器中使用时可以直接 use JWTAuth;
    要想使得我们每次的接口都经受token的验证可以借助中间件,要使用中间件需要在app\Http\Kernel.php文件中的
    $routeMiddleware数组中添加如下:
    // jwttoken 中间件
    'jwt.auth' => \Tymon\JWTAuth\Http\Middleware\Authenticate::class,(该中间件则按照token规则验证)
    'jwt.refresh' => \Tymon\JWTAuth\Http\Middleware\RefreshToken::class,(该中间件表示请求一次token就失效了)
    添加好以上配置之后我们着手控制器和模型
    在模型中
    use Tymon\JWTAuth\Contracts\JWTSubject;
    class User extends Authenticatable implements JWTSubject
    并且添加以下方法
    public function getJWTIdentifier() {
    return $this->getKey();
    }
    public function getJWTCustomClaims() {
    return [];
    }

    然后需要更改下我们的auth.php配置文件因为在路由时要指定何种验证方式
    'guards' => [
    ...
    'api' => [
    'driver' => 'jwt',
    'provider' => 'users',
    ],
    ],
    更改之后路由中要这样才能生效
    Route::middleware('jwt.auth')->get('users', function () {
    return auth('api')->user();
    });
    这样路由就能经过指定的中间件jwt.auth过滤,然后经auth('api)这里指定了验证方式就是对应刚刚讲到的auth.php中的配置项
    如果你想让token的验证信息更加温暖,那么你可以捕获token验证的异常具体做法
    打开文件app/Exceptions/Handler.phprender方法开头使用如下代码
    use Symfony\Component\HttpKernel\Exception\UnauthorizedHttpException;

    if ($exception instanceof UnauthorizedHttpException) {
    $preException = $exception->getPrevious();
    if ($preException instanceof
    \Tymon\JWTAuth\Exceptions\TokenExpiredException) {
    return response()->json(['error' => 'TOKEN_EXPIRED']);
    } else if ($preException instanceof
    \Tymon\JWTAuth\Exceptions\TokenInvalidException) {
    return response()->json(['error' => 'TOKEN_INVALID']);
    } else if ($preException instanceof
    \Tymon\JWTAuth\Exceptions\TokenBlacklistedException) {
    return response()->json(['error' => 'TOKEN_BLACKLISTED']);
    }
    if ($exception->getMessage() === 'Token not provided') {
    return response()->json(['error' => 'Token not provided']);
    }
    }
    每一error都能自定义你自己的提示语
    下面是获取token的方法
    在控制器中使用use
    JWTAuth;
    读取到用户信息将用户信息作为参数例如
    $data={'mobile':12345667,'password:2342342}
    $token = JWTAuth::fromUser($data);
    这样就能拿到token
    如果我们想解析token可以使用
    JWTAuth::user()
    该方法可以将验证通过的用户信息全部提取出来
    JWTAuth.php中方法
    attempt()  尝试对用户进行身份验证并返回令牌
    authenticate()  通过令牌对用户进行身份验证
    user()       获取经过身份验证的用户


     
     

     

    转载于:https://www.cnblogs.com/mzli/p/10637214.html

    展开全文
  • c# JSON WEB TOKEN JWT.dll

    2019-07-18 10:08:10
    生成token工具,webapi 接口 token JWT的Web API身份验证Json Web Token(jwt)是一种不错的身份验证及授权方案,简单的说就是调用端调用api时,附带上一个由api端颁发的token,以此来验证调用者的授权信息。
  • token jwt配置

    2019-05-05 11:31:00
    1. token jwt配置 1.1. pom <!-- token验证 --> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt</artifactId> ...

    1. token jwt配置

    1.1. pom

            <!-- token验证 -->
            <dependency>
                <groupId>io.jsonwebtoken</groupId>
                <artifactId>jjwt</artifactId>
                <version>0.9.1</version>
            </dependency>

    1.2. 代码

    1.2.1. 生成token

    @Configuration
    public class JwtToken {
    
        /**
         * 生成jwt token
         */
        public Token generateToken(Long userId) {
            Date date = new Date();
            SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
            Date expiration = DateUtils.addDays(new Date(), 3);
            String token = Jwts.builder()
                    // 设置header
                    .setHeaderParam("typ", "JWT")
                    // 设置签发时间
                    .setHeaderParam("alg", "HS256").setIssuedAt(date)
                    .setExpiration(expiration)
                    // 设置内容
                    .claim("userId", String.valueOf(userId))
                    // 设置签发人
                    .setIssuer("lll")
                    // 签名,需要算法和key
                    .signWith(signatureAlgorithm, "xxxxx").compact();
            return new Token().setExpireTime(expiration).setToken(token).setUserId(userId);
        }
    
    }

    1.2.2. token拦截器

    public class TokenInterceptor implements HandlerInterceptor {
    
        @Autowired
        private ITokenService tokenService;
    
        @Autowired
        private JwtToken jwtToken;
    
        private Map<Long, Token> tokenMap = new ConcurrentHashMap<>();
    
        public Set<String> passPath = new HashSet<>();
    
        /**
         * 添加token
         *
         * @param userId
         * @return
         */
        public Token addToken(Long userId) {
            Token token = jwtToken.generateToken(userId);
            tokenMap.put(userId, token);
    
            Token tk = tokenService.getById(userId);
            if (tk != null) {
                tokenService.updateById(token);
            } else {
                tokenService.save(token);
            }
            return token;
        }
    
        public TokenInterceptor() {
            init();
        }
    
        @Value("${token.enabled:false}")
        public boolean openToken;
    
        /**
         * token开关
         *
         * @param openToken
         */
        public void setOpenToken(boolean openToken) {
            this.openToken = openToken;
        }
    
        @PostConstruct
        private void init() {
            passPath.add("/fund/user/");
            passPath.add("/fund/user/login");
        }
    
        private boolean isFilter(String uri) {
            if (!openToken) {
                return true;
            }
            return passPath.stream().anyMatch(s -> s.equals(uri));
        }
    
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object arg2) throws Exception {
            //普通路径放行
            if (isFilter(request.getRequestURI())) {
                return true;
            }
    
            //权限路径拦截
            response.setCharacterEncoding("UTF-8");
            final String headerToken = request.getHeader("x-access-token");
            //判断请求信息
            if (null == headerToken || "".equals(headerToken.trim())) {
                response.getWriter().write("用户未登录,请先登录");
                return false;
            }
            //解析Token信息
            try {
                Claims claims = Jwts.parser().setSigningKey("beikbank@fund").parseClaimsJws(headerToken).getBody();
                String tokenUserId = (String) claims.get("userId");
                Long itokenUserId = Long.parseLong(tokenUserId);
                //根据客户Token查找缓存Token
                Token myToken = tokenMap.get(itokenUserId);
    
                //缓存没有Token记录
                if (null == myToken) {
                    Token token = tokenService.getById(itokenUserId);
                    if (token != null) {
                        if (judgeToken(response, headerToken, claims, itokenUserId, token)) {
                            return false;
                        }
                    }
                    return true;
                }
                if (judgeToken(response, headerToken, claims, itokenUserId, myToken)) {
                    return false;
                }
    
            } catch (Exception e) {
                e.printStackTrace();
                response.getWriter().write("发生异常,请重新登录");
                return false;
            }
            //最后才放行
            return true;
        }
    
        private boolean judgeToken(HttpServletResponse response, String headerToken, Claims claims, Long itokenUserId, Token myToken) throws IOException {
            //缓存Token与客户Token比较
            if (!headerToken.equals(myToken.getToken())) {
                response.getWriter().write("token不正确,请重新登录");
                return true;
            }
            //判断Token过期
            Date tokenDate = claims.getExpiration();
            if (tokenDate.before(new Date())) {
                tokenMap.remove(itokenUserId);
                tokenService.removeById(itokenUserId);
                response.getWriter().write("token过期,请重新登录");
                return true;
            }
            return false;
        }
    }

    1.2.3. 设置token

    1. token设置,在登录时设置
        @Autowired
        private TokenInterceptor tokenInterceptor;
    
        @ApiOperation(value = "用户登录", notes = "用户登录")
        @RequestMapping(value = "/login", method = RequestMethod.POST)
        public ResponseEntity login( @RequestBody @ApiParam(name = "user", value = "用户", required = true) @Valid User user) {
            boolean result = userService.vaildLogin(user);
            Token token = tokenInterceptor.addToken(user.getUserId());
            return ResponseEntity.ok(result ? ok(token) : error("登录失败,请检查用户名和密码"));
        }

    转载于:https://www.cnblogs.com/sky-chen/p/10812091.html

    展开全文
  • C++ token JWT HS256 生成token和验证token

    千次阅读 2018-02-01 23:29:21
    使用到的类库 jsoncpp:用于json数据操作 boost:智能指针和正则表达,如果是C++11以上版本可以替换成C++11的智能指针和正则表达式 CryptoPP:大名鼎鼎的免费的C++加解密类库,Crypto++几乎涵盖了所有的加解密算法 ...

    使用到的类库

    jsoncpp:用于json数据操作

    boost:智能指针和正则表达,如果是C++11以上版本可以替换成C++11的智能指针和正则表达式

    CryptoPP:大名鼎鼎的免费的C++加解密类库,Crypto++几乎涵盖了所有的加解密算法

    以上类库是可以跨平台使用

    代码

    宏定义请参看负载均衡权重系数算法 C++中的se_std.h

    头文件

    #include <string>
    #include  <strstream>
    #include <boost/noncopyable.hpp>
    #include <boost/scoped_ptr.hpp>
    #include <boost/regex.hpp>
    #include <json/json.h>
    #include "se_std.h"
    #include "se_conf.h"
    #include <base64.h>
    #include  <hmac.h>
    #include  <sha.h>
    
    using namespace std;
    
    #ifndef H_3695350A_4107_49D7_BE41_60F19549BD53
    #define H_3695350A_4107_49D7_BE41_60F19549BD53
    
    /*
    *	Author:
    *	Version:1.0
    *	Copyright:
    *	Description:	生成token和验证token
    *						https://jwt.io/introduction/
    *	Create:2018-02-01
    *	LastChange:2018-02-01
    */
    class se_token : public boost::noncopyable {
    private:
    	const int FLAG;
    	CryptoPP::HMAC< CryptoPP::SHA256 > m_hs256;
    	boost::scoped_ptr<Json::StreamWriter> m_jwrite;
    	boost::scoped_ptr<Json::CharReader> m_jread;
    	stringstream m_strbuf;
    	string m_header, m_header_base64;
    	Json::Value m_jheader;
    	boost::regex m_reg_exp;
    	char m_numbuf[SE_MAX_NUMSTR];
    public:
    	se_token()
    		:FLAG(CryptoPP::HashVerificationFilter::PUT_RESULT | CryptoPP::HashVerificationFilter::HASH_AT_END) {
    		this->init();
    	};
    	se_token(const CryptoPP::SecByteBlock &key)
    		:m_hs256(key, key.size()),
    		FLAG(CryptoPP::HashVerificationFilter::PUT_RESULT | CryptoPP::HashVerificationFilter::HASH_AT_END) {
    		this->init();
    	};
    	virtual ~se_token() {};
    private:
    	/*初始化*/
    	void init();
    	/*清除字符缓冲区内容*/
    	inline void clear(stringstream &strbuf) const {
    		strbuf.str(""); strbuf.clear();
    	}
    private:
    	void parse_token(const string &token, string &msg, string &b64payload, string &b64sig) const;
    public:
    	/*设置HMAC key*/
    	inline void set_key(const CryptoPP::SecByteBlock &key) {
    		this->m_hs256.SetKey(key, key.size());
    	}
    	/*设置HMAC key(key为base64编码)*/
    	void set_key_base64(const string &b64key);
    	/*生成key*/
    	void generate_key(string &b64key) const;
    	/*生成签名*/
    	void signature(const string &plain, string &mac);
    	/*生成签名(签名为base64编码)*/
    	void signature_base64(const string &plain, string &b64);
    	/*验证签名*/
    	bool verify(const string &msg, const string &signature);
    	/*验证签名(签名为base64编码)*/
    	bool verify_base64(const string &msg, const string &b64);
    	/*获取JWT Header信息*/
    	inline const string &header() const {
    		return this->m_header;
    	}
    	/*获取JWT Header信息*/
    	inline const Json::Value &header_json() const {
    		return this->m_jheader;
    	}
    	/*	根据json生成token
    	*	注意,生成的token如要附件在url中必须采用url_encode后输出
    	*/
    	void generate_token(const Json::Value &payload, string &token);
    	/*	根据payload json格式字符串生成token
    	*	注意,生成的token如要附件在url中必须采用url_encode后输出
    	*/
    	void generate_token(const string &payload, string &token);
    	/*解析token*/
    	void parse_token(const string &token, Json::Value &payload);
    	/*更新token的过期时间*/
    	void update_expires(const se_conf_server &conf, string &token);
    };
    
    #endif /* H_3695350A_4107_49D7_BE41_60F19549BD53 */
    

    源文件

    #include "se_token.h"
    #include <osrng.h>
    
    #define  HS256KEY ("eoRK6DnPRTbQ72oEG+ANFg==")
    
    void se_token::init() {
    	Json::StreamWriterBuilder writer;
    	writer["commentStyle"] = "None";
    	writer["indentation"] = "";  // or whatever you like	
    	writer["precision"] = 6;
    	this->m_jwrite.reset(writer.newStreamWriter());
    
    	Json::CharReaderBuilder rbuilder;
    	this->m_jread.reset(rbuilder.newCharReader());
    
    	this->m_header = "{\"typ\":\"JWT\",\"alg\":\"HS256\"}";
    	CryptoPP::StringSource(this->m_header, true,
    		new CryptoPP::Base64Encoder(
    			new CryptoPP::StringSink(this->m_header_base64), false
    		)
    	);
    
    	this->m_reg_exp = "(\\\"exp\\\")\\:(\\d+)";
    
    	this->m_jheader["typ"] = "JWT";
    	this->m_jheader["alg"] = "HS256";
    	this->set_key_base64(HS256KEY);
    }
    
    void se_token::generate_key(string &b64key) const {
    	CryptoPP::AutoSeededRandomPool prng;
    	CryptoPP::SecByteBlock key(16);
    	prng.GenerateBlock(key, key.size());
    
    	CryptoPP::StringSource(key, key.size(), true,
    		new CryptoPP::Base64Encoder(
    			new CryptoPP::StringSink(b64key), false
    		)
    	);
    }
    
    void se_token::set_key_base64(const string &b64key) {
    	CryptoPP::SecByteBlock key;
    	string encoded;
    	CryptoPP::StringSource(b64key, true,
    		new CryptoPP::Base64Decoder(
    			new CryptoPP::StringSink(encoded)
    		)
    	);
    	key.Assign((const byte *)encoded.c_str(), encoded.size());
    	this->set_key(key);
    }
    
    void se_token::signature(const string &plain, string &mac) {
    	mac.clear();
    	CryptoPP::StringSource ss1(plain, true,
    		new CryptoPP::HashFilter(this->m_hs256,
    			new CryptoPP::StringSink(mac)
    		)
    	);
    
    }
    
    void se_token::signature_base64(const string &plain, string &b64) {
    	string mac;
    	b64.clear();
    	this->signature(plain, mac);
    	CryptoPP::StringSource(mac, true,
    		new CryptoPP::Base64Encoder(
    			new CryptoPP::StringSink(b64), false
    		)
    	);
    }
    
    bool se_token::verify(const string &msg, const string &signature) {
    	bool result = false;
    	CryptoPP::StringSource ss(msg + signature, true,
    		new CryptoPP::HashVerificationFilter(this->m_hs256,
    			new CryptoPP::ArraySink((byte*)&result, sizeof(result)),
    			FLAG
    		)
    	);
    	return result;
    }
    
    bool se_token::verify_base64(const string &msg, const string &b64sig) {
    	string signature;
    	CryptoPP::StringSource(b64sig, true,
    		new CryptoPP::Base64Decoder(
    			new CryptoPP::StringSink(signature)
    		)
    	);
    	return this->verify(msg, signature);
    }
    
    void se_token::generate_token(const Json::Value &payload, string &token) {
    	this->clear(this->m_strbuf);
    	ostream stream(this->m_strbuf.rdbuf());
    	this->m_jwrite->write(payload, &stream);
    	string str_payload = this->m_strbuf.str();
    	this->clear(this->m_strbuf);
    
    	string payload_base64, signature;
    	CryptoPP::StringSource(str_payload, true,
    		new CryptoPP::Base64Encoder(
    			new CryptoPP::StringSink(payload_base64), false
    		)
    	);
    
    	token.clear();
    	token.append(this->m_header_base64).append(".").append(payload_base64);
    	this->signature_base64(token, signature);
    	token.append(".").append(signature);
    }
    
    void se_token::generate_token(const string &payload, string &token) {
    	string payload_base64, signature;
    	CryptoPP::StringSource(payload, true,
    		new CryptoPP::Base64Encoder(
    			new CryptoPP::StringSink(payload_base64), false
    		)
    	);
    
    	token.clear();
    	token.append(this->m_header_base64).append(".").append(payload_base64);
    	this->signature_base64(token, signature);
    	token.append(".").append(signature);
    }
    
    void se_token::parse_token(const string &token, string &msg, string &b64payload, string &b64sig) const {
    	string::size_type pos1 = token.find(".");
    	string::size_type pos2 = token.find(".", pos1 + 1);
    	if (string::npos == pos1 || string::npos == pos2)
    		SE_THROW("invalid token!");
    	msg = token.substr(0, pos2);
    	++pos1;
    	b64payload = token.substr(pos1, pos2 - pos1);
    	++pos2;
    	b64sig = token.substr(pos2);
    }
    
    void se_token::parse_token(const string &token, Json::Value &payload) {
    	string msg, b64payload, b64sig;
    	this->parse_token(token, msg, b64payload, b64sig);
    	if (!this->verify_base64(msg, b64sig))
    		SE_THROW("lllegal token!");
    
    	string plian, tmp;
    	CryptoPP::StringSource(b64payload, true,
    		new CryptoPP::Base64Decoder(
    			new CryptoPP::StringSink(plian)
    		)
    	);
    
    	const char *ptr_start = plian.c_str();
    	const char *ptr_end = ptr_start + plian.size();
    	bool parsingSuccessful = this->m_jread->parse(ptr_start, ptr_end, &payload, &tmp);
    	if (!parsingSuccessful)
    		SE_THROW(tmp);
    }
    
    void se_token::update_expires(const se_conf_server &conf, string &token) {
    	string msg, b64payload, b64sig;
    	this->parse_token(token, msg, b64payload, b64sig);
    	if (!this->verify_base64(msg, b64sig))
    		SE_THROW("invalid token!");
    
    	string plian;
    	CryptoPP::StringSource(b64payload, true,
    		new CryptoPP::Base64Decoder(
    			new CryptoPP::StringSink(plian)
    		)
    	);
    
    	/*获取当前时间*/
    	const time_t tt = time(NULL);
    	time_t exp = tt + conf.expires();
    #if defined(_MSC_VER)
    	_snprintf_s(this->m_numbuf, SE_MAX_NUMSTR, "$1:%I64d", exp);
    #else
    	snprintf(this->m_numbuf, SE_MAX_NUMSTR, "$1:%lld", exp);
    #endif
    	//替换过期时间
    	std::string result = boost::regex_replace(plian, this->m_reg_exp, this->m_numbuf);
    	this->generate_token(result, token);
    }
    
    

    输出

    调用generate_token方法后的输出结果(JWT)

    eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE1MTc0OTgwNzQsImlzcyI6ImttY2IuY29tIiwibmFtZSI6InVzZXJpZCIsInVzZXJpZCI6MX0=.u3lauh/Inw+fTq7kITL+5mwQQ65LP5t2g9CHXWQZkrk=
    

    如果要直接在url中使用,还需要对上述字符串进行url编码,否则因url编码的原因,会导致验证失败.

    /*经过url编码后的token,验证成功*/
    http://localhost:9101/heightservice?m=chatoken&token=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE1MTc0OTk5ODAsImlzcyI6ImttY2IuY29tIiwibmFtZSI6InVzZXJpZCIsInVzZXJpZCI6MX0%3D.EGK4P7wqMgm0HjwLuApkqVvyc5AZUJ6zvnQsBrqlhHM%3D
    

    2018-11-30补充

    根据JWT的标准,token Base64还需要用下面两个函数转换.转换后url就没问题了,同时可以在JWT网站上解析token

    void SE_base64uri_encode(char *b64, int32_t len) {
    	int i, t;
    	for (i = t = 0; i < len; i++) {
    		switch (b64[i]) {
    		case '+':
    			b64[t++] = '-';
    			break;
    		case '/':
    			b64[t++] = '_';
    			break;
    		case '=':
    			break;
    		default:
    			b64[t++] = b64[i];
    		}
    	}
    	b64[t] = '\0';
    }
    
    bool SE_base64uri_decode(const char *src, int32_t len, char **base64) {
    	int32_t i = 0, z = 0;
    	char *bin_data = NULL;
    
    
    	bin_data = malloc(len + 4);
    	if (SE_PTR_ISNULL(bin_data))
    		goto SE_ERROR_CLEAR;
    	for (i = 0; i < len; i++) {
    		switch (src[i]) {
    		case '-':
    			bin_data[i] = '+';
    			break;
    		case '_':
    			bin_data[i] = '/';
    			break;
    		default:
    			bin_data[i] = src[i];
    		}
    	}
    	z = 4 - (i % 4);
    	if (z < 4) {
    		while (z--)
    			bin_data[i++] = '=';
    	}
    	bin_data[i] = '\0';
    	*base64 = bin_data;
    	return true;
    SE_ERROR_CLEAR:
    	SE_free(bin_data);
    	return false;
    }
    
    展开全文
  • cookie session token jwt

    2020-01-09 16:19:47
    使用 cookie 时需要考虑的问题 因为存储在客户端,容易被客户端篡改,使用前需要验证合法性 ...使用 httpOnly 在一定程度上提高安全性 尽量减少 cookie 的体积,能存储的数据量不能超过 4kb 设置正确的 domain 和 path...

    使用 cookie 时需要考虑的问题

    因为存储在客户端,容易被客户端篡改,使用前需要验证合法性
    不要存储敏感数据,比如用户密码,账户余额
    使用 httpOnly 在一定程度上提高安全性
    尽量减少 cookie 的体积,能存储的数据量不能超过 4kb
    设置正确的 domain 和 path,减少数据传输
    cookie 无法跨域
    一个浏览器针对一个网站最多存 20 个Cookie,浏览器一般只允许存放 300 个Cookie
    移动端对 cookie 的支持不是很好,而 session 需要基于 cookie 实现,所以移动端常用的是 token

    使用 session 时需要考虑的问题

    将 session 存储在服务器里面,当用户同时在线量比较多时,这些 session 会占据较多的内存,需要在服务端定期的去清理过期的 session
    当网站采用集群部署的时候,会遇到多台 web 服务器之间如何做 session 共享的问题。因为 session 是由单个服务器创建的,但是处理用户请求的服务器不一定是那个创建 session 的服务器,那么该服务器就无法拿到之前已经放入到 session 中的登录凭证之类的信息了。
    当多个应用要共享 session 时,除了以上问题,还会遇到跨域问题,因为不同的应用可能部署的主机不一样,需要在各个应用做好 cookie 跨域的处理。
    sessionId 是存储在 cookie 中的,假如浏览器禁止 cookie 或不支持 cookie 怎么办? 一般会把 sessionId 跟在 url 参数后面即重写 url,所以 session 不一定非得需要靠 cookie 实现
    移动端对 cookie 的支持不是很好,而 session 需要基于 cookie 实现,所以移动端常用的是 token

    使用 token 时需要考虑的问题

    如果你认为用数据库来存储 token 会导致查询时间太长,可以选择放在内存当中。比如 redis 很适合你对 token 查询的需求。
    token 完全由应用管理,所以它可以避开同源策略
    token 可以避免 CSRF 攻击(因为不需要 cookie 了)
    移动端对 cookie 的支持不是很好,而 session 需要基于 cookie 实现,所以移动端常用的是 token

    使用 JWT 时需要考虑的问题

    因为 JWT 并不依赖 Cookie 的,所以你可以使用任何域名提供你的 API 服务而不需要担心跨域资源共享问题(CORS)
    JWT 默认是不加密,但也是可以加密的。生成原始 Token 以后,可以用密钥再加密一次。
    JWT 不加密的情况下,不能将秘密数据写入 JWT。
    JWT 不仅可以用于认证,也可以用于交换信息。有效使用 JWT,可以降低服务器查询数据库的次数。
    JWT 最大的优势是服务器不再需要存储 Session,使得服务器认证鉴权业务可以方便扩展。但这也是 JWT 最大的缺点:由于服务器不需要存储 Session 状态,因此使用过程中无法废弃某个 Token 或者更改 Token 的权限。也就是说一旦 JWT 签发了,到期之前就会始终有效,除非服务器部署额外的逻辑。
    JWT 本身包含了认证信息,一旦泄露,任何人都可以获得该令牌的所有权限。为了减少盗用,JWT的有效期应该设置得比较短。对于一些比较重要的权限,使用时应该再次对用户进行认证。
    JWT 适合一次性的命令认证,颁发一个有效期极短的 JWT,即使暴露了危险也很小,由于每次操作都会生成新的 JWT,因此也没必要保存 JWT,真正实现无状态。
    为了减少盗用,JWT 不应该使用 HTTP 协议明码传输,要使用 HTTPS 协议传输。

    展开全文
  • token jwt 验证方法

    2019-09-16 09:28:21
    public static function token_decode($str){ $str = base64_decode($str); $params = explode("|",$str); if(count($params)!=3){ return false; } $res['uid'] = $params[0]; $re...
  • asp.net WebAPI Token Oauth2.0授权自定义返回结果(包括登录正确返回,登录失败返回)。 详细参考:https://blog.csdn.net/u013546115/article/details/105580532
  • vue项目+.net core mvc token jwt权限验证

    千次阅读 2019-05-13 22:52:29
    参考: https://www.cnblogs.com/lyl6796910/p/6648891.html ...1, .net core使用jwt验证 首先创建一个类 JwtSeetings public class JwtSeetings { /// <summary...
  • 实现登录状态保持的方法 方法一:cookie和session配合使用 ...如果验证通过,就会创建session来存储相关信息,并且生成一个cookie字符串,把sessionID放在cookie里面。然后返回给浏览器。 当用户下一次发起请求时,...
  • vue axios springboot2.0 cookie token jwt 跨域 cors cookie存token header 头请求带token 登陆login 采坑记录  首先 后端 pom文件 &lt;dependency&gt; &lt;groupId&gt;io.jsonwebtoken&...
  • 1、新建工程 2、选择打包方式,这边可以选择为打包为Jar包,或者传统的打包为War包 3、选择开发过程中使用到的技术,这边我选择的是Rest Repositories 4、新建测试用Controller ... plain copy
  • JWT产生和验证Token

    万次阅读 多人点赞 2019-07-31 19:15:33
    Token验证  最近了解下基于 Token 的身份验证,跟大伙分享下。很多大型网站也都在用,比如 Facebook,Twitter,Google+,Github 等等,比起传统的身份验证方法,Token 扩展性更强,也更安全点,非常适合用在 Web...
  • jwt

    千次阅读 2019-08-17 22:19:01
    文章目录介绍JWT的验证过程实例 在之前的项目中,大部分网页是通过session来判断用户是否有权限来访问...JWT也就是JSON Web TokenJWT),是目前最流行的跨域身份验证解决方案。 JWT的组成: 一个JWT实际上就是一个...
  • token

    千次阅读 2019-07-24 17:28:40
    JWT (jsonwebtoken) 用户登录 服务器端产生一个token (加密字符串) 发送给前端 前端将token 进行保存 前端发起数据请求的时候携带token 服务端 验证token 是否合法 如果合法继续操作 不合法终止操作 token 的...
  • Token and JWT

    2020-08-02 09:24:18
    傻傻分不清之 Cookie、Session、TokenJWT 阮一峰日志 JWT Token(令牌) 什么是token => 访问资源接口(API)时所需要的资源凭证 最为突出的两个特点就是: 服务端无状态化、可扩展性好 支持移动端设备 支持...
  • 昨天讲解了JWT的介绍、应用场景、优点及注意事项等,今天来个JWT具体的使用实践吧。...下面来看看如何使用jjwt来实现JWT token的生成与解密,主要用到sha512算法来演示。 1、导入jjwt的maven包。 depende
  • JSON Web Token (JWT) 简介

    千次阅读 2015-08-13 19:41:00
    JSON Web Token (JWT) 是一种基于 token 的认证方案。 JSON Web Token 的结构 一个 JWT token 看起来是这样的: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjEzODY4OTkxMzEsImlzcyI6ImppcmE6MTU0ODk1...
  • 从session、cookie到token以及JWT

    千次阅读 2020-05-13 14:16:17
    主要讲tokenjwt技术,关于session和cookie文章很多,简单提一下。 session和cookie 现在一般都是session和cookie一起用,一起提。但是他们俩其实不是一定要在一起。 首先牢记一点,http协议是无状态的。就是...
  • 前言 在互联网的登陆系统中一般有session cookie 和 jwt token来进行验证用户是否登录的.下面来说一下关于 jwt的坑: 1.首先登录成功的返回,其中jwt的有效期为2小时,refreshJwt的有效期为30天如下: 2.保存jwt 和...
  • TokenJwt详解

    千次阅读 2019-10-30 10:01:11
    区别: Token验证方式:由于服务器没有存储token数据,因此需要先从数据库中查询当前token,服务器再是验证否有效; JWT验证方式:直接在服务端进行校验,并且不用...接下来,详细介绍TokenJwt相关概念 1.To...
  • TokenJWT认证

    2020-02-21 19:39:43
    为什么用Token 先了解身份验证的演变: 随着交互式Web应用的兴起,像在线购物网站,需要登录的网站等等,遇到的一个问题就是身份验证会话管理,必须记住登录的用户,也就是必须吧每个用户区分开,因为HTTP请求是无状态...
  • JWT Token

    2016-03-02 14:05:22
    json web token. http://jwt.io/
  • JWT token

    2018-04-25 13:43:50
    最近一直在做前后端分离项目,开始想研究如何从实现remember me问题,可以使用JWT token。我的想法是把用户的id或者用户名(最好不要加上password)保存在token令牌中,每次提交时携带上token令牌后台验证是否失效,...

空空如也

1 2 3 4 5 ... 20
收藏数 102,693
精华内容 41,077
关键字:

token