aview-app 1.0.2

package/aardio/lib/crypt/aes.aardio

@@ -0,0 +1,58 @@
+//aes 加密算法
+import crypt;
+namespace crypt
+
+class aes {
+
+    ctor( initVector ) {  
+        this = ..crypt(
+        	 _WINXP ? "Microsoft Enhanced RSA and AES Cryptographic Provider (Prototype)" : "Microsoft Enhanced RSA and AES Cryptographic Provider"
+        	 ,0x18/*_PROV_RSA_AES*/
+        );  
+        this.initVector = initVector; 
+    };
+    setPassword = function( key,flags=0 ) {
+    
+    	if( type(key) != type.string ) error("请指定正确的密钥",2);
+    	
+    	var algId;
+    	var keyLen = #key;
+    	if( #key <= 16 ){
+    		if( keyLen < 16 ) key = ..raw.buffer(16,key);
+    		algId = 0x660E/*_CALG_AES_128*/;
+    	}
+    	elseif( #key <= 24 ){
+    		if( keyLen < 24 ) key = ..raw.buffer(24,key);
+    		algId = 0x660F/*_CALG_AES_192*/;
+    	}
+    	elseif( #key <= 32 ){
+    		if( keyLen < 32 ) key = ..raw.buffer(32,key);
+    		algId = 0x6610/*_CALG_AES_256*/;
+    	}
+    	else {
+    		return this.setHashPassword(key,0x8003/*_CALG_MD5*/,0x6610/*_CALG_AES_256*/,flags);
+    	} 
+    	
+    	var ret,err  = this.setPlainPassword(key,algId,flags);
+		if(!ret) return null,err;
+
+		this.blockSize = 16;
+		this.setKeyParamMode(1/*_CRYPT_MODE_CBC*/);
+		this.setKeyParamPadding(1/*_PKCS5_OR_PKCS7_PADDING*/);
+		return this.setInitVector( this.initVector or key );
+    }
+}
+ 
+/**intellisense()
+crypt.aes = AES加密算法支持库,默认加密模式 CBC,填充模式PKCS7,\n注意PKCS5与PKCS7填充规则一样,PKCS5填充1到8字节,PKCS7填充1到255字节,\n而AES数据块分组为16字节也就是128位,指定PKCS5实际使用的也是PKCS7,\n[各编程语言兼容的AES兼容写法参考](http://bbs.aardio.com/forum.php?mod=viewthread&tid=13818)\n\n演示代码:\n\n```\nimport crypt.aes;\nvar aes = crypt.aes();\n\n//设置密钥\naes.setPassword("12345678");\n\n//加密\nvar sstr = aes.encrypt("Test String");\n\n//解密\nvar str = aes.decrypt(sstr);\n```
+crypt.aes() = 返回AES加密容器,\n可选使用一个字符串参数指定密钥向量\n如果要与其他编程语言有相同加解密结果,建议不要设置该参数\n!crypy_aes.
+!crypy_aes.setPassword(.("密钥",选项) = 支持128位(16字节)、192位(24字节) 和 256位(32字节)密钥\n如果密钥长度不足指定位数自动填充'\0'到最适合的密钥长度,\n超过24字节使用使用MD5算法创建转换为24位密钥,\n参数@2不需要指定
+!crypy_aes.decrypt(.(字符串,是否已输入全部数据,哈希对象,选项) = 除第一个参数以外,其他参数都是可选参数\n成功返回解密文本,失败返回空,\n可使用..lasterr()函数获取错误信息
+!crypy_aes.encrypt(.(字符串,是否已输入全部数据,哈希对象,选项) = 除第一个参数以外,其他参数都是可选参数\n成功返回加密文本,失败返回空,\n可使用..lasterr()函数获取错误信息
+!crypy_aes.setKeyParam(.(类型,数据值,选项) = 设置加密参数\n数据值可以是结构体,字符串，或 buffer 对象，\n如果数据值一个数值参数,则转换为表示32位整型数值地址的结构体指针\n成功返回true,失败请使用 ..lasterr()获取错误信息
+!crypy_aes.setKeyParamMode(_CRYPT_MODE__) = 设置加密模式\n成功返回true,失败请使用 ..lasterr()获取错误信息
+!crypy_aes.setKeyParamPadding(_PKCS5_PADDIN__) = 设置加密填充方式,\nPKCS7填充模式请指定 _PKCS5_PADDIN,\n成功返回true,失败请使用 ..lasterr()获取错误信息
+!crypy_aes.setInitVector(.(字符串向量,选项) = 设置初始化向量,成功返回true,\n参数2可选
+!crypy_aes.hasKey() = 检测是否已设置密钥
+!crypy_aes.blockSize = 加密填充的块大小，默认为16
+end intellisense**/

