精华内容
下载资源
问答
  • 如果数据库表User中有一列为passwd,存放的是md5加密的数据,如何更新新的数据。 update user set passwd=md5("123321") where uName="lihua"; 插入新的数据: insert into user(uName,passwd) values("xiaoqiang...

    如果数据库表User中有一列为passwd,存放的是md5加密的数据,如何更新新的数据。

    update user set passwd=md5("123321") where uName="lihua";

    插入新的数据:

    insert into user(uName,passwd) values("xiaoqiang",md5("123321")) ;

    这样存放在数据中的密码信息就是保密存放的,但是通过md5加密后的数据是不能逆向使用的,也就是说如果想严重用户的密码信息,则需要通过数据查询匹配来实现。

    比如需要进行用户身份认证,则需要执行下面查询语句:

    select * from user where uName="lihua" and passwd=md5("123321");

    展开全文
  • 在前端防止SQL注入时,有个需求:在js中加密前端向后端传递的SQL语句,在后端进行解密后运行SQL语句。前端js加密方式有很多,但是存在很非可逆的加密,所以只能找已经成熟的js加密解密工具; 1、crypto-js.min.js ...

    在前端防止SQL注入时,有个需求:在js中加密前端向后端传递的SQL语句,在后端进行解密后运行SQL语句。前端js加密方式有很多,但是存在很多非可逆性的加密,所以只能找已经成熟的js加密解密工具;
    1、crypto-js.min.js
    2、base64.js
    第一种加密方式本人在实际测试中发现会存在SQL语句过长,加密、解密后导致SQL语句被截取,不完整的情况,所以采取的是第二中js加密方式。

    (1)在后端解密时,使用的是java类调用js(base64.js)中的方法的方式,实现代码:

       /**
         * 解密,
         * @param str  密文
         * @param str_src_Path js存放路径,path+name
         * @return
         */
        public static String decrypt(String str,String str_src_Path){
            ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
            ScriptEngine nashorn = scriptEngineManager.getEngineByName("nashorn");
            try {
                // 读取js文件内容
                nashorn.eval(new FileReader(str_src_Path));
                //调用js代码,进行参数加密
                Object eval = nashorn.eval("decrypt(\"" + str + "\")");
                System.out.println("解密后明文==="+eval.toString());
                return eval.toString() ;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null ;
        }
        
        /**
         * 加密,
         * @param str 明文
         * @param str_src_Path js存放路径,path+name
         * @return
         */
        public static String encrypt(String str,String str_src_Path){
            ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
            ScriptEngine nashorn = scriptEngineManager.getEngineByName("nashorn");
            try {
                // 读取js文件内容
                nashorn.eval(new FileReader(str_src_Path));
                //调用js代码,进行参数加密
                Object eval = nashorn.eval("encrypt(\"" + str + "\")");
                System.out.println("加密后密文  "+eval.toString());
                return eval.toString() ;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null ;
        }
    

    (2)base64.js经过微调,增加了如下代码,加密解密的方法名参数个数需要与java代码中的一致

    //加密
    function encrypt(message)
    {
        return encode(message);
    }
    //解密
    function decrypt(ciphertext)
    {
        return decode(ciphertext);
    }
    
    

    base64.js经过微调,全部内容为:

    /*
     * [hi-base64]{@link https://github.com/emn178/hi-base64}
     *
     * @version 0.2.1
     * @author Chen, Yi-Cyuan [emn178@gmail.com]
     * @copyright Chen, Yi-Cyuan 2014-2017
     * @license MIT
     */
    /*jslint bitwise: true */
    
    'use strict';
    
    var root = typeof window === 'object' ? window : {};
    var NODE_JS = !root.HI_BASE64_NO_NODE_JS && typeof process === 'object' && process.versions && process.versions.node;
    if (NODE_JS)
    {
        root = global;
    }
    var COMMON_JS = !root.HI_BASE64_NO_COMMON_JS && typeof module === 'object' && module.exports;
    var AMD = typeof define === 'function' && define.amd;
    var BASE64_ENCODE_CHAR = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');
    var BASE64_DECODE_CHAR =
    {
        'A' : 0,
        'B' : 1,
        'C' : 2,
        'D' : 3,
        'E' : 4,
        'F' : 5,
        'G' : 6,
        'H' : 7,
        'I' : 8,
        'J' : 9,
        'K' : 10,
        'L' : 11,
        'M' : 12,
        'N' : 13,
        'O' : 14,
        'P' : 15,
        'Q' : 16,
        'R' : 17,
        'S' : 18,
        'T' : 19,
        'U' : 20,
        'V' : 21,
        'W' : 22,
        'X' : 23,
        'Y' : 24,
        'Z' : 25,
        'a' : 26,
        'b' : 27,
        'c' : 28,
        'd' : 29,
        'e' : 30,
        'f' : 31,
        'g' : 32,
        'h' : 33,
        'i' : 34,
        'j' : 35,
        'k' : 36,
        'l' : 37,
        'm' : 38,
        'n' : 39,
        'o' : 40,
        'p' : 41,
        'q' : 42,
        'r' : 43,
        's' : 44,
        't' : 45,
        'u' : 46,
        'v' : 47,
        'w' : 48,
        'x' : 49,
        'y' : 50,
        'z' : 51,
        '0' : 52,
        '1' : 53,
        '2' : 54,
        '3' : 55,
        '4' : 56,
        '5' : 57,
        '6' : 58,
        '7' : 59,
        '8' : 60,
        '9' : 61,
        '+' : 62,
        '/' : 63,
        '-' : 62,
        '_' : 63
    };
    
    var utf8ToBytes = function (str)
    {
        var bytes = [];
        for (var i = 0; i < str.length; i++)
        {
            var c = str.charCodeAt(i);
            if (c < 0x80)
            {
                bytes[bytes.length] = c;
            }
            else if (c < 0x800)
            {
                bytes[bytes.length] = 0xc0 | (c >> 6);
                bytes[bytes.length] = 0x80 | (c & 0x3f);
            }
            else if (c < 0xd800 || c >= 0xe000)
            {
                bytes[bytes.length] = 0xe0 | (c >> 12);
                bytes[bytes.length] = 0x80 | ((c >> 6) & 0x3f);
                bytes[bytes.length] = 0x80 | (c & 0x3f);
            }
            else
            {
                c = 0x10000 + (((c & 0x3ff) << 10) | (str.charCodeAt(++i) & 0x3ff));
                bytes[bytes.length] = 0xf0 | (c >> 18);
                bytes[bytes.length] = 0x80 | ((c >> 12) & 0x3f);
                bytes[bytes.length] = 0x80 | ((c >> 6) & 0x3f);
                bytes[bytes.length] = 0x80 | (c & 0x3f);
            }
        }
        return bytes;
    };
    
    var decodeAsBytes = function (base64Str)
    {
        var v1,
        v2,
        v3,
        v4,
        bytes = [],
        index = 0,
        length = base64Str.length;
        if (base64Str.charAt(length - 2) === '=')
        {
            length -= 2;
        }
        else if (base64Str.charAt(length - 1) === '=')
        {
            length -= 1;
        }
    
        // 4 char to 3 bytes
        for (var i = 0, count = length >> 2 << 2; i < count; )
        {
            v1 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
            v2 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
            v3 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
            v4 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
            bytes[index++] = (v1 << 2 | v2 >>> 4) & 255;
            bytes[index++] = (v2 << 4 | v3 >>> 2) & 255;
            bytes[index++] = (v3 << 6 | v4) & 255;
        }
    
        // remain bytes
        var remain = length - count;
        if (remain === 2)
        {
            v1 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
            v2 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
            bytes[index++] = (v1 << 2 | v2 >>> 4) & 255;
        }
        else if (remain === 3)
        {
            v1 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
            v2 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
            v3 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
            bytes[index++] = (v1 << 2 | v2 >>> 4) & 255;
            bytes[index++] = (v2 << 4 | v3 >>> 2) & 255;
        }
        return bytes;
    };
    
    var encodeFromBytes = function (bytes)
    {
        var v1,
        v2,
        v3,
        base64Str = '',
        length = bytes.length;
        for (var i = 0, count = parseInt(length / 3) * 3; i < count; )
        {
            v1 = bytes[i++];
            v2 = bytes[i++];
            v3 = bytes[i++];
            base64Str += BASE64_ENCODE_CHAR[v1 >>> 2] +
            BASE64_ENCODE_CHAR[(v1 << 4 | v2 >>> 4) & 63] +
            BASE64_ENCODE_CHAR[(v2 << 2 | v3 >>> 6) & 63] +
            BASE64_ENCODE_CHAR[v3 & 63];
        }
    
        // remain char
        var remain = length - count;
        if (remain === 1)
        {
            v1 = bytes[i];
            base64Str += BASE64_ENCODE_CHAR[v1 >>> 2] +
            BASE64_ENCODE_CHAR[(v1 << 4) & 63] +
            '==';
        }
        else if (remain === 2)
        {
            v1 = bytes[i++];
            v2 = bytes[i];
            base64Str += BASE64_ENCODE_CHAR[v1 >>> 2] +
            BASE64_ENCODE_CHAR[(v1 << 4 | v2 >>> 4) & 63] +
            BASE64_ENCODE_CHAR[(v2 << 2) & 63] +
            '=';
        }
        return base64Str;
    };
    
    var btoa = root.btoa, atob = root.atob, utf8Base64Encode, utf8Base64Decode;
    if (NODE_JS)
    {
        var Buffer = require('buffer').Buffer;
        btoa = function (str)
        {
            return new Buffer(str, 'ascii').toString('base64');
        };
    
        utf8Base64Encode = function (str)
        {
            return new Buffer(str).toString('base64');
        };
    
        encodeFromBytes = utf8Base64Encode;
    
        atob = function (base64Str)
        {
            return new Buffer(base64Str, 'base64').toString('ascii');
        };
    
        utf8Base64Decode = function (base64Str)
        {
            return new Buffer(base64Str, 'base64').toString();
        };
    }
    else if (!btoa)
    {
        btoa = function (str)
        {
            var v1,
            v2,
            v3,
            base64Str = '',
            length = str.length;
            for (var i = 0, count = parseInt(length / 3) * 3; i < count; )
            {
                v1 = str.charCodeAt(i++);
                v2 = str.charCodeAt(i++);
                v3 = str.charCodeAt(i++);
                base64Str += BASE64_ENCODE_CHAR[v1 >>> 2] +
                BASE64_ENCODE_CHAR[(v1 << 4 | v2 >>> 4) & 63] +
                BASE64_ENCODE_CHAR[(v2 << 2 | v3 >>> 6) & 63] +
                BASE64_ENCODE_CHAR[v3 & 63];
            }
    
            // remain char
            var remain = length - count;
            if (remain === 1)
            {
                v1 = str.charCodeAt(i);
                base64Str += BASE64_ENCODE_CHAR[v1 >>> 2] +
                BASE64_ENCODE_CHAR[(v1 << 4) & 63] +
                '==';
            }
            else if (remain === 2)
            {
                v1 = str.charCodeAt(i++);
                v2 = str.charCodeAt(i);
                base64Str += BASE64_ENCODE_CHAR[v1 >>> 2] +
                BASE64_ENCODE_CHAR[(v1 << 4 | v2 >>> 4) & 63] +
                BASE64_ENCODE_CHAR[(v2 << 2) & 63] +
                '=';
            }
            return base64Str;
        };
    
        utf8Base64Encode = function (str)
        {
            var v1,
            v2,
            v3,
            base64Str = '',
            bytes = utf8ToBytes(str),
            length = bytes.length;
            for (var i = 0, count = parseInt(length / 3) * 3; i < count; )
            {
                v1 = bytes[i++];
                v2 = bytes[i++];
                v3 = bytes[i++];
                base64Str += BASE64_ENCODE_CHAR[v1 >>> 2] +
                BASE64_ENCODE_CHAR[(v1 << 4 | v2 >>> 4) & 63] +
                BASE64_ENCODE_CHAR[(v2 << 2 | v3 >>> 6) & 63] +
                BASE64_ENCODE_CHAR[v3 & 63];
            }
    
            // remain char
            var remain = length - count;
            if (remain === 1)
            {
                v1 = bytes[i];
                base64Str += BASE64_ENCODE_CHAR[v1 >>> 2] +
                BASE64_ENCODE_CHAR[(v1 << 4) & 63] +
                '==';
            }
            else if (remain === 2)
            {
                v1 = bytes[i++];
                v2 = bytes[i];
                base64Str += BASE64_ENCODE_CHAR[v1 >>> 2] +
                BASE64_ENCODE_CHAR[(v1 << 4 | v2 >>> 4) & 63] +
                BASE64_ENCODE_CHAR[(v2 << 2) & 63] +
                '=';
            }
            return base64Str;
        };
    
        atob = function (base64Str)
        {
            var v1,
            v2,
            v3,
            v4,
            str = '',
            length = base64Str.length;
            if (base64Str.charAt(length - 2) === '=')
            {
                length -= 2;
            }
            else if (base64Str.charAt(length - 1) === '=')
            {
                length -= 1;
            }
    
            // 4 char to 3 bytes
            for (var i = 0, count = length >> 2 << 2; i < count; )
            {
                v1 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
                v2 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
                v3 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
                v4 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
                str += String.fromCharCode((v1 << 2 | v2 >>> 4) & 255) +
                String.fromCharCode((v2 << 4 | v3 >>> 2) & 255) +
                String.fromCharCode((v3 << 6 | v4) & 255);
            }
    
            // remain bytes
            var remain = length - count;
            if (remain === 2)
            {
                v1 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
                v2 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
                str += String.fromCharCode((v1 << 2 | v2 >>> 4) & 255);
            }
            else if (remain === 3)
            {
                v1 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
                v2 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
                v3 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
                str += String.fromCharCode((v1 << 2 | v2 >>> 4) & 255) +
                String.fromCharCode((v2 << 4 | v3 >>> 2) & 255);
            }
            return str;
        };
    
        utf8Base64Decode = function (base64Str)
        {
            var str = '',
            bytes = decodeAsBytes(base64Str),
            length = bytes.length;
            var i = 0,
            followingChars = 0,
            b,
            c;
            while (i < length)
            {
                b = bytes[i++];
                if (b <= 0x7F)
                {
                    str += String.fromCharCode(b);
                    continue;
                }
                else if (b > 0xBF && b <= 0xDF)
                {
                    c = b & 0x1F;
                    followingChars = 1;
                }
                else if (b <= 0xEF)
                {
                    c = b & 0x0F;
                    followingChars = 2;
                }
                else if (b <= 0xF7)
                {
                    c = b & 0x07;
                    followingChars = 3;
                }
                else
                {
                    throw 'not a UTF-8 string';
                }
    
                for (var j = 0; j < followingChars; ++j)
                {
                    b = bytes[i++];
                    if (b < 0x80 || b > 0xBF)
                    {
                        throw 'not a UTF-8 string';
                    }
                    c <<= 6;
                    c += b & 0x3F;
                }
                if (c >= 0xD800 && c <= 0xDFFF)
                {
                    throw 'not a UTF-8 string';
                }
                if (c > 0x10FFFF)
                {
                    throw 'not a UTF-8 string';
                }
    
                if (c <= 0xFFFF)
                {
                    str += String.fromCharCode(c);
                }
                else
                {
                    c -= 0x10000;
                    str += String.fromCharCode((c >> 10) + 0xD800);
                    str += String.fromCharCode((c & 0x3FF) + 0xDC00);
                }
            }
            return str;
        };
    }
    else
    {
        utf8Base64Encode = function (str)
        {
            var result = '';
            for (var i = 0; i < str.length; i++)
            {
                var charcode = str.charCodeAt(i);
                if (charcode < 0x80)
                {
                    result += String.fromCharCode(charcode);
                }
                else if (charcode < 0x800)
                {
                    result += String.fromCharCode(0xc0 | (charcode >> 6)) +
                    String.fromCharCode(0x80 | (charcode & 0x3f));
                }
                else if (charcode < 0xd800 || charcode >= 0xe000)
                {
                    result += String.fromCharCode(0xe0 | (charcode >> 12)) +
                    String.fromCharCode(0x80 | ((charcode >> 6) & 0x3f)) +
                    String.fromCharCode(0x80 | (charcode & 0x3f));
                }
                else
                {
                    charcode = 0x10000 + (((charcode & 0x3ff) << 10) | (str.charCodeAt(++i) & 0x3ff));
                    result += String.fromCharCode(0xf0 | (charcode >> 18)) +
                    String.fromCharCode(0x80 | ((charcode >> 12) & 0x3f)) +
                    String.fromCharCode(0x80 | ((charcode >> 6) & 0x3f)) +
                    String.fromCharCode(0x80 | (charcode & 0x3f));
                }
            }
            return btoa(result);
        };
    
        utf8Base64Decode = function (base64Str)
        {
            var tmpStr = atob(base64Str.trim('=').replace(/-/g, '+').replace(/_/g, '/'));
            if (!/[^\x00-\x7F]/.test(tmpStr))
            {
                return tmpStr;
            }
            var str = '',
            i = 0,
            length = tmpStr.length,
            followingChars = 0,
            b,
            c;
            while (i < length)
            {
                b = tmpStr.charCodeAt(i++);
                if (b <= 0x7F)
                {
                    str += String.fromCharCode(b);
                    continue;
                }
                else if (b > 0xBF && b <= 0xDF)
                {
                    c = b & 0x1F;
                    followingChars = 1;
                }
                else if (b <= 0xEF)
                {
                    c = b & 0x0F;
                    followingChars = 2;
                }
                else if (b <= 0xF7)
                {
                    c = b & 0x07;
                    followingChars = 3;
                }
                else
                {
                    throw 'not a UTF-8 string';
                }
    
                for (var j = 0; j < followingChars; ++j)
                {
                    b = tmpStr.charCodeAt(i++);
                    if (b < 0x80 || b > 0xBF)
                    {
                        throw 'not a UTF-8 string';
                    }
                    c <<= 6;
                    c += b & 0x3F;
                }
                if (c >= 0xD800 && c <= 0xDFFF)
                {
                    throw 'not a UTF-8 string';
                }
                if (c > 0x10FFFF)
                {
                    throw 'not a UTF-8 string';
                }
    
                if (c <= 0xFFFF)
                {
                    str += String.fromCharCode(c);
                }
                else
                {
                    c -= 0x10000;
                    str += String.fromCharCode((c >> 10) + 0xD800);
                    str += String.fromCharCode((c & 0x3FF) + 0xDC00);
                }
            }
            return str;
        };
    }
    
    var encode = function (str, asciiOnly)
    {
        var notString = typeof(str) != 'string';
        if (notString && str.constructor === root.ArrayBuffer)
        {
            str = new Uint8Array(str);
        }
        if (notString)
        {
            return encodeFromBytes(str);
        }
        else
        {
            if (!asciiOnly && /[^\x00-\x7F]/.test(str))
            {
                return utf8Base64Encode(str);
            }
            else
            {
                return btoa(str);
            }
        }
    };
    
    var decode = function (base64Str, asciiOnly)
    {
        return asciiOnly ? atob(base64Str) : utf8Base64Decode(base64Str);
    };
    
    var exports =
    {
        encode : encode,
        decode : decode,
        atob : atob,
        btoa : btoa
    };
    decode.bytes = decodeAsBytes;
    decode.string = decode;
    
    if (COMMON_JS)
    {
        module.exports = exports;
    }
    else
    {
        root.base64 = exports;
        if (AMD)
        {
            define(function ()
            {
                return exports;
            }
            );
        }
    }
    
    //加密
    function encrypt(message)
    {
        return encode(message);
    }
    //解密
    function decrypt(ciphertext)
    {
        return decode(ciphertext);
    }
    
    

    在之后的实际使用中发现,完全一致的SQL,在js中进行的加密SQL语句,与在Java类中调用js进行的加密SQL语句的密文不一致;出现的问题是,在js中加密完成后,在Java类中进行解密时报错,某些SQL语句在加密后进行解密报错,如下:

    javax.script.ScriptException: not a UTF-8 string in <eval> at line number 412 at column number 20
    null
    	at jdk.nashorn.api.scripting.NashornScriptEngine.throwAsScriptException(NashornScriptEngine.java:470)
    	at jdk.nashorn.api.scripting.NashornScriptEngine.evalImpl(NashornScriptEngine.java:454)
    	at jdk.nashorn.api.scripting.NashornScriptEngine.evalImpl(NashornScriptEngine.java:406)
    	at jdk.nashorn.api.scripting.NashornScriptEngine.evalImpl(NashornScriptEngine.java:402)
    	at jdk.nashorn.api.scripting.NashornScriptEngine.eval(NashornScriptEngine.java:155)
    	at javax.script.AbstractScriptEngine.eval(AbstractScriptEngine.java:264)
    	at com.sinosoft.utility.Ciphertext.decrypt(Ciphertext.java:40)
    	at com.sinosoft.utility.Ciphertext.main(Ciphertext.java:21)
    Caused by: <eval>:412:20 not a UTF-8 string
    	at jdk.nashorn.internal.runtime.ECMAException.create(ECMAException.java:113)
    	at jdk.nashorn.internal.scripts.Script$Recompilation$10$9908A$\^eval\_.utf8Base64Decode-1(<eval>:412)
    	at jdk.nashorn.internal.scripts.Script$Recompilation$9$15488AA$\^eval\_.decode(<eval>:576)
    	at jdk.nashorn.internal.scripts.Script$Recompilation$8$16047A$\^eval\_.decrypt(<eval>:614)
    	at jdk.nashorn.internal.scripts.Script$7$\^eval\_.:program(<eval>:1)
    	at jdk.nashorn.internal.runtime.ScriptFunctionData.invoke(ScriptFunctionData.java:637)
    	at jdk.nashorn.internal.runtime.ScriptFunction.invoke(ScriptFunction.java:494)
    	at jdk.nashorn.internal.runtime.ScriptRuntime.apply(ScriptRuntime.java:393)
    	at jdk.nashorn.api.scripting.NashornScriptEngine.evalImpl(NashornScriptEngine.java:449)
    	... 6 more
    

    经过分析,在js中进行加密时,是SQL语句中存在特殊字符 %% 两个%,经过两次加密后,在解密两次,就不会报错了,只是 %被替换为%25,

    总结:报错 javax.script.ScriptException: not a UTF-8 string in at line number 412 at column number 20
    是在js中加密时,可能与SQL语句含有特殊字符,加密多次即可。

    展开全文
  • 外部数据库使用SQL语句可以快速地完成数据库的种种操作,如:查询、修改、插入记录、删除记录等。至于更多的,比如:创建表、删除表、加密数据等等,等我们能够比较熟练地掌握数据库的操作再研究。一、基本命令...

    易语言与SQL (易语言使用SQL语句)

    ━━━━━━━━━━━━━━━━━━━━━━━━━

    学习使用数据库,难免要使用SQL语句。外部数据库使用SQL语句可以快速地完成对数据库的种种操作,如:查询、修改、插入记录、删除记录等。至于更多的,比如:创建表、删除表、加密数据等等,等我们能够比较熟练地掌握数据库的操作再研究。

    一、基本命令格式

    1、查询记录

    基本格式:select 字段名 from 表名 where 条件

    例如:要查询“员工表"中“张三"的信息,可以这么写:“select *

    from 员工表 where

    姓名='张三'"。这里,“员工表"是要查询的表的名称,“姓名"是字段名称。

    如果要查询的是张三的电话呢?就得这么写:“select 电话 from

    员工表 where 姓名='张三'"。“电话"也是该表中的字段。

    如果要查询整个表的信息,就不需要加“where"。比如,要查询“员工表"中所有员工的全部信息,就可以这么写:“select * from 员工表"。

    2、删除记录

    基本格式:delete from 表名 where 条件

    例如:要删除“学生表"中“成绩"小于50的学生名字,可以这么写:“delete from 学生表 where 成绩<50"

    如果不加条件,就会删除该表中所有记录,该表就变成一个没有记录的空表,以后还可以向表中添加记录。本命令与删除表“drop

    table"不同,“drop table"删除的是被操作的表,删除后,整个表都不存在,也就不可以再添加记录了。

    3、添加记录

    基本格式:insert into 表名(字段1,字段2,字段3) values

    (字段1的值,字段2的值,字段3的值)

    本命令是往指定的表中添加记录。要注意,“表名"后面括号中是被操作的字段名称,“values"后面括号中是对应的字段值,不要弄错了位置的先后顺序。还有,本命令不可以跟“where",因为你要添加的记录在表中根本没有,所以也就不可以有什么条件了。

    4、修改记录

    基本格式:update 表名 set 欲修改的字段名1=该字段的新值,欲修改的字段名2=该字段的新值 where

    条件

    该命令是修改表中已经存在的记录数据。如果不加“where"条件,就会把所有指定的字段都改成新值。

    比如:要修改“员工表"中“张三"的工资为1500,应该这么写:“update 员工表 set 工资=1500 where

    姓名='张三'"。

    二、易语言命令操作数据库

    在易语言中,对外部数据库,比如ACCESS的操作,有如下方法:

    一个是用“外部数据库",另一个是用“数据库连接"和“记录集"。前一种是我这段时间正在学习的,操作起来比较方便。后一种我还没有用过,不敢多讲。不过,我觉得记录集就象一张表格,只是这表格是看不见的,是动态的。在这里,我只说一下“外部数据库"。

    1、查询操作

    基本命令:外部数据库控件名称.查询(SQL命令语句)

    这一命令只可以用来进行查询操作。使用的时候要注意SQL语句是否正确。

    如果查询的记录存在,则回车满足查询条件的记录的条数,否则回车0。

    2、非查询操作

    基本命令:外部数据库控件名称.执行(SQL命令语句,操作的数据)

    这一命令可以完成对数据的添加、删除、修改等操作,也可以完成对数据库中表的创建、删除。此命令有两个参数,第一个是SQL命令,后一个是你要操作的数据。第二个参数是可以省略的,只在对表中的备注型、OLE型字段进行操作时才用。

    本命令执行成功回车真,否则回车假。这样我们就可以通过执行的结果来判断操作是否正确了。

    比如,你想把一张图 片放入数据库,应该这么做:

    外部数据库1.执行(“insert into 图 片表(图 片名,图 片)

    values ('美丽的图 片',?)",读入文件(你要放入的图 片的文件名称))

    其中,“图 片表"是你的数据库中存放图 片的表的名称,“图 片名"和“图

    片"是字段名称,前一字段是文本型的,后一字段是OLE型,也就是易语言中字节集型的。

    “美丽的图 片"是在表中插入的新记录中“图

    片名"字段所对应的值,在SQL语句中要用单引号括起来。“?"表示你要操作的数据,如果你操作的数据中有字节集型的,应该用“?"代替,在后面的第二参数中写入真正的数据内容。如果你同时操作多个字节集型的数据,应该用多个“?",并且后面按照顺序放置相应的值。

    3、读数据库数据

    读数据的时候,首先要用查询命令,要不然是没法读数据的。

    建立一个变量,存放查询的结果。如:查询结果,整数型。

    查询结果=外部数据库控件名称.查询(查询类的SQL语句)

    外部数据库控件名称.到首记录(查询结果)

    存放数据的变量=外部数据库控件名称.读(查询结果,要读的字段名称)

    好了,以上是我学习数据库以来的一点体会,与朋友们一同分享。朋友们也可以看一下我最近发的软件《小小日记本》、《易用通讯录》和例程《图

    片导入数据库》,里面用了SQL语句对ACCESS数据库进行记录的增删、修改、查询等操作

    模糊查询1 查询姓名中带“李”的同学

    aql语句=“select*from 成绩表 where 姓名 like

    ‘%李%’”

    like 是模糊匹配的意思 % 是SQL语言里的通配符,用于表示多个字符 长度不限

    模糊查询2 查询 姓“李”的同学

    aql语句=“select*from 成绩表 where 姓名 like

    ‘李_’”

    “_”也是一个通配符 用于表示一个字符 (半角下划线)

    过滤一个字段重复数据

    select distinct 字段 from 表

    distinct 过滤重复的子句!

    sql = “select 字段名 from 表明 order by

    排序的字段名 asc”

    order by 排序命令 ASC为升序,DESC为降序

    展开全文
  • 经典SQL语句大全

    热门讨论 2014-12-20 12:00:30
    10、说明:几个简单的基本的sql语句 选择:select * from table1 where 范围 插入:insert into table1(field1,field2) values(value1,value2) 删除:delete from table1 where 范围 更新:update table1 set field1...
  • 常用SQL 语句大全

    2011-06-18 11:47:51
    10、几个简单的基本的sql语句 11、几个高级查询运算词 12、使用外连接 13、分组:Group by: 14、数据库进行操作: 15.如何修改数据库的名称: 第二部分、 提升 1、复制表 2、拷贝表 3、跨数据库之间表的...
  • 能直接查看到已经加密SQL视图语句,可以复制,非常好用,而且不会对加密的视图有任何影响。
  • SQL 语句的解析过程

    2018-12-11 16:03:12
    SSL的基本概念和框架 ...简单说就是首先要通信两端的身份进行认证确保是真实的,接下来就是确保通信双方交换的数据进行加密确保只有真实的对手方才能看到,任何其他的人即便拿到数据也无法获...

    SSL的基本概念和框架

    SSL 缩写 Secure Socket Layer ,是几十年前网景公司制定的保证服务器和客户端安全通信的一种协议,大量使用在http的安全通信中,这里的安全通信有两层含义:

    • 通信双方身份的认证
    • 通信数据的保密

    简单说就是首先要对通信两端的身份进行认证确保是真实的,接下来就是确保通信双方交换的数据进行加密确保只有真实的对手方才能看到,任何其他的人即便拿到数据也无法获得有效信息。这里要注意, SSL 并不包含或实现身份认证的方法和数据加密方法, SSL 只是制定了一套可靠的 C-S 之间的协商办法,来确定通信双方如何身份认证和加密。现在 SSL 里头基本使用 PKI 数字证书方式认证,加密的算法很多,对称非对称,这些网上资料很多自己 google 之。

    SSL 是如何工作的呢?基本上 SSL 的工作分为两个阶段:握手阶段和数据传输阶段,若通信期间检测到不安全因素,比如握手时候发现另一端无法支持选择的协议或加密算法,或者发现数据被篡改,这时通信一方会发送警告消息,不安全因素影响比较大两端之间的通信就会终止,必须重新协商建立连接。

     

    SSL 协议结构如下:

     

    通过 SSL 分成三个子协议, HandShake( 握手) ChangeCipherSpec( 更改密钥规格 ), Alert( 告警 )

     

    SSL 的告警协议是用来为通信对方发送一条告警消息,告警分为两个层次: fatal warning, 如果是 fatal 级别的如 MAC 计算出错或协商密钥算法失败则马上断开连接,要建立连接的话需要重新握手; warning 类型的消息一般只会记录日志,并不会断开连接。

     

    SSL 更换密钥规格 (change cipher spec) 协议独立于握手协议,单独属于一类,也是其中最简单的一个。协议由单个消息组成 , 该消息只包含一个值为 1 的单个字节。该消息由客户端和服务器端各自发出用来通知对方,从这个消息以后要开始使用之前协商好的密钥套件了,这个消息一般是在握手到发出 Finish 消息之前发出。

     

    SSL 握手协议主要负责如下工作:

    • 算法协商:首次通信时,双方通过握手协议协商密钥加密算法,数据加密算法和文摘算法。
    • 身份验证:在密钥协商完成后,客户端与服务器端通过证书互相验证对方的身份。
    • 确定密钥:最后使用协商好的密钥交换算法产生一个只有双方知道的秘密信息,客户端和服务器各自根据这个秘密信息计算出加密密钥,在接下来的记录协议中用来对应用数据进行加密;

     

    如果说握手协议是 C/S 双方的协商的话记录协议就是利用协商结果对上层应用提供两种服务:

    • 机密性:使用协商好的通信密钥对业务数据加解密;
    • 数据完整性:利用协商好的 MAC 算法计算消息 HASH ,防止消息被篡改;

     

    协议规定每个记录层的协议数据包长度不能超过 2^14(16K) ,因此记录协议接收到层应用业务数据若超长会将业务数据分块,压缩 ( 可选 ) ,计算 MAC ,加密,按上记录层协议头发出去。

     

    本教程由尚硅谷教育大数据研究院出品,如需转载请注明来源。

    展开全文
  • 6.5 加密密钥和内置加密函数 工业和政府开始要求数据库数据进行加密。在美国,健康保健和信用卡行业最先受到影响。...有时候,数据加密在其他数据库的列级别上实现,具体做法是使用DDL扩展语句声明要加密的列。...
  • 原文: sql server 数据库的备份进行加密 嗯,最近在研究数据库... 首先,我从网上搜到的,数据库备份加密的方法,主要有三种: 1、在使用 BACKUP 语句时,添加 PASSWORD 参数【此方法适用于 sql server 2012 ...
  • !... private void button2_Click... 上面的是我的任务要求,但是我的SQL语句写错了,报错ORA-01008: 并非所有变量都已绑定,而且我还不知道C#中的richTextBox2.Text每行的数据插入到ORACLE中应该用什么参数,求大家帮忙
  • 登录时,需要用户输入的密码进行加密处理后与数据表中的密码字段值进行校验,校验通过方可允许登录。 提示:以上的语句表示,先执行dbcc sqlperf(logspace)这个存储过程,将各数据库的日志文件大小插入zdy_...
  • sql经典语句一部分

    2011-07-31 11:16:50
    经典SQL语句大全 一、基础 1、说明:创建数据库 CREATE DATABASE database-name 2、说明:删除数据库 drop database dbname 3、说明:备份sql server --- 创建 备份数据的 device USE master EXEC sp_addumpdevice ...
  • 1、sql语句对数据库中的密码字段进行加密的方法: 首先查看密码字段的约束长度符不符合md5摘要的长度,如果不符合请先用下面命令修改约束长度: alter table tb_user modify password varchar(32); 密码内容进行...
  • 执行sql 语句对数据库解密:ALTER DATABASE database_name SET ENCRYPTION OFF; DROP DATABASE ENCRYPTION KEY 删除 证书和master key DROP CERTIFICATE certificate_name DROP MASTER KEY 再...
  • 对SQL Server 2008的安全入门略作小结,以作备忘。本文涉及两个应用:存储过程加密和安全上下文。 <一>存储过程加密 SQL server,我已经成了存储过程的忠实拥趸。在直接使用SQL语句还是存储过程来处理业务...
  • -- 使用WITH ENCRYPTION选项可用于加密SQL存储过程或者触发器(SQLServer本身提供的加密算法). -- WITH ENCRYPTION子句用户隐藏存储过程的文本。 -- 加密存储过程 Create procname WITH ENCRYPTION as ...
  • 10、说明:几个简单的基本的sql语句 选择:select * from table1 where 范围 插入:insert into table1(field1,field2) values(value1,value2) 删除:delete from table1 where 范围 更新:update table1 set field1...
  • 最近对SQL Server 2008的安全入门略作小结,以作备忘。本文涉及两个应用:存储过程加密和安全上下文。 <一>存储过程加密 其实,用了这十多年的SQL server,我已经成了存储过程的忠实拥趸。在直接使用SQL语句...
  • --用以下语句备份数据库BACKUP DATABASE [demo] TO DISK = N'C:\demo.bak' WITH NOFORMAT, NOINIT, NAME = N'demo-完整 数据库 备份', SKIP, NOREWIND, NOUNLOAD, STATS = 10 ,PASSWORD = '123456'--密码,可要记录...
  • 最近对SQL Server 2008的安全入门略作小结,以作备忘。本文主要是针对存储过程加密与安全来作分析。 http://database.51cto.com/art/201102/246498.htm 存储过程加密 其实,用了这十多年的SQL server,我已经成...
  • SQL注入是一种注入攻击,由于应用程序用户输入数据的合法性没有判断或过滤不严,攻击者可以在应用程序中事先定义好的查询语句的结尾添加恶意的SQL语句,从而在管理员不知情的情况下,攻击者能够完全控制应用程序...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 583
精华内容 233
关键字:

对sql语句加密