精华内容
下载资源
问答
  • RSA密钥长度、明文长度和密文长度

    万次阅读 2018-06-02 13:48:35
    本文介绍RSA加解密中必须考虑到的密钥长度、明文长度和密文长度问题,对第一次接触RSA的开发人员来说,RSA算是比较复杂的算法,天缘以后还会补充几篇RSA基础知识专题文章,用最简单最通俗的语言描述RSA,让各位了解...

    本文介绍RSA加解密中必须考虑到的密钥长度、明文长度和密文长度问题,对第一次接触RSA的开发人员来说,RSA算是比较复杂的算法,天缘以后还会补充几篇RSA基础知识专题文章,用最简单最通俗的语言描述RSA,让各位了解RSA算法本身其实也很简单,RSA的复杂度是因为数学家把效率和安全也考虑进去的缘故。

    本文先只谈密钥长度、明文长度和密文长度的概念知识,RSA的理论及示例等以后再谈。提到密钥,我们不得不提到RSA的三个重要大数:公钥指数e、私钥指数d和模值n。这三个大数是我们使用RSA时需要直接接触的,理解了本文的基础概念,即使未接触过RSA的开发人员也能应对自如的使用RSA相关函数库,无需深入了解e、d、n是如何生成的,只需要知道我该如何用、要注意什么。

    一、密钥长度

    1、密钥是指谁?

    首先我们说的“密钥”是指谁?由于RSA密钥是(公钥+模值)、(私钥+模值)分组分发的,单独给对方一个公钥或私钥是没有任何用处,所以我们说的“密钥”其实是它们两者中的其中一组。但我们说的“密钥长度”一般只是指模值的位长度。目前主流可选值:1024、2048、3072、4096...

    2、模值主流长度是多少?

    目前主流密钥长度至少都是1024bits以上,低于1024bit的密钥已经不建议使用(安全问题)。那么上限在哪里?没有上限,多大都可以使用。所以,主流的模值是1024位,实际运算结果可能会略小于1024bits,注意,这个值不是绝对的,跟素数的生成算法有关系,只是告诉素数生成器“帮我生成一个接近1024位的素数而已”,然后生成器“好,给您一个,这个差不多1024位”。

    素数生成器这么厉害?说生成1024位就会出个1024位的大整数?真实的情况是素数生成器也只是在1024bits对应的整数附近进行“摸索”而已,大家其实都不容易,又要快又要准确又要随机性,那么素数生成器也只能应付一下,找到1024位的算是好运,没找到1024位,1023位也照样送出来:)。

    3、公钥指数如何确定?

    公钥指数是随意选的,但目前行业上公钥指数普遍选的都是65537(0x10001,5bits),该值是除了1、3、5、17、257之外的最小素数,为什么不选的大一点?当然可以,只是考虑到既要满足相对安全、又想运算的快一点(加密时),PKCS#1的一个建议值而已。

    有意的把公钥指数选的小一点,但是对应私钥指数肯定很大,意图也很明确,大家都要用公钥加密,所以大家时间很宝贵,需要快一点,您一个人私钥解密,时间长一点就多担待,少数服从多数的典型应用。

    4、私钥指数如何确定?

    公钥指数随意选,那么私钥就不能再随意选了,只能根据算法公式(ed%k=1,k=(p-1)(q-1))进行运算出来。那么私钥指数会是多少位?根据ed关系,私钥d=(x*k+1)/e,所以单看这个公式,私钥指数似乎也不是唯一结果,可能大于也可能小于1024bits的,但我们习惯上也是指某个小于1024bits的大整数。

    包括前文的公钥指数,在实际运算和存储时为方便一般都是按照标准位长进行使用,前面不足部分补0填充,所以,使用保存和转换这些密钥需要注意统一缓冲区的长度。

    二、明文长度

    网上有说明文长度小于等于密钥长度(Bytes)-11,这说法本身不太准确,会给人感觉RSA 1024只能加密117字节长度明文。实际上,RSA算法本身要求加密内容也就是明文长度m必须0<m<n,也就是说内容这个大整数不能超过n,否则就出错。那么如果m=0是什么结果?普遍RSA加密器会直接返回全0结果。如果m>n,运算就会出错?!那怎么办?且听下文分解。

    所以,RSA实际可加密的明文长度最大也是1024bits,但问题就来了:

    如果小于这个长度怎么办?就需要进行padding,因为如果没有padding,用户无法确分解密后内容的真实长度,字符串之类的内容问题还不大,以0作为结束符,但对二进制数据就很难理解,因为不确定后面的0是内容还是内容结束符。

    只要用到padding,那么就要占用实际的明文长度,于是才有117字节的说法。我们一般使用的padding标准有NoPPadding、OAEPPadding、PKCS1Padding等,其中PKCS#1建议的padding就占用了11个字节。

    如果大于这个长度怎么办?很多算法的padding往往是在后边的,但PKCS的padding则是在前面的,此为有意设计,有意的把第一个字节置0以确保m的值小于n。

    这样,128字节(1024bits)-减去11字节正好是117字节,但对于RSA加密来讲,padding也是参与加密的,所以,依然按照1024bits去理解,但实际的明文只有117字节了。

    关于PKCS#1 padding规范可参考:RFC2313 chapter 8.1,我们在把明文送给RSA加密器前,要确认这个值是不是大于n,也就是如果接近n位长,那么需要先padding再分段加密。除非我们是“定长定量自己可控可理解”的加密不需要padding。

    三、密文长度

    密文长度就是给定符合条件的明文加密出来的结果位长,这个可以确定,加密后的密文位长跟密钥的位长度是相同的,因为加密公式:

    C=(P^e)%n

    所以,C最大值就是n-1,所以不可能超过n的位数。尽管可能小于n的位数,但从传输和存储角度,仍然是按照标准位长来进行的,所以,即使我们加密一字节的明文,运算出来的结果也要按照标准位长来使用(当然了,除非我们能再采取措施区分真实的位长,一般不在考虑)。

    至于明文分片多次加密,自然密文长度成倍增长,但已不属于一次加密的问题,不能放到一起考虑。

    展开全文
  • 我在一些资料上查到, 明文密文,密码 这三个东西均为64位,但试验中好像不是呀!
  • 目前遇到一个问题,需要把数据库中所有涉及到身份证号的表的字段从明文变成密文,但是表设计的时候身份证号码字段长度只有18位,有没有办法可以在不改变表接口(需要改动的表太多了)然后储存密文,并且密文是可以反...
  • 1.密钥长度 rsa算法初始化的时候一般要填入密钥长度,...看下面的明文长度),低于下限96bits时,一个byte都加密不了,当然没意义啦 (2)为啥上限是1024(128bytes)?这是算法本身决定的...当然如果某天网上出现了支持2048bi
    1.密钥长度
    rsa算法初始化的时候一般要填入密钥长度,在96-1024bits间
    (1)为啥下限是96bits(12bytes)?因为加密1byte的明文,需要至少1+11=12bytes的密钥(不懂?看下面的明文长度),低于下限96bits时,一个byte都加密不了,当然没意义啦
    (2)为啥上限是1024(128bytes)?这是算法本身决定的...当然如果某天网上出现了支持2048bits长的密钥的rsa算法时,你当我废话吧

    2.明文长度
    明文长度(bytes) <= 密钥长度(bytes)-11.这样的话,对于上限密钥长度1024bits能加密的明文上限就是117bytes了.
    这个规定很狗血,所以就出现了分片加密,网上很流行这个版本.很简单,如果明文长度大于那个最大明文长度了,我就分片吧,保证每片都别超过那个值就是了.
    片数=(明文长度(bytes)/(密钥长度(bytes)-11))的整数部分+1,就是不满一片的按一片算

    3.密文长度
    对,就是这个充满了谣言,都说密文长度为密钥长度的一半,经俺验证,密文长度等于密钥长度.当然这是不分片情况下的.
    分片后,密文长度=密钥长度*片数

    例如96bits的密钥,明文4bytes
    每片明文长度=96/8-11=1byte,片数=4,密文长度=96/8*4=48bytes

    又例如128bits的密钥,明文8bytes
    每片明文长度=128/8-11=5bytes,片数=8/5取整+1=2,密文长度=128/8*2=32

    注意,对于指定长度的明文,其密文长度与密钥长度非正比关系.如4bytes的明文,在最短密钥96bites是,密文长度48bytes,128bits米密钥时,密文长度为16bytes,1024bits密钥时,密文长度128bytes.
    因 为分片越多,密文长度显然会变大,所以有人说,那就一直用1024bits的密钥吧...拜托,现在的机器算1024bits的密钥还是要点时间滴,别以 为你的cpu很牛逼...那么选个什么值比较合适呢?个人认为是600bits,因为我们对于一个字符串的加密,一般不是直接加密,而是将字符串hash 后,对hash值加密.现在的hash值一般都是4bytes,很少有8bytes,几十年内应该也不会超过64bytes.那就用64bytes算吧, 密钥长度就是(64+11)*8=600bits了.

    用开源rsa算法的时候,还要注意,那个年代的人把long当4bytes用,如今 放在64位的机器上,就会死循环啊多悲催....因为有个循环里让一个4bytes做递减....64位机上long是8bytes,这个循环进去后个把 小时都出不来....所以要注意下哦....同理对于所有年代久远的开源库都得注意下...
    展开全文
  • java:三重des加密中明文、密文长度

    千次阅读 2012-06-13 17:03:26
    明文byte[]长度:7 相应的16进制字符串值:0123456789abcd  加密后byte[]长度:8 相应的16进制字符串值:19dffce951d8c37d  解密后byte[]长度:7 相应的16进制字符串值:0123456789abcd  对长度为8的字节...
    对长度为7的字节数组加密,解密输出结果: 
    Java代码  收藏代码
    1. 原明文byte[]长度:7   相应的16进制字符串值:0123456789abcd  
    2. 加密后byte[]长度:8   相应的16进制字符串值:19dffce951d8c37d  
    3. 解密后byte[]长度:7   相应的16进制字符串值:0123456789abcd  


    对长度为8的字节数组加密,解密输出结果: 
    Java代码  收藏代码
    1. 原明文byte[]长度:8   相应的16进制字符串值:0123456789abcdef  
    2. 加密后byte[]长度:16  相应的16进制字符串值:bb93c15e93aafe01c15629bc63a3c3c8  
    3. 解密后byte[]长度:8   相应的16进制字符串值:0123456789abcdef  


    以下是源代码(也可以下载附件里的源码),代码复制即可执行.期待您的帮助 
    Java代码  收藏代码
    1. import java.security.Key;  
    2. import javax.crypto.Cipher;  
    3. import javax.crypto.KeyGenerator;  
    4. import javax.crypto.SecretKey;  
    5.   
    6. public class DESedeCoderTest {  
    7.     public static void main(String[] args) throws Exception {  
    8.         String sHexPlainText = "0123456789abcdef";  
    9.         SecretKey skSecretkey=(SecretKey)TDESCoder.generateKey(112);  
    10.         byte[] byteaPlainText = hexStr2ByteArr(sHexPlainText);  
    11.         byte[] byteaCryptograph = TDESCoder.enc(byteaPlainText, skSecretkey);  
    12.         byte[] byteaPlainTextAftDec = TDESCoder.dec(byteaCryptograph, skSecretkey);  
    13.         System.out.println("原明文byte[]长度:"+byteaPlainText.length+"\t相应的16进制字符串值:"+byteArr2HexStr(byteaPlainText));  
    14.         System.out.println("加密后byte[]长度:"+byteaCryptograph.length+"\t相应的16进制字符串值:"+byteArr2HexStr(byteaCryptograph));  
    15.         System.out.println("解密后byte[]长度:"+byteaPlainTextAftDec.length+"\t相应的16进制字符串值:"+byteArr2HexStr(byteaPlainTextAftDec));  
    16.     }  
    17.     public static String byteArr2HexStr(byte[] bytea) throws Exception {  
    18.         String sHex = "";  
    19.         int iUnsigned = 0;  
    20.         StringBuffer sbHex = new StringBuffer();  
    21.         for (int i = 0; i < bytea.length; i++) {  
    22.             iUnsigned = bytea[i];  
    23.             if (iUnsigned < 0) {  
    24.                 iUnsigned += 256;  
    25.             }  
    26.             if (iUnsigned < 16) {  
    27.                 sbHex.append("0");  
    28.             }  
    29.             sbHex.append(Integer.toString(iUnsigned, 16));  
    30.         }  
    31.         sHex = sbHex.toString();  
    32.         return sHex;  
    33.     }  
    34.   
    35.   
    36.     public static byte[] hexStr2ByteArr(String sHex) throws Exception {  
    37.           
    38.         if(sHex.length()%2!=0){  
    39.             sHex="0"+sHex;  
    40.         }  
    41.         byte[] bytea =bytea=new byte[sHex.length() / 2];  
    42.           
    43.         String sHexSingle = "";  
    44.         for (int i = 0; i < bytea.length; i++) {  
    45.             sHexSingle = sHex.substring(i * 2, i * 2 + 2);  
    46.             bytea[i] = (byte) Integer.parseInt(sHexSingle, 16);  
    47.         }  
    48.         return bytea;  
    49.     }  
    50.        
    51. }  
    52. class TDESCoder {  
    53.     private static final String S_KEY_ALGORITHM = "DESede";  
    54.     private static final String S_CIPHER_ALGORITHM = "DESede/ECB/PKCS5Padding";  
    55.     private static SecretKey skSecretkey;  
    56.     public static byte[] enc(byte[] byteaPlainText,SecretKey skSecretkey) throws Exception {  
    57.         Cipher cipher = Cipher.getInstance(S_CIPHER_ALGORITHM);  
    58.         cipher.init(Cipher.ENCRYPT_MODE, skSecretkey);  
    59.         byte[] byteaCryptograph=cipher.doFinal(byteaPlainText);  
    60.         return byteaCryptograph;  
    61.     }  
    62.       
    63.     public static byte[] dec(byte[] byteaCryptograph,SecretKey skSecretkey) throws Exception {  
    64.         Cipher cCipher = Cipher.getInstance(S_CIPHER_ALGORITHM);  
    65.         cCipher.init(Cipher.DECRYPT_MODE, skSecretkey);  
    66.         byte[] byteaPlainText=cCipher.doFinal(byteaCryptograph);  
    67.         return byteaPlainText;  
    68.     }  
    69.   
    70.     public static Key generateKey(int iBits) throws Exception {  
    71.         iBits=112;  
    72.         KeyGenerator kg = KeyGenerator.getInstance(S_KEY_ALGORITHM);  
    73.         kg.init(iBits);  
    74.         skSecretkey = kg.generateKey();  
    75.         return   skSecretkey;  
    76.     }  
    77. }  
    2011年2月27日 14:46

    展开全文
  • pin密文是1.1+1.2 1+2=3,最后12进行二进制异或,3出表示07 密码是什么后面异或 主密加密工密,工密加密密码 密码加密就好比,方程式,也可以说实一种投影,就是密码通过工作密码进行加密...

    目录

    android des加密string:

    国密算法,明文、密文、密码、密钥、对称加密、非对称加密简单理解


     

    android des加密string:

    package com.example.ceshi;
    
    import android.util.Log;
    
    
    import com.blankj.utilcode.util.StringUtils;
    
    import java.security.SecureRandom;
    
    import javax.crypto.Cipher;
    import javax.crypto.SecretKey;
    import javax.crypto.SecretKeyFactory;
    import javax.crypto.spec.DESKeySpec;
    
    /**
     * @ProjectName: ceshi
     * @Package: com.example.ceshi
     * @ClassName: DESEncryptUtil
     * @Description: java类作用描述
     * @Author: 作者名
     * @CreateDate: 2020/7/20 0020 下午 4:14
     * @UpdateUser: 更新者:
     * @UpdateDate: 2020/7/20 0020 下午 4:14
     */
    
    public class DESEncryptUtil {
    
        public static final String PASS_WORD = "f7f0f67e45";
    
        private static SecretKeyFactory keyFactory = null;
        private static Cipher cipher = null;
        static {
            try {
                keyFactory = SecretKeyFactory.getInstance("DES");
            } catch (Exception e) {
                keyFactory = null;
            }
            try {
                cipher = Cipher.getInstance("DES");
            } catch (Exception e) {
                cipher = null;
            }
        }
    
        /**
         * DES加密
         *
         * @param password 密码,长度要是8的倍数
         * @return
         */
        public static String encrypt(String data, String password) throws Exception {
    
            try {
                SecureRandom random = new SecureRandom();
                DESKeySpec desKey = new DESKeySpec(password.getBytes());
                // 创建一个密匙工厂,然后用它把DESKeySpec转换成
                if (keyFactory == null)
                    keyFactory = SecretKeyFactory.getInstance("DES");
                SecretKey securekey = keyFactory.generateSecret(desKey);
                // Cipher对象实际完成加密操作
                if (cipher == null)
                    cipher = Cipher.getInstance("DES");
                // 用密匙初始化Cipher对象
                cipher.init(Cipher.ENCRYPT_MODE, securekey, random);
                // 现在,获取数据并加密
                // 正式执行加密操作
                return ByteStringConvertUtil.byte2HexStr(cipher.doFinal(data.getBytes()));
            } catch (Exception e) {
                throw new Exception("DES解密失败!");
            }
        }
    
        public static String decrypt(String data, String password) throws Exception {
    
            try {
                // DES算法要求有一个可信任的随机数源
                SecureRandom random = new SecureRandom();
                // 创建一个DESKeySpec对象
                DESKeySpec desKey = new DESKeySpec(password.getBytes());
                // 创建一个密匙工厂
                if (keyFactory == null)
                    keyFactory = SecretKeyFactory.getInstance("DES");
                // 将DESKeySpec对象转换成SecretKey对象
                SecretKey securekey = keyFactory.generateSecret(desKey);
                // Cipher对象实际完成解密操作
                if (cipher == null)
                    cipher = Cipher.getInstance("DES");
                // 用密匙初始化Cipher对象
                cipher.init(Cipher.DECRYPT_MODE, securekey, random);
                // 真正开始解密操作
                return new String(cipher.doFinal(ByteStringConvertUtil.hexStr2Byte(data)));
            } catch (Exception e) {
                throw new Exception("DES解密失败!");
            }
        }
    
    }
    

     

    package com.example.ceshi;
    
    public class ByteStringConvertUtil {
    	/**
    	 * 字符串转换为字节数据
    	 * 
    	 * @param hexStr
    	 * @return
    	 */
    	public static byte[] hexStr2Byte(String hexStr) {
    		if (hexStr.length() < 1)
    			return null;
    		byte result[] = new byte[hexStr.length() / 2];
    		for (int i = 0; i < hexStr.length() / 2; i++) {
    			int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
    			int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
    			result[i] = (byte) (high * 16 + low);
    		}
    		return result;
    	}
    
    	/**
    	 * 字节数组转换为字符串
    	 * 
    	 * @param buf
    	 * @return
    	 */
    	public static String byte2HexStr(byte buf[]) {
    		StringBuffer sb = new StringBuffer();
    		for (int i = 0; i < buf.length; i++) {
    			String hex = Integer.toHexString(buf[i] & 255);
    			if (hex.length() == 1)
    				hex = (new StringBuilder(String.valueOf('0'))).append(hex).toString();
    			sb.append(hex.toLowerCase());
    		}
    		return sb.toString();
    	}
    }
    
    

    测试代码:

     @Test
        public void ceshia() throws Exception {
            String s = "a77a7aaaa";
            byte [] data_Voucherno=s.getBytes();
            if(data_Voucherno.length % 8 != 0){ //not a multiple of 8
                //create a new array with a size which is a multiple of 8
                byte[] padded = new byte[data_Voucherno.length + 8 - (data_Voucherno.length % 8)];
                //copy the old array into it
                System.arraycopy(data_Voucherno, 0, padded, 0, data_Voucherno.length);
                data_Voucherno = padded;
            }
            String key = "CCIC2020";
    
            String data=DESEncryptUtil.encrypt(s,key);
            String undata=DESEncryptUtil.decrypt(data,key);
            System.out.println(data+11);
            System.out.println(undata+11);
        }

     

    还有一种:

    package com.example.ceshi;
    
    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    import java.security.spec.InvalidKeySpecException;
    
    import javax.crypto.BadPaddingException;
    import javax.crypto.Cipher;
    import javax.crypto.IllegalBlockSizeException;
    import javax.crypto.NoSuchPaddingException;
    import javax.crypto.SecretKey;
    import javax.crypto.SecretKeyFactory;
    import javax.crypto.spec.DESKeySpec;
    
    /**
     * @ProjectName: ceshi
     * @Package: com.example.ceshi
     * @ClassName: Des
     * @Description: java类作用描述
     * @Author: 作者名
     * @CreateDate: 2020/7/20 0020 下午 4:01
     * @UpdateUser: 更新者:
     * @UpdateDate: 2020/7/20 0020 下午 4:01
     */
    
    public class Des {
        /**
         * 加密(使用DES算法)
         *
         * @param txt
         *            需要加密的文本
         * @param key
         *            密钥
         * @return 成功加密的文本
         * @throws InvalidKeySpecException
         * @throws InvalidKeyException
         * @throws NoSuchPaddingException
         * @throws IllegalBlockSizeException
         * @throws BadPaddingException
         */
        public static String enCrypto(String txt, String key)
                throws InvalidKeySpecException, InvalidKeyException,
                NoSuchPaddingException, IllegalBlockSizeException,
                BadPaddingException {
            StringBuffer sb = new StringBuffer();
            DESKeySpec desKeySpec = new DESKeySpec(key.getBytes());
            SecretKeyFactory skeyFactory = null;
            Cipher cipher = null;
            try {
                skeyFactory = SecretKeyFactory.getInstance("DES");
                cipher = Cipher.getInstance("DES");
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            }
            SecretKey deskey = skeyFactory.generateSecret(desKeySpec);
            cipher.init(Cipher.ENCRYPT_MODE, deskey);
            byte[] cipherText = cipher.doFinal(txt.getBytes());
            for (int n = 0; n < cipherText.length; n++) {
                String stmp = (java.lang.Integer.toHexString(cipherText[n] & 0XFF));
    
                if (stmp.length() == 1) {
                    sb.append("0" + stmp);
                } else {
                    sb.append(stmp);
                }
            }
            return sb.toString().toUpperCase();
        }
    
        /**
         * 解密(使用DES算法)
         *
         * @param txt
         *            需要解密的文本
         * @param key
         *            密钥
         * @return 成功解密的文本
         * @throws InvalidKeyException
         * @throws InvalidKeySpecException
         * @throws NoSuchPaddingException
         * @throws IllegalBlockSizeException
         * @throws BadPaddingException
         */
        public static String deCrypto(String txt, String key)
                throws InvalidKeyException, InvalidKeySpecException,
                NoSuchPaddingException, IllegalBlockSizeException,
                BadPaddingException {
            DESKeySpec desKeySpec = new DESKeySpec(key.getBytes());
            SecretKeyFactory skeyFactory = null;
            Cipher cipher = null;
            try {
                skeyFactory = SecretKeyFactory.getInstance("DES");
                cipher = Cipher.getInstance("DES");
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            }
            SecretKey deskey = skeyFactory.generateSecret(desKeySpec);
            cipher.init(Cipher.DECRYPT_MODE, deskey);
            byte[] btxts = new byte[txt.length() / 2];
            for (int i = 0, count = txt.length(); i < count; i += 2) {
                btxts[i / 2] = (byte) Integer.parseInt(txt.substring(i, i + 2), 16);
            }
            return (new String(cipher.doFinal(btxts)));
        }
    
        public static void main(String[] args) throws InvalidKeyException,
                NoSuchAlgorithmException, InvalidKeySpecException,
                NoSuchPaddingException, IllegalBlockSizeException,
                BadPaddingException {
            String soureTxt = "这里是要加密的文本内容";
            String key = "这里是自定义的密钥";
            String str = null;
            System.out.println("明文:" + soureTxt);
            str = enCrypto(soureTxt, key);
            System.out.println("加密:" + str);
            System.out.println("解密:" + deCrypto(str, key));
            System.out.println(str + "====" + key);
    
        }
    }
    

     

    国密算法,明文、密文、密码、密钥、对称加密、非对称加密简单理解

    国密算法是什么?
    国密算法是由国家密码局发布,包含SM1、SM2、 SM3、 SM4、 SSF33算法。
    国际算法是什么?
    国际算法由美国的安全局发布,是现今最通用的商用算法。
    密码学中应用最为广泛算法都有哪些?
    密码学中应用最为广泛的的三类算法:
    1、对称算法(分组密码算法)代表分组密码算法(DES和SM4);
    2、非对称算法(公钥密码算法)代表公钥密码算法(RSA和SM2);
    3、杂凑算法(摘要算法)代表摘要算法(HAS-256系列和SM3);
     

    pin密文是1.1+1.2

     

    1+2=3,最后1和2进行二进制异或,3出表示07 和密码是什么后面异或

     

    主密加密工密,工密加密密码

     

     

     

     

    密码加密就好比,方程式,也可以说实一种投影,就是密码通过工作密码进行加密进行传输,好比密码是x,密钥是参数y通过方程式运算得出z:就是密文。反向地逻辑就是解密。

    还有主密钥,就是加密工作密钥,这时候,工作密钥是x,通过方程式输出y:是工作密钥的密文,这样的话密码的安全程度就会更高。

    我的 理解就是将其理解成为方程式,

    des,3des,sm2,sm4,rsa都是加密形式,好比不同函数,不同维度的方程式。

    期间的运算是通过,二进制数据,进行移位,补位,进行异或,与,非运算进行加密,生成密文。

    明文就是你的密码了。

     

     

    密码(cipher)

    密码学中的密码(cipher)和我们日常生活中所说的密码不太一样,计算机术语『密码 cipher』是一种用于加密或者解密的算法,而我们日常所使用的『密码 password』是一种口令,它是用于认证用途的一组文本字符串,这里我们要讨论的是前者:cipher。
    

     密钥(key)

    密钥是一种参数,它是在使用密码(cipher)算法过程中输入的参数。同一个明文在相同的密码算法和不同的密钥计算下会产生不同的密文。很多知名的密码算法都是公开的,密钥才是决定密文是否安全的重要参数,通常密钥越长,破解的难度越大,比如一个8位的密钥最多有256种情况,使用穷举法,能非常轻易的破解,知名的DES算法使用56位的密钥,目前已经不是一种安全的加密算法了,主要还是因为56位的密钥太短,在数小时内就可以被破解。密钥分为对称密钥与非对称密钥。

     

    明文/密文

    明文(plaintext)是加密之前的原始数据,密文是通过密码(cipher)运算后得到的结果成为密文(ciphertext)

     

    对称密钥

    对称密钥(Symmetric-key algorithm)又称为共享密钥加密,对称密钥在加密和解密的过程中使用的密钥是相同的,常见的对称加密算法有DES、3DES、AES、RC5、RC6。对称密钥的优点是计算速度快,但是他也有缺点,密钥需要在通讯的两端共享,让彼此知道密钥是什么对方才能正确解密,如果所有客户端都共享同一个密钥,那么这个密钥就像万能钥匙一样,可以凭借一个密钥破解所有人的密文了,如果每个客户端与服务端单独维护一个密钥,那么服务端需要管理的密钥将是成千上万,这会给服务端带来噩梦

     

    非对称密钥

    非对称密钥(public-key cryptography),又称为公开密钥加密,服务端会生成一对密钥,一个私钥保存在服务端,仅自己知道,另一个是公钥,公钥可以自由发布供任何人使用。客户端的明文通过公钥加密后的密文需要用私钥解密。非对称密钥在加密和解密的过程的使用的密钥是不同的密钥,加密和解密是不对称的,所以称之为非对称加密。与对称密钥加密相比,非对称加密无需在客户端和服务端之间共享密钥,只要私钥不发给任何用户,即使公钥在网上被截获,也无法被解密,仅有被窃取的公钥是没有任何用处的。常见的非对称加密有RSA,非对称加解密的过程:
    
    1.服务端生成配对的公钥和私钥
    2.私钥保存在服务端,公钥发送给客户端
    3.客户端使用公钥加密明文传输给服务端
    4.服务端使用私钥解密密文得到明文
    

    数字签名

    数据在浏览器和服务器之间传输时,有可能在传输过程中被冒充的盗贼把内容替换了,那么如何保证数据是真实服务器发送的而不被调包呢,同时如何保证传输的数据没有被人篡改呢,要解决这两个问题就必须用到数字签名,数字签名就如同日常生活的中的签名一样,一旦在合同书上落下了你的大名,从法律意义上就确定是你本人签的字儿,这是任何人都没法仿造的,因为这是你专有的手迹,任何人是造不出来的。那么在计算机中的数字签名怎么回事呢?数字签名就是用于验证传输的内容是不是真实服务器发送的数据,发送的数据有没有被篡改过,它就干这两件事,是非对称加密的一种应用场景。不过他是反过来用私钥来加密,通过与之配对的公钥来解密。
    
    第一步:服务端把报文经过Hash处理后生成摘要信息Digest,摘要信息使用私钥private-key加密之后就生成签名,服务器把签名连同报文一起发送给客户端。 
    
    第二步:客户端接收到数据后,把签名提取出来用public-key解密,如果能正常的解密出来Digest2,那么就能确认是对方发的。 
    第三步:客户端把报文Text提取出来做同样的Hash处理,得到的摘要信息Digest1,再与之前解密出来的Digist2对比,如果两者相等,就表示内容没有被篡改,否则内容就是被人改过了。因为只要文本内容哪怕有任何一点点改动都会Hash出一个完全不一样的摘要信息出来。

    数字证书(Certificate Authority):证明数字签名

    数字证书简称CA,它由权威机构给某网站颁发的一种认可凭证,这个凭证是被大家(浏览器)所认可的,为什么需要用数字证书呢,难道有了数字签名还不够安全吗?有这样一种情况,就是浏览器无法确定所有的真实服务器是不是真的是真实的,举一个简单的例子:A厂家给你们家安装锁,同时把钥匙也交给你,只要钥匙能打开锁,你就可以确定钥匙和锁是配对的,如果有人把钥匙换了或者把锁换了,你是打不开门的,你就知道肯定被窃取了,但是如果有人把锁和钥匙替换成另一套表面看起来差不多的,但质量差很多的,虽然钥匙和锁配套,但是你却不能确定这是否真的是A厂家给你的,那么这时候,你可以找质检部门来检验一下,这套锁是不是真的来自于A厂家,质检部门是权威机构,他说的话是可以被公众认可的(呵呵)。
    
    同样的, 因为如果有人(张三)用自己的公钥把真实服务器发送给浏览器的公钥替换了,于是张三用自己的私钥执行相同的步骤对文本Hash、数字签名,最后得到的结果都没什么问题,但事实上浏览器看到的东西却不是真实服务器给的,而是被张三从里到外(公钥到私钥)换了一通。那么如何保证你现在使用的公钥就是真实服务器发给你的呢?我们就用数字证书来解决这个问题。数字证书一般由数字证书认证机构(Certificate Authority)颁发,证书里面包含了真实服务器的公钥和网站的一些其他信息,数字证书机构用自己的私钥加密后发给浏览器,浏览器使用数字证书机构的公钥解密后得到真实服务器的公钥。这个过程是建立在被大家所认可的证书机构之上得到的公钥,所以这是一种安全的方式。
    展开全文
  • 介绍C++Java之间兼容DES算法加密/解密数据的注意事项。
  • 最近,我用openssl库里面的des_ncbc_encrypt()函数加密一个 90个字符的字符串时,发现 当我输入不同的密码时,有的时候密文返回结果还比较正常,长度是96 ,但是输入其他密码时,有的返回密文长度是14,有的是64等等, 不...
  • 【什么叫明文,什么叫密文,为什么不允许在数据库里明文保存密码?】 每篇分享文从 【背景介绍】【知识剖析】【常见问题】【解决方案】【编码实战】【扩展思考】【更多讨论】【参考文献】 八个方面深度解析后端...
  • 关于3des加密算法密钥长度的解释

    千次阅读 热门讨论 2020-05-26 11:30:51
    3DES和DES算法均属于分组加密算法,即加密前将明文按照8字节长度进行顺序分组(若最后一组数据长度不足8字节,就进行填充处理)。例如:若明文为16字节,则将其前8字节作为明文数据块1,后8字节作为明文数据块2。...
  • 1、使用DESCryptoServiceProvider...不过要注意的是需要把随机数添加到明文的靠前面, 好像有一定的长度限制,所以可以DES(随机数+明文) 2、配置IIS7执行全局的URL重写。 设置Handler Mappings --> *...
  • 3DES加密,秘钥长度为32

    千次阅读 2017-07-12 13:14:13
    kCCBlockSize3DES - 1 );    bufferPtr = malloc (bufferPtrSize * sizeof ( uint8_t ));     memset (( void *)bufferPtr, 0x0 , bufferPtrSize);     const ...
  • 这里是修真院后端小课堂,每篇分享文从 【背景介绍】【知识剖析...【什么叫明文,什么叫密文,为什么不允许在数据库里明文保存密码?】 大家好,我是IT修真院深圳分院第10期的JAVA学员,一枚正直纯洁善良的java程...
  • 对称加密算法中,des算法的密钥长度是多少,采用什么进行加密
  • 首先:Windows文件名长度: 最长255字节. ...winNT是使用宽字符(unicode)的,一个英文字母一个汉字一样都是占用2字节. windows为什么会限制文件名长度 文件系统中,文件名至少在两个地方存在,...
  • DES分组密码算法调用DES分组密码源程序中的相关函数,设计一个文件加密器,可以加密任意长度的文件,并且密文文件可解密还原回原明文文件。DES分组密码算法流程(1)以下程序加密从桌面上的读入8个字符长度明文,...
  • 基于DES任意长度字符串的加密解密,MFC界面
  • DES

    千次阅读 2019-08-25 16:18:46
    DES 一、简介 **DES(Data Encryption Standard)**是1977年美国联邦信息处理标准(FIPS)中所采用的一种对称密码(FIPS46.3)。...明文/密文 算法: 加密:DES 解密:DES 密钥:56bit 三、加密...
  • 安全算法:3DES密钥长度

    万次阅读 2012-10-18 13:57:08
    DES的密钥长度为8字节,3DES的密钥长度为3*8=24字节。 Cipher=Ek3(Dk2(Ek1(Plain)));--使用K1加密,再使用K2对K1加密的结果解密,最后使用K3对K2解密的结果再加密,第三次的结果作为最终的密文。 Plain=DK1(Ek2(Dk...
  • DES分组加密算法

    千次阅读 2019-03-17 13:10:10
    分组密码是将明文数字序列按照固定长度分组,并且用同一个密钥同一个加密算法逐组加密,从而将各个明文分组变换成为密文分组的密码。 1.2.安全原则 (1)混乱原则:使得密文和对应明文和密钥之间的关系足够复杂...
  • 对称加密算法DES、3DES和AES

    千次阅读 2016-11-01 16:33:49
    对称加密算法DES、3DES和AES
  • python实现DES加密解密

    千次阅读 2020-10-24 16:02:02
    DES是一种将64比特的明文加密成64比特的密文对称密码算法。DES是以64比特的明文为一个单位来进行加密的,这个64比特的单位成为分组,所以DES密码又称为分组密码 DES的基本结构是由Horst Feistel 设计的,因此也称为...
  • 对称加密算法之DES算法AES算法

    千次阅读 2019-01-22 13:44:36
    在对称加密算法中,数据发送方将明文和加密密钥一起经过特殊加密算法处理后,生成复杂的加密密钥进行发送,数据接收方收到密文后,若想读取原文,则需要使用加密使用的密钥及相同算法的逆算法对加密的密文进行解密,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,905
精华内容 3,962
关键字:

des明文和密文长度