package/aardio/lib/crypt/bin.aardio

@@ -0,0 +1,68 @@
+//bin 文本编码
+import crypt;
+namespace crypt.bin;
+   
+encode = ..crypt.encodeBin;
+decode = ..crypt.decodeBin;
+
+encodeBase64 = function(str,len,flags = 0x40000001/*_CRYPT_STRING_BASE64*/){
+	return encode(str,len,flags);
+}
+
+decodeBase64 = function(str,len,flags = 1/*_CRYPT_STRING_BASE64*/){
+	return decode(str,len,flags);
+}
+
+encodeUrlBase64 = function(str,len,padding){
+	var bin = encode(str,len,0x40000001/*_CRYPT_STRING_BASE64*/);
+	if(bin){
+		bin = ..string.replace(bin,"[\+/]",{["+"]="-";["/"]="_"} );
+    	return padding ? bin : ..string.trimright(bin,"=");
+	}
+}
+
+decodeUrlBase64 = function(str,len){
+    if(!str) return;
+    str = ..string.replace(str,"@-","+");
+    str = ..string.replace(str,"@_","/");
+	return decode(str,len,1/*_CRYPT_STRING_BASE64*/);
+}
+
+encodeHex = function(str,len,flags = 0x40000004/*_CRYPT_STRING_HEX*/){
+	return encode(str,len,flags); 
+}
+
+decodeHex = function(str,len,flags = 4/*_CRYPT_STRING_HEX*/){
+	return decode(str,len,flags);
+}
+
+base64DataUrl = function(str,mime){
+	return ..string.format('data:%s;base64,%s',mime: "text/plain; charset=UTF-8",..string.replace(encodeBase64(str),"\r\n","") ) 
+}
+ /**intellisense()
+crypt.bin = BASE64加密解密\n简单封装 crypt.encodeBin 以及 crypt.decodeBin 函数
+crypt.bin.encodeBase64(.(字符串,长度,选项) = Base64编码,\n字符串可以是指针,如果不是托管指针则应指定长度参数,\n否则长度参数可省略\n调用此函数不建议指定选项参数
+crypt.bin.decodeBase64(.(字符串,长度,选项) = Base64解码,\n字符串可以是指针,如果不是托管指针则应指定长度参数,\n否则长度参数可省略\n调用此函数不建议指定选项参数
+crypt.bin.encodeUrlBase64(.(字符串,长度,允许补等号) = UrlBase64编码,\n字符串可以是指针,如果不是托管指针则应指定长度参数,\n否则长度参数可省略\n\n返回字符串不包含用于尾部对齐的等号\n并且+替换为-,/替换为_，以保证作为URL参数可以安全传输
+crypt.bin.decodeUrlBase64(.(字符串,长度) = UrlBase64解码,\n字符串可以是指针,如果不是托管指针则应指定长度参数,\n否则长度参数可省略\n
+crypt.bin.encodeHex(.(字符串,长度,选项) = 16进制编码,移除返回字符串尾部回车换行
+crypt.bin.decodeHex(.(字符串,长度,选项) = 16进制解码\n调用此函数不建议指定选项参数
+crypt.bin.base64DataUrl(.(字符串,MIME) = 返回 Base64 格式 Data URL
+_CRYPT_STRING_BASE64HEADER=@0/*_CRYPT_STRING_BASE64HEADER*/
+_CRYPT_STRING_BASE64=@1/*_CRYPT_STRING_BASE64*/
+_CRYPT_STRING_BINARY=@2/*_CRYPT_STRING_BINARY*/
+_CRYPT_STRING_BASE64REQUESTHEADER=@3/*_CRYPT_STRING_BASE64REQUESTHEADER*/
+_CRYPT_STRING_HEX=@4/*_CRYPT_STRING_HEX*/
+_CRYPT_STRING_HEXASCII=@5/*_CRYPT_STRING_HEXASCII*/
+_CRYPT_STRING_BASE64_ANY=@6/*_CRYPT_STRING_BASE64_ANY*/
+_CRYPT_STRING_ANY=@7/*_CRYPT_STRING_ANY*/
+_CRYPT_STRING_HEX_ANY=@8/*_CRYPT_STRING_HEX_ANY*/
+_CRYPT_STRING_BASE64X509CRLHEADER=@9/*_CRYPT_STRING_BASE64X509CRLHEADER*/
+_CRYPT_STRING_HEXADDR=@0xA/*_CRYPT_STRING_HEXADDR*/
+_CRYPT_STRING_HEXASCIIADDR=@0xB/*_CRYPT_STRING_HEXASCIIADDR*/
+_CRYPT_STRING_HEXRAW=@0xC/*_CRYPT_STRING_HEXRAW*/
+_CRYPT_STRING_HASHDATA=@0x10000000/*_CRYPT_STRING_HASHDATA*/
+_CRYPT_STRING_STRICT=@0x20000000/*_CRYPT_STRING_STRICT*/
+_CRYPT_STRING_NOCRLF=@0x40000000/*_CRYPT_STRING_NOCRLF*/
+_CRYPT_STRING_NOCR=@0x80000000/*_CRYPT_STRING_NOCR*/
+end intellisense**/

