U盘超级加密3000加密后的文件是在右侧的加密区显示的。U盘超级加密3000有两种加密方式：1.闪电加密的文件在U盘里是隐藏的，看不到的，打开软件才能看到；2.金钻加密文件后缀是.udef。
这些是普通的文件，没有加密的。请你选择正确的打开方式即可
这个问题，要解决起来还是比较困难的。
所以还是建议您再加密文件的时候，选择专业的文件加密软件。
超级加密3000采用国际上成熟的加密算法和安全快速的加密方法，可以有效保障数据安全!
//计划做的脚本引擎的一部分//参考的 C++编程艺术
//总地来说会有一些难度
//我的是C++应该会给你一些启发
//TypeDef.h
#include "windows.h"
#ifndef B_TYPE_DEF_H
#define B_TYPE_DEF_H
const int MAX_T_LEN = 128//可以分析的最大符号长度(同时决定了一个字符变量的最大长度为128字节)
const int MAX_ID_LEN = 31//允许的最大的标识长度(一个标识符是指一个变量名或函数名)
const int MAX_BUF_LEN = 1024//解释缓冲区1024字节
const int NUM_PARAMS = 32//最大参数数目
const int MAX_DIM_NUM = 65536//数组最大维数
//需要分析的所有东西
enum Token_Item { UNDEF=1, //未定义
E_TEMP,//当模板使用
E_CHAR,//char关键字
E_INT,//int关键字
E_FLOAT,//float关键字
E_SWITCH,//switch关键字
E_CASE,//case关键字
E_IF,//if关键字
E_ELSE,//else关键字
E_FOR,//for关键字
E_DO,//do关键字
E_WHILE,//while关键字
E_BREAK,//break关键字
E_RETURN,//return关键字
E_COUT,//cout关键字
E_CIN,//cin关键字
LBLOCK, //{
RBLOCK,//}
DOU,//,
EOS,//
MAO,//:
SFEN,//'已舍弃,不含'分析
LT,//<
LE,//<=
GT,//>
GE,//>=
EQ,//==
NE,//!=
FF,//.
LK,//(
NOT,//!
INC,//++
DEC,//--
ADD,//+
SUB,//-
RK,//)
LZK,//[
RZK,//]
LS,//<<
RS,//>>
ASS,//=
AND,//&&
OR,//||
MUL,//*
DIV,///
MOD,//%
POW,//^
NUMBER, //数字
IDENTIFIER,//标识
STRING,//字符串
END//文件结束
}//需要分析的全部符号
enum Token_Type{
UNK,//未知类型
KEY,//关键字
FJF,//分界符
CMP,//比较运算符
OPE,//运算符
NUM,//数字
IDE,//标识符
STR,//字符串
NON,//结束符号
UDF//未定义
}
typedef struct Token_Table{//符号表
char name[MAX_T_LEN]
Token_Item token
Token_Type type
} TOKEN_TABLE,*PTOKEN_TABLE
enum error_msg //错误类型
{ SYNTAX=1000, NO_EXP, NOT_VAR, DUP_VAR, DUP_FUNC,
SEMI_EXPECTED, UNBAL_BRACES, FUNC_UNDEF,
TYPE_EXPECTED, RET_NOCALL, PAREN_EXPECTED,
WHILE_EXPECTED, QUOTE_EXPECTED, DIV_BY_ZERO,
BRACE_EXPECTED, COLON_EXPECTED,FAIL_OPEN,ERROR_SIZE,
NO_MAIN,ERROR_ASSIGN,ERROR_RZK,ERROR_DIM}
class InterpExc { //错误类
error_msg err
public:
InterpExc(error_msg e) { err = e}
error_msg get_err() { return err}
}
enum Vars{类型
V_Int,
V_Float,
V_String,
V_pInt,
V_pFloat,
V_pString,
V_Udef
}
#endif
#ifndef V_NULL
#define V_NULL (-1)
#endif
//Cfenxi.h
#include "TypeDef.h"
#include <iostream>
#include <vector>
#include <stack>
#include <algorithm>
#include <string>
using namespace std
//Fenxi类说明
//curr_pt始终指向将要分析的地址
//prev_pt为前一个分析的地址
//可以使用函数GotoPt来改变当前分析地址
//分析结果放在变量stoken,item,type
//在Cfenxi.cpp中定义了一个文件级变量TOKEN_TABLE tokentable[]
//在使用的时候必须声明这个变量
#ifndef B_CFENXI_H
#define B_CFENXI_H
class Fenxi{
public:
char stoken[MAX_T_LEN+1]//分析出来的符号名
char buff[MAX_BUF_LEN+1]//缓冲区
Token_Item item//分析出来的具体符号
Token_Type type//符号大类
long curr_pt//当前分析点
long prev_pt//前一个分析点
char pFileName[256]//脚本文件名
PTOKEN_TABLE pTokenTable//符号表
public:
Fenxi(){}
~Fenxi(){}
void Create(char*,PTOKEN_TABLE,int)//创建分析对象
void GetToken()//分析一步
void GotoPt(long)//跳分析点
void PutBack()//回退一个分析点
private:
int nTableItem//分析表中的分析数目
long iFileLength//脚本文件长度
int iBlock//当前所在区块
int iYouBiao//当前游标
char cbuff//当前所指向的字符
char cbuff1//超前搜索的字符
void MoveNext()//向下移动
void MovePrev()//向前移动
void LoadBlock()//装入一个块
long GetPt(int i,int n){return (long)(i*MAX_BUF_LEN+n)}//计算位置
bool KeyLookUp(char*,Token_Item &)//查找是不是关键词
bool isdelim(char)
}
//解释类
class var_value{
public:
char string_value[MAX_T_LEN+1]
int int_value
float float_value
Vars v_type
public:
var_value()
{
int_value=0
float_value=0
string_value[0]=0
v_type=Udef
}
var_value(const var_value&)
set_type(Vars type){v_type=type}
~var_value(){}
friend bool operator == (const var_value&_X, const var_value&_Y)
friend bool operator < (const var_value&_X, const var_value&_Y)
}
class temp_var_value{
public:
char string_value[MAX_T_LEN+1]
int int_value
float float_value
int p_int
int p_float
int p_string
vector<int>dim
Vars v_type
public:
temp_var_value()
{
int_value=0
float_value=0
string_value[0]=0
p_int=p_float=p_string=V_NULL
v_type=Udef
}
temp_var_value(const temp_var_value&)
temp_set_type(Vars type){v_type=type}
~temp_var_value(){}
friend bool operator == (const temp_var_value&_X, const temp_var_value&_Y)
friend bool operator < (const temp_var_value&_X, const temp_var_value&_Y)
}
struct var_type { //变量类型
charvar_name[MAX_ID_LEN+1]// 变量名
Varsv_type//数据类型
vector<var_value>value//变量值
vector<int> v_dim//变量维数
intv_max//变量的最大数目
}
struct func_type {
char func_name[MAX_ID_LEN+1]//函数名
Vars ret_type//返回值类型
long loc// 函数入口点,函数的入口点是指分析点指向函数括号后第一个字符
}
class Script{
public:
Fenxi theFx//词法分析对象,负责对脚本文件的 *** 作
char FileName[256]//脚本文件名
var_value ret_value//返回值
bool breakfound//中断
public:
Script(){}
~Script(){}
void Create(char*,PTOKEN_TABLE,int)//创建脚本对象
void ExecuteScript()//开始解释脚本
private:
void PreScan()//预扫描
void decl_global()//声明全局变量
long find_func(char*)//返回函数的入口点
voidItemToVar(Token_Item,Vars&)//根据一个项,得到相当的变量类型
void CallFun()//执行一个函数
void get_args()//得到函数的形式参数名
void Interp()//具体解释
private:
void eval_exp (var_value &value)
void eval_exp0(var_value &value)
void eval_exp1(var_value &value)
void eval_exp2(var_value &value)
void eval_exp3(var_value &value)
void eval_exp4(var_value &value)
void eval_exp5(var_value &value)
void eval_exp6(var_value &value)
void eval_exp7(var_value &value)
void eval_exp8(var_value &value)
boolis_var(char *s)
// 变量名,变量的维数,变量的值,变量的类型
void assign_var(char *var_name,int idx, var_value value)
void find_var_value(char *var_name,int idx,var_value&value)
int find_idx(vector<int>,vector<int>)// 计算[][]
void find_vector(vector<int>&)//读取[]
int cal_idx(vector<int>)
Vars is_var_type//使用is_var的时候如果返回值是真那么这个变量存储了变量类型
public:
//每执行一个函数的时候就把进入前的局部变量数目
//放到函数结点栈,函数执行完的时候就根据栈里的
//数据改变局部函数表里的变量,从而实现变量的灵活使用
//同理块结点栈的原理也一样
//变量表
vector<var_type> global_vars//全局变量表
vector<var_type> local_var_stack//局部变量表(函数参数作为局部变量处理)
vector<func_type> func_table//函数表
stack<int> func_call_stack//函数结点栈
stack<int> nest_scope_stack//块结点栈
}
#endif
//Fenxi.cpp
#include "CFenxi.h"
#include <cstring>
#include <cctype>
#include <fstream>
#include <cstdio>
#include <cmath>
using namespace std
///////////////////////////////////////////////////////////////////////
/////////////////////////词法分析类的函数定义//////////////////////////
///////////////////////////////////////////////////////////////////////
extern TOKEN_TABLE tokentable[]={
"char",E_CHAR,KEY,
"int",E_INT,KEY,
"float",E_FLOAT,KEY,
"switch",E_SWITCH,KEY,
"case",E_CASE,KEY,
"if",E_IF,KEY,
"else",E_ELSE,KEY,
"for",E_FOR,KEY,
"do",E_DO,KEY,
"while",E_WHILE,KEY,
"break",E_BREAK,KEY,
"return",E_RETURN,KEY,
"cout",E_COUT,KEY,
"cin",E_CIN,KEY,
"{",LBLOCK,FJF,
"}",RBLOCK,FJF,
",",DOU,FJF,
"",EOS,FJF,
"<",LT,CMP,
"<=",LE,CMP,
">",GT,CMP,
">=",GE,CMP,
"==",EQ,CMP,
"!=",NE,CMP,
".",FF,OPE,
"(",LK,OPE,
")",RK,OPE,
"[",LZK,OPE,
"]",RZK,OPE,
"++",INC,OPE,
"--",DEC,OPE,
"<<",LS,OPE,
">>",RS,OPE,
"=",ASS,OPE,
"!",NOT,OPE,
"&&",AND,OPE,
"||",OR,OPE,
"+",ADD,OPE,
"-",SUB,OPE,
"*",MUL,OPE,
"/",DIV,OPE,
"%",MOD,OPE,
"^",POW,OPE,
}
var_value::var_value(const var_value&p)
{
int_value=p.int_value
float_value=p.float_value
strcpy(string_value,p.string_value)
v_type=p.v_type
}
bool operator == (const var_value&_X, const var_value&_Y)
{
if (_X.v_type != _Y.v_type)
{
return false
}
else
{
switch (_X.v_type)
{
case V_Float:
return (abs(_X.float_value - _Y.float_value) <0.0001)
break
case V_Int:
return (_X.int_value == _Y.int_value)
break
case V_Int:
return !(strcmp(_X.string_value, _Y.string_value))
break
default:
return false
}
}
}
bool operator < (const var_value&_X, const var_value&_Y)
{
if (_X.v_type != _Y.v_type)
{
return false
}
else
{
switch (_X.v_type)
{
case V_Float:
return (_X.float_value <_Y.float_value)
break
case V_Int:
return (_X.int_value <_Y.int_value)
break
case V_Int:
return !(strcmp(_X.string_value, _Y.string_value))
break
default:
return false
}
}
temp_var_value::temp_var_value(const temp_var_value&p)
{
int_value=p.int_value
float_value=p.float_value
strcpy(string_value,p.string_value)
p_int=p.p_int
p_float=p.p_float
p_string=p.p_string
v_type=p.v_type
}
void Fenxi::Create(char* p,PTOKEN_TABLE ptt,int n)
{
strcpy(pFileName,p)
ifstream fin(pFileName,ios::in|ios::binary)
fin.seekg(0,ios::end)
iFileLength=fin.tellg()
fin.close()
if(iFileLength==0)
throw InterpExc(ERROR_SIZE)
iBlock=0
LoadBlock()
MoveNext()//指向第一个字符
iYouBiao=0//置游标于文件头
curr_pt=0
prev_pt=0
cbuff=buff[0]//当前应该分析字符
cbuff1=buff[1]//超前搜索字符
pTokenTable=ptt
nTableItem=n//分析表设置
}
void Fenxi::MoveNext()
{
if(iYouBiao==MAX_BUF_LEN-1)//如果当前游标在缓冲区尾
{
iBlock++
LoadBlock()
cbuff=buff[0]
cbuff1=buff[1]//超前搜索
}
else
{
iYouBiao++
cbuff=buff[iYouBiao]
if(iYouBiao==MAX_BUF_LEN-1)//超前搜索
{
char temp[2]
temp[1]=0
ifstream fin(pFileName,ios::in|ios::binary)
fin.seekg(MAX_BUF_LEN*(iBlock+1))
fin.read(temp,1)
int i=fin.gcount()
temp[i]=0
fin.close()
cbuff1=temp[0]
}
else
cbuff1=buff[iYouBiao+1]
}
curr_pt=GetPt(iBlock,iYouBiao)
}
void Fenxi::MovePrev()
{
if(iYouBiao==0)//如果当前游标在缓冲区头
{
cbuff1=cbuff//超前搜索
iBlock--
LoadBlock()
iYouBiao=MAX_BUF_LEN-1
cbuff=buff[iYouBiao]
}
else
{
cbuff1=cbuff//超前搜索
iYouBiao--
cbuff=buff[iYouBiao]
}
curr_pt=GetPt(iBlock,iYouBiao)
}
void Fenxi::PutBack()
{
GotoPt(prev_pt)
}
void Fenxi::LoadBlock()//装入一个块
{
ifstream fin(pFileName,ios::in|ios::binary)
fin.seekg(MAX_BUF_LEN*iBlock)
fin.read(buff,MAX_BUF_LEN)
int i=fin.gcount()
buff[i]=0
iYouBiao=0
fin.close()
}
void Fenxi::GotoPt(long pt)
{
if(pt/MAX_BUF_LEN==curr_pt/MAX_BUF_LEN)//如果是在同一个块内的话
{
curr_pt=pt
iYouBiao=curr_pt-iBlock*MAX_BUF_LEN
cbuff=buff[iYouBiao]
}
else//否则要重新装入内存
{
curr_pt=pt
iBlock=curr_pt/MAX_BUF_LEN
LoadBlock()
iYouBiao=curr_pt-iBlock*MAX_BUF_LEN
cbuff=buff[iYouBiao]
}
if(iYouBiao==MAX_BUF_LEN-1)//超前搜索
{
char temp[2]
temp[1]=0
ifstream fin(pFileName,ios::in|ios::binary)
fin.seekg(MAX_BUF_LEN*(iBlock+1))
fin.read(temp,1)
int i=fin.gcount()
temp[i]=0
fin.close()
cbuff1=temp[0]
}
else
cbuff1=buff[iYouBiao+1]
}
void Fenxi::GetToken()
{
prev_pt=curr_pt//保存前一个的位置
char *temp//利用一个指针向字符里写内容
item=UNDEFtype=UDF
temp = stoken
*temp = '\0'
// 如果当前字符是空格且未到文件末
while(isspace(cbuff) &&cbuff) MoveNext()
// 跳过行
while(cbuff == '\r') {
MoveNext()
MoveNext()
while(isspace(cbuff) &&cbuff) MoveNext()
}
// 是否结尾
if(cbuff == '\0') {
*stoken = '\0'
item = END
type=NON
return
}
// 检查{}标识符
if(strchr("{}", cbuff)) {
stoken[0]=cbuff
stoken[1]='\0'
type=FJF
if(cbuff=='{')
item=LBLOCK
else
item=RBLOCK
MoveNext()//指向下一个字符
return
}
// 检查注释信息
if(cbuff == '/')
if(cbuff1 == '*') { // /*注释符
MoveNext()
MoveNext()
do { // 找到结尾
while(cbuff != '*') MoveNext()
MoveNext()
} while (cbuff != '/')
MoveNext()
GetToken()
return
} else if(cbuff1 == '/') { // is a // CMPment
MoveNext()
MoveNext()
// Find end of CMPment.
while(cbuff != '\r' &&cbuff != '\0') MoveNext()
if(cbuff == '\r') {MoveNext()MoveNext()}
GetToken()
return
}
// 检查双 *** 作符
if(strchr("!<>=+-&|", cbuff)) {
switch(cbuff) {
case '|':
if(cbuff1 == '|') {
MoveNext()MoveNext()
*temp = '|'
temp++
*temp = '|'
temp++
*temp = '\0'
item=OR
type=OPE
}
break
case '&':
if(cbuff1 == '&') {
MoveNext()MoveNext()
*temp = '&'
temp++
*temp = '&'
temp++
*temp = '\0'
item=AND
type=OPE
}
break
case '=':
if(cbuff1 == '=') {
MoveNext()MoveNext()
*temp = '='
temp++
*temp = '='
temp++
*temp = '\0'
item=EQ
type=CMP
}
break
case '!':
if(cbuff1 == '=') {
MoveNext()MoveNext()
*temp = '!'
temp++
*temp = '='
temp++
*temp = '\0'
item=NE
type=CMP
}
break
case '<':
if(cbuff1 == '=') {
MoveNext()MoveNext()
*temp = '<'
temp++
*temp = '='
item=LE
type=CMP
}
else if(cbuff1 == '<') {
MoveNext()MoveNext()
*temp = '<'
temp++
*temp = '<'
item=LS
type=OPE
}
else {
MoveNext()
*temp = '<'
item=LT
type=CMP
}
temp++
*temp = '\0'
break
case '>':
if(cbuff1 == '=') {
MoveNext()MoveNext()
*temp = '>'
temp++
*temp = '='
item=GE
type=CMP
} else if(cbuff1 == '>') {
MoveNext()MoveNext()
*temp = '>'
temp++
*temp = '>'
item=RS
type=OPE
}
else {
MoveNext()
*temp = '>'
item=GT
type=CMP
}
temp++
*temp = '\0'
break
case '+':
if(cbuff1 == '+') {
MoveNext()MoveNext()
*temp = '+'
temp++
*temp = '+'
temp++
*temp = '\0'
item=INC
type=OPE
}
break
case '-':
if(cbuff1 == '-') {
MoveNext()MoveNext()
*temp = '-'
temp++
*temp = '-'
temp++
*temp = '\0'
item=DEC
type=OPE
}
break
}
if(*stoken) return
}
// 其它运算符号
if(strchr("+-*^/=().[]|!%", cbuff)) {
type=OPE
switch(cbuff){
case '+':
item=ADDbreak
case '-':
item=SUBbreak
case '*':
item=MULbreak
case '/':
item=DIVbreak
case '=':
item=ASSbreak
case '(':
item=LKbreak
case ')':
item=RKbreak
case '[':
item=LZKbreak
case ']':
item=RZKbreak
case '.':
item=FFbreak
case '|':
item=UNDEFtype=UDFbreak
case '!':
item=NOTbreak
case '%':
item=MODbreak
}
*temp = cbuff
MoveNext()
temp++
*temp = '\0'
return
}
// 分界符号
if(strchr(",#:", cbuff)) {
type=FJF
switch(cbuff){
case '':
item=EOSbreak
case ',':
item=DOUbreak
case ':':
item=MAObreak
}
*temp = cbuff
MoveNext()
temp++
*temp = '\0'
return
}
// 读取一个字符串
if(cbuff == '"') {
MoveNext()
while(cbuff != '"' &&cbuff != '\r' &&cbuff) {
// Check for \n escape sequence.
if(cbuff == '\\') {
if(cbuff1 == 'n') {
MoveNext()
*temp++ = '\n'
}
}
else if((temp - stoken) <MAX_T_LEN)
*temp++ = cbuff
MoveNext()
}
if(cbuff == '\r' || cbuff == 0)
throw InterpExc(SYNTAX)
MoveNext()*temp = '\0'
item=STRING
type=STR
return
}
// 读取一个数字
if(isdigit(cbuff)) {
while((cbuff>='0'&&cbuff<='9')||(cbuff=='.')) {
if((temp - stoken) <MAX_T_LEN)
*temp++ = cbuff
MoveNext()
}
*temp = '\0'
item=NUMBER
type=NUM
return
}
// Read identifier or keyword.
if(isalpha(cbuff)) {
while(!isdelim(cbuff)) {
if((temp - stoken) <MAX_T_LEN)
*temp++ = cbuff
MoveNext()
}
item=E_TEMP
}
*temp = '\0'
// Determine if token is a keyword or identifier.
if(item == E_TEMP) { // convert to internal form
if(KeyLookUp(stoken,item)) type=KEY// is a keyword
else {type = IDEitem=IDENTIFIER}
}
if(type==UDF)
throw InterpExc(SYNTAX)
}
bool Fenxi::KeyLookUp(char *s,Token_Item &it){
int i
// char *p
// 转为小写字母
// p = s
// while(*p) { *p = tolower(*p)p++}
for(i=0i<nTableItemi++) {
if((tokentable[i].type==KEY)&&!strcmp(tokentable[i].name, s))
{
it=tokentable[i].token
return true
}
}
return false
}
// 符号检查
bool Fenxi::isdelim(char c)
{
if(strchr(" !:,+-<>/*^=().|&[]\"%", c) || c == 9 ||
c == '\r' || c == 0) return true
return false
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）