package/aardio/lib/crypt/des.aardio

@@ -0,0 +1,55 @@
+//des 加密算法(3DES)
+import crypt;
+namespace crypt
+
+class des {
+
+    ctor( initVector ) {  
+        this = ..crypt("Microsoft Enhanced Cryptographic Provider v1.0"); 
+        this.initVector = initVector;  
+    };
+    setPassword = function( key,flags) {
+    
+    	if( type(key) != type.string ) error("请指定正确的密钥",2);
+    	
+    	var algId;
+    	var keyLen = #key;
+    	if( keyLen <= 8 ){
+    		if( keyLen < 8 ) key = ..raw.buffer(8,key);
+    		algId = 0x6601/*_CALG_DES*/;
+    	}
+    	elseif( #key <= 16 ){
+    		if( keyLen < 16 ) key = ..raw.buffer(16,key);
+    		algId = 0x6609/*_CALG_3DES_112*/;
+    	}
+    	elseif( #key <= 24 ){
+    		if( keyLen < 24 ) key = ..raw.buffer(24,key);
+    		algId = 0x6603/*_CALG_3DES*/;
+    	}
+    	else {
+    		return this.setHashPassword(key,0x8003/*_CALG_MD5*/,0x6603/*_CALG_3DES*/,flags);
+    	} 
+    	 
+    	var ret,err  = this.setPlainPassword(key,algId,flags);
+		if(!ret) return null,err;
+		
+		return this.setInitVector( this.initVector or '\x12\x34\x56\x78\x90\xAB\xCD\xEF' );
+    }  
+}
+ 
+/**intellisense()
+crypt.des = DES,2DES,3DES加密算法支持库\n加密模式CBC，填充模式PKCS5，如果与其他编程语言互通要保持一致\n各编程语言兼容的DES兼容写法参考](http://bbs.aardio.com/forum.php?mod=viewthread&tid=13148) \n\n演示代码：\n\n```\nimport crypt.des; \n\nvar des = crypt.des(); \ndes.setPassword("abcd12" ) \n\n//加密\nvar sstr = des.encrypt("测试字符串");\n\n//解密\nvar str = des.decrypt(sstr);\n```
+crypt.des() = 返回DES加密容器,支持DES,2DES,3DES加密\n可选使用一个字符串参数指定密钥向量\n如果要与其他编程语言有相同加解密结果,建议不要设置该参数\n!crypy_3des.
+end intellisense**/
+
+/**intellisense(!crypy_3des)
+setPassword(.("密钥",选项) = 密钥使用补0方式进行8位对齐\n密钥长度小于等于8位时使用DES加密\n密钥长度小于等于16位时使用2DES加密\n密钥长度小于等于24位时使用3DES加密,\n超过24字节使用使用MD5算法创建转换为24位密钥,\n参数@2不需要指定
+decrypt(.(字符串,是否已输入全部数据,哈希对象,选项) = 除第一个参数以外,其他参数都是可选参数\n成功返回解密文本,失败返回空,\n可使用..lasterr()函数获取错误信息
+encrypt(.(字符串,是否已输入全部数据,哈希对象,选项) = 除第一个参数以外,其他参数都是可选参数\n成功返回加密文本,失败返回空,\n可使用..lasterr()函数获取错误信息
+setKeyParam(.(类型,数据值,选项) = 设置加密参数\n数据值可以是结构体,字符串，或 buffer 对象,\n如果数据值一个数值参数,则转换为表示32位整型数值地址的结构体指针\n成功返回true,失败请使用 ..lasterr()获取错误信息
+setKeyParamMode(_CRYPT_MODE__) = 设置加密模式\n成功返回true,失败请使用 ..lasterr()获取错误信息
+setKeyParamPadding(_PKCS5__) = 设置加密填充方式\n成功返回true,失败请使用 ..lasterr()获取错误信息
+setInitVector(.(字符串向量,选项) = 设置初始化向量,成功返回true,\n参数2可选
+hasKey() = 检测是否已设置密钥
+blockSize = 加密填充的块大小，默认为8
+end intellisense**/

package/aardio/lib/crypt/hash.aardio

@@ -0,0 +1,110 @@
+//hash 哈希对象
+if(!crypt) error("该类仅供crypt库内部调用",2)
+namespace crypt;
+
+class hash{
+	ctor( cryptContent,algid = 0x8003/*_CALG_MD5*/,hKey/*密钥散列*/,flag=0){ {
+		this.cryptContent = cryptContent;//防止析构 
+		this.hKey = hKey;
+    	var ret,hHash = CreateHash( this.cryptContent.hCryptProv,algid,hKey,0 ); 
+		if (!ret) {  
+			return null,..lasterr();
+		}
+		this.handle = hHash;
+		..table.gc(this,"destroy");
+	} }; 
+	getValue = function () { 
+		var ret,size = GetHashParamByInt(this.handle, 0x4/*_HP_HASHSIZE*/, 4, 4, 0); 
+		var ret,str = GetHashParamByString(this.handle, 0x2/*_HP_HASHVAL*/, size, size, 0);
+		 
+		if (ret) {
+			return str;
+		}
+	};
+	getHexValue = function( upper=true  ){
+		var s = this.getValue(); 
+		if( s ){
+			var f = upper?"%02X":"%02x"
+			var s = ..string.replace(s,".",
+				function(c){
+					return ..string.format(f, c[1] )
+				}
+			);  
+			return s;
+		}
+	};
+	hashData = function (data) {
+		return HashData(this.handle , data, #data, 0);
+	};
+	setParamStruct = function(param,data,flag=0){ 
+		return CryptSetHashParamStruct(this.handle ,param ,data,flag);
+	};
+	hashBuffer = function (buffer,l) {
+		var m = #buffer;
+		if( !l ) l = m;
+		elseif( l > m ) l = m;
+		elseif( l < 0 ) return;
+		return HashData(this.handle , buffer,l, 0);
+	};
+	deriveKey = function(algId = 0x6801/*_CALG_RC4*/, flag=0,bits=0){
+		if(algId==0x6801 && bits === null) bits = 128;
+		var ret,hKey = DeriveKey(this.cryptContent.hCryptProv,algId,this.handle,flag | (bits <<16) ); 
+		if(ret){ 
+			this.cryptContent.setKey(hKey);  
+			return true;
+		};
+		return null,..lasterr(,"deriveKey");
+	};
+	sign = function(keySpec = 2/*_AT_SIGNATURE*/,flags=0){
+		var r,sOut,size = CryptSignHash( this.handle,keySpec,,flags,0,0) ;
+		if( r && size ) r,sOut,size = CryptSignHash( this.handle,keySpec,,flags,size,size) ;
+		if( r ) return sOut;
+	};
+	destroy = function () {
+		if (this.handle) {
+			DestroyHash(this.handle); 
+			if( this.cryptContent.lastHash == this){
+				this.cryptContent.lastHash = null;
+			}
+			this.handle = null;
+			
+			if( this.hKey ){
+				..crypt.DestroyKey(this.hKey );
+				this.hKey = null;
+			};
+		};
+	};
+	@_meta;
+}
+
+namespace hash{
+	_meta = {
+		_topointer = function(){
+			return owner.handle;
+		} 
+	}
+	
+	if(! ::Advapi32 )error("crypt.hash仅用于crypt库内部调用")
+	
+	CreateHash = ::Advapi32.api("CryptCreateHash", "int(POINTER hProv,int algid,pointer hKey,int flags, pointer& phHash)");
+	DestroyHash = ::Advapi32.api("CryptDestroyHash", "int(POINTER hHash)");
+	HashData = ::Advapi32.api("CryptHashData", "bool(POINTER hHash, string pbData, int dwDataLen,INT flags)");
+	GetHashParamByInt = ::Advapi32.api("CryptGetHashParam", "int(POINTER hHash, int type, int& pbBuff, int& pbBuffLen,int flags)");
+	GetHashParamByString = ::Advapi32.api("CryptGetHashParam", "int(POINTER hHash, int type, string& pbBuff, int& pbBuffLen, int flags)");
+	CryptSetHashParamStruct = ::Advapi32.api("CryptSetHashParam", "bool(POINTER hHash, INT dwParam,struct pbData,INT dwFlags)");		
+	DeriveKey = ::Advapi32.api("CryptDeriveKey", "bool(POINTER hProv,INT Algid,POINTER hBaseData,int flags,pointer &phKey)"); 
+	CryptSignHash = ::Advapi32.api("CryptSignHashW","bool(POINTER hHash,INT keySpec,ustring sDesc,INT flags,string &sign,INT &sigLen") 
+}
+
+/**intellisense()
+crypt.hash() = !crypt_hash.
+!crypt_hash.destroy() = 删除哈希对象
+!crypt_hash.deriveKey(.(算法ID,选项) = 导出会话密钥设置为容器对象当前密钥\n会话密钥由容器对象管理,该函数成功返回true
+!crypt_hash.getValue() = 返回原始哈希值数据,\n即未转换为16进制
+!crypt_hash.getHexValue() = 返回十六进制哈希值(大写)
+!crypt_hash.getHexValue(false) = 返回十六进制哈希值(小写)
+!crypt_hash.hashData(__/*字符串*/) = 计算哈希值
+!crypt_hash.hashBuffer(.(buffer,长度) =  参数@1 必须是 raw.buffer 创建的 buffer 对象,\n长度为可选参数
+!crypt_hash.deriveKey(.(算法ID,选项) = 从哈希表中派生密钥,\n参数可选,算法ID默认为_CALG_RC4,选项默认为0\n密钥自动绑定到CSP密钥容器对象\n该函数无返回值
+!crypt_hash.sign(.(keySpec,flags) = 返回签名\n可选用 @keySpec 参数中指定密钥类型,\n@flags 不必指定,默认为_AT_SIGNATURE\n导入密钥时请改为_AT_KEYEXCHANGE
+end intellisense**/

package/aardio/lib/crypt/hmac.aardio

@@ -0,0 +1,64 @@
+//hmac 算法
+import crypt;
+namespace crypt
+
+class hmac{
+	ctor(key,data,algId = 0x8004/*_CALG_SHA1*/) {
+		var csp = ..crypt(); 
+		
+		//不会真的用到RC2
+		var ret,err = csp.setPlainPassword(key,0x6602/*_CALG_RC2*/,0x100/*_CRYPT_IPSEC_HMAC_KEY*/);
+		if(!ret) return null,err;
+		 
+		var hashMac,err = csp.createHashByKey(0x8009/*_CALG_HMAC*/); 
+		if( !hashMac ) return null,err; 
+		
+		var hmacInfo = HMAC_INFO();
+		hmacInfo.hashAlgid = algId; 
+		hashMac.setParamStruct( 5/*_HP_HMAC_INFO*/, hmacInfo );
+		
+		if( data ){
+			hashMac.hashData(data);
+		} 
+		
+		this = hashMac;
+	} 
+}
+
+namespace hmac{
+	sha1 = function(key,data){
+		return ..crypt.hmac(key,data,0x8004/*_CALG_SHA1*/);
+	}
+	sha256 = function(key,data){
+		return ..crypt.hmac(key,data,0x800C/*_CALG_SHA_256*/);
+	}
+	sha512 = function(key,data){
+		return ..crypt.hmac(key,data,0x800E/*_CALG_SHA_512*/);
+	}
+	sha384 = function(key,data){
+		return ..crypt.hmac(key,data,0x800D/*_CALG_SHA_384*/);
+	}
+	md5 = function(key,data){
+		return ..crypt.hmac(key,data,0x8003/*_CALG_MD5*/);
+	}
+	
+	class HMAC_INFO {
+    	INT hashAlgid;
+    	pointer pbInnerString;
+    	INT cbInnerString;
+    	pointer pbOuterString;
+    	INT cbOuterString;
+	};
+}
+
+/**intellisense()
+crypt.hmac(.("密钥","源数据",算法ID) = 返回HMAC哈希对象,算法ID默认为 _CALG_SHA1
+crypt.hmac.sha1(.("密钥","源数据") = 返回 HMAC-SHA1 哈希对象
+crypt.hmac.sha256(.("密钥","源数据") = 返回 HMAC-SHA256 哈希对象
+crypt.hmac.sha512(.("密钥","源数据") = 返回 HMAC-SHA512 哈希对象
+crypt.hmac.sha384(.("密钥","源数据") = 返回 HMAC-SHA384 哈希对象
+crypt.hmac.md5(.("密钥","源数据") = 返回 HMAC-MD5 哈希对象
+crypt.hmac() = !crypt_hash.
+crypt.hmac.sha1() = !crypt_hash.
+crypt.hmac.md5() = !crypt_hash.
+end intellisense**/

package/aardio/lib/crypt/jwt.aardio

@@ -0,0 +1,78 @@
+//jwt 令牌
+import web.json;
+import crypt.hmac;
+import crypt.bin;
+
+namespace crypt
+
+class jwt{
+    
+	ctor(privateKey,expiresIn){
+		this.privateKey = privateKey;
+		this.expiresIn = expiresIn;
+	};
+	
+	encode = function(data){
+		if(!data.iat)data.iat = tonumber(..time());
+		if(this.expiresIn && data.exp===null){
+			data.exp = tonumber(..time().addsecond(this.expiresIn));
+		}
+		
+		var header = ..crypt.bin.encodeUrlBase64(`{"alg":"HS256","typ":"JWT"}`);
+		var payload = ..crypt.bin.encodeUrlBase64( ..web.json.stringify(data) );
+		var sign = ..crypt.hmac.sha256(this.privateKey,header + "." + payload).getValue();
+		return ..string.format("%s.%s.%s",header,payload,..crypt.bin.encodeUrlBase64(sign));
+	};
+	
+	decode = function(token){
+		var jwt = ..string.split(token,".",3);
+		if(#jwt==3){
+			var ret =  {
+        		header = ..web.json.parse(..crypt.bin.decodeBase64(jwt[1]));
+        		payload = ..web.json.parse(..crypt.bin.decodeBase64(jwt[2]));
+        		sign = ..crypt.bin.decodeBase64(jwt[3]);
+    		} 
+    		
+    		if(ret.payload[["exp"]]){
+    			ret.payload[["exp"]] = ..time(ret.payload[["exp"]])
+    		}	
+    		
+    		if(ret.payload[["iat"]]){
+    			ret.payload[["iat"]] = ..time(ret.payload[["iat"]])
+    		}
+    		
+    		if(ret.payload[["nbf"]]){
+    			ret.payload[["nbf"]] = ..time(ret.payload[["iat"]])
+    		}
+    		return ret;
+		}
+	};
+	
+	verify = function(token){
+		token = ..string.match(token,"[Bb]earer\s+(\S+)") : token;
+		if(this.privateKey){
+			var jwt = ..string.split(token,".",3);
+        	var sign = ..crypt.hmac.sha256(this.privateKey,jwt[1] + "." + jwt[2]).getValue() ;
+        	
+        	if( jwt[3] === ..crypt.bin.encodeUrlBase64(sign) ){
+        		var ret = this.decode(token);
+        		if(ret.payload[["exp"]]){
+        			if( ret.payload[["exp"]] <= ..time() ){
+        				return;
+        			}
+        		}
+        		return ret;
+        	}
+         
+    	}
+	};
+}
+
+/**intellisense()
+crypt.jwt = JSON Web Token 令牌
+crypt.jwt(.(密钥,超时) = 使用字符串指定签名使用的密钥,\n参数@2指定令牌超时秒数
+crypt.jwt() = !crypt_jwt.
+!crypt_jwt.verify(__) = 验证参数指定的token是否在有效期内，以及签名是否有效\n如果验证token有效，就解码返回令牌信息
+!crypt_jwt.decode(__) = 解码并返回令牌信息
+!crypt_jwt.encode(__) = 生成令牌，\n参数指定要存储到客户端的数据，\n参数必须是表对象
+end intellisense**/

package/aardio/lib/crypt/protectData.aardio

@@ -0,0 +1,51 @@
+//protectData DPAPI
+::Crypt32  := ..raw.loadDll("Crypt32.dll");
+	
+namespace crypt.protectData;
+
+decrypt = function(dataIn,unhex,flags){
+    if((unhex===null && (type(dataIn)==="string") ) || unhex){
+    	dataIn = ..string.unhex(dataIn,"") 
+    }
+     
+    var dataOut = {INT cbData;ptr data}
+    var description = {ptr v}
+	if( ::Crypt32.CryptUnprotectData ({
+		INT cbData = #dataIn;
+		ptr data = dataIn;
+	},description,null,null,null,flags,dataOut) ){
+ 
+		var ret,desc = ..raw.buffer(dataOut.cbData,dataOut.data);
+		if(description.v){
+			desc = ..string.fromUnicode(description.v,,-1)
+			::Kernel32.LocalFree(description.v);
+		}
+		::Kernel32.LocalFree(dataOut.data);
+		return ret,desc;
+	}   
+}
+
+encrypt = function(dataIn,description,hex,flags){  
+    var dataOut = {INT cbData;ptr data}
+	if( ::Crypt32.CryptProtectData({
+		INT cbData = #dataIn;
+		ptr data = dataIn;
+	},description,null,null,null,flags,dataOut) ){ 
+		var ret = ..raw.buffer(dataOut.cbData,dataOut.data);
+		::Kernel32.LocalFree(dataOut.data);
+		if(hex || hex === null ) ret = ..string.hex(ret,""); 
+		return ret;
+	} 	
+}
+
+/**intellisense()
+crypt.protectData = DPAPI 加解密
+crypt.protectData.decrypt(.(dataIn,unhex,flags) = @dataIn 指定加密数据,\n@unhex 指定是否对@dataIn进行16进制解码,省略时默认为true\n可选用 @flags 指定选项\n如果解密系统加密数据失败,\n请先尝试在管理权限下用 thread.token.impersonate("winlogon.exe") 获取 SYSTEM 身份
+crypt.protectData.encrypt(.(dataIn,description,hex,flags) = @dataIn 指定要加密的数据，允许传入字符串,buffer,\n可选用 @hex 参数指定是否对返回值进行16进制编码,默认为true\n可选用 @flags 指定选项 
+end intellisense**/
+ 
+/**intellisense()
+_CRYPTPROTECT_UI_FORBIDDEN=@1/*_CRYPTPROTECT_UI_FORBIDDEN*/
+_CRYPTPROTECT_LOCAL_MACHINE=@4/*_CRYPTPROTECT_LOCAL_MACHINE*/
+_CRYPTPROTECT_AUDIT=@0x10/*_CRYPTPROTECT_AUDIT*/
+end intellisense**/

package/aardio/lib/crypt/provParam.aardio

@@ -0,0 +1,32 @@
+//provParam 提供程序参数
+import crypt;
+
+namespace crypt;
+
+class provParam{
+	ctor( cryptContent ){
+		this.cryptContent = cryptContent;
+	};
+	get = function(dwParam,data,flags){
+		var size = {INT value}
+		if(dwParam!=0x26/*_PP_USE_HARDWARE_RNG*/){
+			if(!data){
+				if(!::Advapi32.CryptGetProvParam(this.cryptContent.hCryptProv,dwParam,null,size,flags))return;
+				data = ..raw.buffer(size.value);
+			}
+			else {
+				size.value = data[["_struct"]] ?  ..raw.sizeof(data) : #data ;
+			} 
+		} 
+		
+		if( ::Advapi32.CryptGetProvParam(this.cryptContent.hCryptProv,dwParam,data,size,flags) ){
+			return data || true;
+		}
+	};
+}
+
+/**intellisense()
+crypt.provParam(.(cryptObject) = 参数指定 crypt 对象
+crypt.provParam() = !cryptProvParam.
+!cryptProvParam.get(.(dwParam,data,flags) = @dwParam 使用数值指定获取参数,\n@data 可指定 struct,buffer 或 null 值,\n成功返回获取数据。\n用法参考源码以及 ::Advapi32.CryptGetProvParam 文档
+end intellisense**/

package/aardio/lib/crypt/rc4.aardio

@@ -0,0 +1,32 @@
+//rc4 加密算法
+import crypt;
+namespace crypt;
+
+class crypt.rc4 {
+
+    ctor( ... ) {  
+        this = ..crypt(...);
+    };
+    setPassword = function(key,flags=0) {
+    	if( type(key) != type.string ) error("请指定正确的密钥",2);
+
+    	if( #key <  5 ){
+    		key = ..raw.buffer(5,key);
+    	}
+    	elseif( #key> 16 ) {
+			return this.setHashPassword(key,0x8003/*_CALG_MD5*/,0x6801/*_CALG_RC4*/,flags);
+    	} 
+    	
+    	var ret,err  = this.setPlainPassword(key,0x6801/*_CALG_RC4*/,flags);
+		if(!ret) return null,err;
+    }
+}
+ 
+/**intellisense()
+crypt.rc4 = rc4加密算法
+crypt.rc4() = 返回RC4加密容器,\n可选使用一个字符串参数指定密钥向量\n如果要与其他编程语言有相同加解密结果,建议不要设置该参数\n!crypy_rc4.
+!crypy_rc4.setPassword(.("密钥",选项) = 密钥长度为5到16字节,\n密钥超过128位(16字节)时使用MD5转换为哈希值,\n如果密钥长度小于5字节自动填充'\0'\n参数@2不需要指定
+!crypy_rc4.decrypt(.(字符串,是否已输入全部数据,哈希对象,选项) = 除第一个参数以外,其他参数都是可选参数\n成功返回解密文本,失败返回空,\n可使用..lasterr()函数获取错误信息
+!crypy_rc4.encrypt(.(字符串,是否已输入全部数据,哈希对象,选项) = 除第一个参数以外,其他参数都是可选参数\n成功返回加密文本,失败返回空,\n可使用..lasterr()函数获取错误信息
+!crypy_rc4.hasKey() = 检测是否已设置密钥
+end intellisense**/