精华内容
下载资源
问答
  • 安装ecb

    2019-07-25 09:33:57
    mac emacs上安装ecb,通过elpa折腾得要死,死活无法使用。 解决办法:下载https://github.com/alexott/ecb,添加路径,(require 'ecb),直接ok。 转载于:https://www.cnblogs.com/Open_Source/p/4829052.html...

    mac emacs上安装ecb,通过elpa折腾得要死,死活无法使用。

    解决办法:下载https://github.com/alexott/ecb,添加路径,(require 'ecb),直接ok。

    转载于:https://www.cnblogs.com/Open_Source/p/4829052.html

    展开全文
  • AES ECB加密

    2017-12-28 23:00:49
    AES ECB算法 加密正常 对比在线加密网站http://tool.chacuo.net/cryptaes
  • Remove ECB mode

    2020-12-07 02:23:04
    <div><p>It should not be easy to use ECB mode. ;)</p><p>该提问来源于开源项目:randombit/botan</p></div>
  • 银联Ecb加密算法

    2018-07-27 16:28:57
    java实现的银联Ecb加密算法,可运行,含算法步骤详述。
  • ECB or CBC

    2020-12-08 18:49:29
    <p>GCC size output when only ECB mode is ... <p>but the command is <code>arm-none-eabi-gcc -Os -c aes.c -DCBC=0</code></p> <p>Is that a typo?</p><p>该提问来源于开源项目:kokke/tiny-AES-c...
  • aes128 ecb pkcs

    2018-07-13 09:31:07
    aes128 ECB PKCS填充,加密解密同一个API,很简洁。已经在项目中使用。
  • ECB模式解读

    千次阅读 2018-08-31 21:46:23
    一 什么是ECB模式 ECB模式全称是Electronic CodeBook模式,在ECB模式中,将明文分组加密之后的结果将直接成为密文分组。 使用ECB模式加密时,相同的明文分组会被转换为相同的密文分组,我们可以将其理解为是一...

    一 什么是ECB模式

    ECB模式全称是Electronic CodeBook模式,在ECB模式中,将明文分组加密之后的结果将直接成为密文分组。

    使用ECB模式加密时,相同的明文分组会被转换为相同的密文分组,我们可以将其理解为是一个巨大的“明文分组->密文分组”的对应表,因此ECB模式也称为电子密码本模式。

    当最后一个明文分组的内容小于分组长度时,需要用一些特定的数据进行填充。

    二 ECB模式的特点

    ECB模式中,明文分组与密文分组是一一对应的关系,因此,如果明文中存在多个相同的明文分组,则这些明文分组最终都将被转换为相同的密文分组。这样一来,只要观察一下密文,就可以知道明文存在怎样的重复组合,并可以以此为线索来破译密码,因此ECB模式是存在一定风险的。

    三 对ECB模式的攻击

    攻击者无需破译密码就能操纵明文。

    下面举一个例子说明:

    假设分组长度为128bit(16个字节),某银行的转账请求数据由以下3个分组构成。

    分组1=付款人的银行账号

    分组2=收款人的银行账号

    分组3=转账金额。

    场景是:从A-5374账号向B-6671账号转账1亿元

    16进制数据表示如下:

    将上面数据用ECB加密,加密后,看不出明文分组内容。

    攻击者将密文分组1和2对调。

    攻击者没有试图破译密码,但场景却发生了变化:

    现在场景变成了:B-6671账号向A-5374账号转账1亿元。

    完全相反,这就是ECB的弱点,不破译密文的情况下操纵明文。

    展开全文
  • AES128 ECB mode.C

    2021-03-19 13:14:04
    ECB模式的AES128加解密的C语言完整代码,可以加解密任意长度的数据(数据长度非16字节整数倍),已经过实际嵌入式项目的应用验证。对于ECB模式AES算法的原理请查阅相关资料。对于明文不是16字节整数倍的处理原理,请...
  • des ecb cbc CFB OFB

    2017-03-29 15:20:52
    des ecb cbc CFB OFB
  • ECB mode broken?

    2021-01-09 17:28:07
    I know ECB is not secure but I wanted to try it out and it would seem that in modes.py, line 128 might be an issue? <h1>encrypts the paddedtext with AES-ECB-256 standard <pre><code>backend = ...
  • ECB oracle——attack

    2021-02-23 15:17:52
    基于ECB oracle的攻击方案前言什么是ECB方案步骤1.确定块大小和明文大小2.暴力破解求明文脚本代码 前言 参考文章:Breaking ECB by prepending your own message. 环境地址:ECB oracle 什么是ECB 分组密码中AES的...

    前言

    参考文章:Breaking ECB by prepending your own message.
    环境地址:ECB oracle
    在这里插入图片描述

    什么是ECB

    分组密码中AES的一种模式(其他还有:CBC、ECB、CTR、OCF、CFB)如图每一块加密是分开的。
    来自cryptohack.org

    方案步骤

    1.确定块大小和明文大小

    先用一个字符"a"去encrypt返回32个字节的数据(64位16进制)依次用"aa",“aaa”…去encrypt,会发现:
    (?是要求的明文,F是ECB模式填充的字节,p是已求出的明文)
    在这里插入图片描述

    6个"a"的时候返回32个字节的数据
    7个"a"的时候返回48个字节的数据
    22个"a"的时候返回64个字节的数据
    23个"a"的时候返回48个字节的数据
    所以块大小就是16字节(22-6),明文(flag)大小就是26个字节(32-6)

    2.暴力破解求明文

    在这里插入图片描述
    求第一位:
    15个"a"时返回的前16个字节只有一个字节未知,则可以暴力遍历出这一个字节,也就是用(15个"a"+“某个字节”)进行encrypt。如果其中有一个组合返回的前16字节与15个"a"返回的前16字节相同则这"某个字符"就是flag的第一个字节。
    求第二位:
    14个"a"时返回的前16个字节有两个字节未知,这两个字节已经知道一个则可以暴力遍历出另一个字节,也就是用(14个"a"+“第一位求得的字节”+“某个字节”)进行encrypt。如果其中有一个组合返回的前16字节与14个"a"返回的前16字节相同则这"某个字符"就是flag的第二个字节。
    求第三位:
    13个"a"时返回的前16个字节有两个字节未知,这两个字节已经知道一个则可以暴力遍历出另一个字节,也就是用(13个"a"+“第一位求得的字节和第二位求得的字节”+“某个字节”)进行encrypt。如果其中有一个组合返回的前16字节与13个"a"返回的前16字节相同则这"某个字符"就是flag的第三个字节。

    依次下去可以求得前15个字节。

    剩下的字节用同样的方法求出,只不过比较的是第二块16个字节,而不是前16字节了。
    在这里插入图片描述

    脚本代码

    import requests
    # 字符串转16进制
    def t_to_hex(t):
        h = ''
        for i in t:
            h += str(hex(ord(i))[2:])
        return h
    # 获取返回的16进制数据
    def getCipher(s):
    
        url1 = "http://aes.cryptohack.org/ecb_oracle/encrypt/"
        url = url1 + t_to_hex(s)+"/"
        re = requests.get(url)
        return re.text[15:-3]
    # 求第一部分前15字节
    c1 = ''
    for i in range(0,15):
        p = 'a'*(15-i)
        text0 = getCipher(p)[:32]
        for j in range(32,127):
            p_j = p+c1+chr(j)
            if text0 == getCipher(p_j)[:32]:
                c1 += chr(j)
                print(c1)
                break
    
    # c1 = 'crypto{p3n6u1n5'
    # 求第二部分剩余的字节
    c2 = c1
    for i in range(9,15):
        p = 'a'*(16-i)
        text0 = getCipher(p)[32:64]
        for j in range(32,127):
            p_j = p+c2+chr(j)
            if text0 == getCipher(p_j)[32:64]:
                c2 += chr(j)
                print(c2)
                if chr(j)=="}":
                    exit()
                break
    
    # Y3J5cHRve3AzbjZ1MW41X2g0NzNfM2NifQ==
    
    展开全文
  • AES-128-ECB加密模式

    2021-03-22 11:11:42
    AES-128-ECB加密,包含main 方法测试
  • matlab开发-ECB统计数据仓库。从ECB统计数据仓库下载计量经济学时间序列。
  • <div><p>Commit adds hardware access layer in nrf_ecb.h. Layer is similar to other implementations to keep sources consistent. Documentation is aligned to meet current implementation. Previous ...
  • 128-AES/ECB加解密

    2020-03-25 13:21:03
    128-AES/ECB加解密。因为传输的数据并不重要,考虑到并发性和安全性的原因,采用了AES128-ecb的加密模式
  • AESECB

    2013-12-06 08:57:28
    package com.vzo.eightpartycall.util; import javax.crypto.Cipher; import javax.crypto.spec.SecretKeySpec; //import android.util.Log;... public class AESECB {  /*ECB模式不要IV*/  privat
    package com.vzo.eightpartycall.util;

    import javax.crypto.Cipher;
    import javax.crypto.spec.SecretKeySpec;

    //import android.util.Log;


     public class AESECB
    {
         /*ECB模式不要IV*/
         private String key;
        
        public  AESECB(String key)
        {
            
            this.key=key;
        }    
     
        public  String encrypt(String data) throws Exception {
           try {
               /*
               String data = "Test String";
              String key = "1234567812345678";
              String iv = "1234567812345678";
    */
                Cipher cipher = Cipher.getInstance("AES/ECB/NoPadding");
    //           Log.i("tag",(16-(data.length()%16))+"");
                int datesize=(16-(data.length()%16));
                for(int i=0;i<datesize;i++)
                {
    //                Log.i("tag","oncex:"+i);
                    
                    data=data+" ";
                }
                
    //            Log.i("tag","填补后"+data);
                /*
                int blockSize = cipher.getBlockSize();

                byte[] dataBytes = data.getBytes();
                int plaintextLength = dataBytes.length;
                if (plaintextLength % blockSize != 0) {
                    plaintextLength = plaintextLength + (blockSize - (plaintextLength % blockSize));
                }

                byte[] plaintext = new byte[plaintextLength];
                System.arraycopy(dataBytes, 0, plaintext, 0, dataBytes.length);
                 */
                SecretKeySpec keyspec = new SecretKeySpec(this.key.getBytes(), "AES");


                cipher.init(Cipher.ENCRYPT_MODE, keyspec);
                byte[] encrypted = cipher.doFinal(data.getBytes());
                return byte2hex(encrypted);
                //return encrypted.toString();
               // return new sun.misc.BASE64Encoder().encode(encrypted);
            } catch (Exception e) {  
                System.out.println(e.toString());  
                return null;  
              //  return new sun.misc.BASE64Encoder().encode(encrypted);

            }
        }

        public  String desEncrypt(String data) throws Exception {
            try
            {
               // String data = "2fbwW9+8vPId2/foafZq6Q==";
                /*
                String key = "1234567812345678";
                String iv = "1234567812345678";
                 */
             //   byte[] encrypted1 = new BASE64Decoder().decodeBuffer(data);
                byte[] encrypted1=hex2byte(data);
               // byte[] encrypted1=data.getBytes();
               Cipher cipher = Cipher.getInstance("AES/ECB/NoPadding");
                SecretKeySpec keyspec = new SecretKeySpec(this.key.getBytes(), "AES");

                 
                cipher.init(Cipher.DECRYPT_MODE, keyspec);

                byte[] original = cipher.doFinal(encrypted1);
                String originalString = new String(original);
                return originalString;
            }
            catch (Exception e) {
                e.printStackTrace();
                return null;       }
       }
        
        
        
        public static byte[] hex2byte(String strhex) {  
            if (strhex == null) {  
                return null;  
            }  
            int l = strhex.length();  
            if (l % 2 == 1) {  
                return null;  
            }  
            byte[] b = new byte[l / 2];  
            for (int i = 0; i != l / 2; i++) {  
                b[i] = (byte) Integer.parseInt(strhex.substring(i * 2, i * 2 + 2),  
                        16);  
            }  
            return b;  
        }  

        public static String byte2hex(byte[] b) {  
            String hs = "";  
            String stmp = "";  
            for (int n = 0; n < b.length; n++) {  
                stmp = (java.lang.Integer.toHexString(b[n] & 0XFF));  
                if (stmp.length() == 1) {  
                    hs = hs + "0" + stmp;  
                } else {  
                    hs = hs + stmp;  
                }  
            }  
            return hs.toLowerCase();
           // return hs.toUpperCase();  
        }  

    }

    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++

    辅助类

    package com.vzo.eightpartycall.util;

    import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.ByteArrayOutputStream;
    import java.io.CharArrayWriter;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.io.Reader;
    import java.io.Writer;

    public class Base64V2 {


        public static char[] encode(byte[] data) {
            char[] out = new char[((data.length + 2) / 3) * 4];

         
            for (int i = 0, index = 0; i < data.length; i += 3, index += 4) {
                boolean quad = false;
                boolean trip = false;

                int val = (0xFF & data[i]);
                val <<= 8;
                if ((i + 1) < data.length) {
                    val |= (0xFF & data[i + 1]);
                    trip = true;
                }
                val <<= 8;
                if ((i + 2) < data.length) {
                    val |= (0xFF & data[i + 2]);
                    quad = true;
                }
                out[index + 3] = alphabet[(quad ? (val & 0x3F) : 64)];
                val >>= 6;
                out[index + 2] = alphabet[(trip ? (val & 0x3F) : 64)];
                val >>= 6;
                out[index + 1] = alphabet[val & 0x3F];
                val >>= 6;
                out[index + 0] = alphabet[val & 0x3F];
            }
            return out;
        }

        /**
         * Decodes a BASE-64 encoded stream to recover the original
         * data. White space before and after will be trimmed away,
         * but no other manipulation of the input will be performed.
         *
         * As of version 1.2 this method will properly handle input
         * containing junk characters (newlines and the like) rather
         * than throwing an error. It does this by pre-parsing the
         * input and generating from that a count of VALID input
         * characters.
         **/
        public static byte[] decode(char[] data) {
            // as our input could contain non-BASE64 data (newlines,
            // whitespace of any sort, whatever) we must first adjust
            // our count of USABLE data so that...
            // (a) we don't misallocate the output array, and
            // (b) think that we miscalculated our data length
            //     just because of extraneous throw-away junk

            int tempLen = data.length;
            for (int ix = 0; ix < data.length; ix++) {
                if ((data[ix] > 255) || codes[data[ix]] < 0)
                    --tempLen; // ignore non-valid chars and padding
            }
            // calculate required length:
            //  -- 3 bytes for every 4 valid base64 chars
            //  -- plus 2 bytes if there are 3 extra base64 chars,
            //     or plus 1 byte if there are 2 extra.

            int len = (tempLen / 4) * 3;
            if ((tempLen % 4) == 3)
                len += 2;
            if ((tempLen % 4) == 2)
                len += 1;

            byte[] out = new byte[len];


            int shift = 0; // # of excess bits stored in accum
            int accum = 0; // excess bits
            int index = 0;

            // we now go through the entire array (NOT using the 'tempLen' value)
            for (int ix = 0; ix < data.length; ix++) {
                int value = (data[ix] > 255) ? -1 : codes[data[ix]];

                if (value >= 0)// skip over non-code
                {
                    accum <<= 6; // bits shift up by 6 each time thru
                    shift += 6; // loop, with new bits being put in
                    accum |= value; // at the bottom.
                    if (shift >= 8)// whenever there are 8 or more shifted in,
                    {
                        shift -= 8; // write them out (from the top, leaving any
                        out[index++] = // excess at the bottom for next iteration.
                            (byte) ((accum >> shift) & 0xff);
                    }
                }
                // we will also have skipped processing a padding null byte ('=') here;
                // these are used ONLY for padding to an even length and do not legally
                // occur as encoded data. for this reason we can ignore the fact that
                // no index++ operation occurs in that special case: the out[] array is
                // initialized to all-zero bytes to start with and that works to our
                // advantage in this combination.
            }

            // if there is STILL something wrong we just have to throw up now!
            if (index != out.length) {
                throw new Error("Miscalculated data length (wrote " +
                    index + " instead of " + out.length + ")");
            }

            return out;
        }


        //
        // code characters for values 0..63
        //
        private static char[] alphabet =
            "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".toCharArray();

        //
        // lookup table for converting base64 characters to value in range 0..63
        //
        private static byte[] codes = new byte[256];

        static {
            for (int i = 0; i < 256; i++)
                codes[i] = -1;
            for (int i = 'A'; i <= 'Z'; i++)
                codes[i] = (byte) (i - 'A');
            for (int i = 'a'; i <= 'z'; i++)
                codes[i] = (byte) (26 + i - 'a');
            for (int i = '0'; i <= '9'; i++)
                codes[i] = (byte) (52 + i - '0');
            codes['+'] = 62;
            codes['/'] = 63;
        }




        ///
        // remainder (main method and helper functions) is
        // for testing purposes only, feel free to clip it.
        ///

        public static void main(String[] args) {
            boolean decode = false;

            if (args.length == 0) {
                System.out.println("usage:  java Base64 [-d[ecode]] filename");
                System.exit(0);
            }
            for (int i = 0; i < args.length; i++) {
                if ("-decode".equalsIgnoreCase(args[i]))
                    decode = true;
                else if ("-d".equalsIgnoreCase(args[i]))
                    decode = true;
            }

            String filename = args[args.length - 1];
            File file = new File(filename);
            if (!file.exists()) {
                System.out.println("Error:  file '" + filename + "' doesn't exist!");
                System.exit(0);
            }

            if (decode) {
                char[] encoded = readChars(file);
                byte[] decoded = decode(encoded);
                writeBytes(file, decoded);
            }
            else {
                byte[] decoded = readBytes(file);
                char[] encoded = encode(decoded);
                writeChars(file, encoded);
            }
        }

        private static byte[] readBytes(File file) {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            try {
                InputStream fis = new FileInputStream(file);
                InputStream is = new BufferedInputStream(fis);
                int count = 0;
                byte[] buf = new byte[16384];
                while ((count = is.read(buf)) != -1) {
                    if (count > 0)
                        baos.write(buf, 0, count);
                }
                is.close();
            }
            catch (Exception e) {
                e.printStackTrace();
            }

            return baos.toByteArray();
        }

        private static char[] readChars(File file) {
            CharArrayWriter caw = new CharArrayWriter();
            try {
                Reader fr = new FileReader(file);
                Reader in = new BufferedReader(fr);
                int count = 0;
                char[] buf = new char[16384];
                while ((count = in.read(buf)) != -1) {
                    if (count > 0)
                        caw.write(buf, 0, count);
                }
                in.close();
            }
            catch (Exception e) {
                e.printStackTrace();
            }

            return caw.toCharArray();
        }

        private static void writeBytes(File file, byte[] data) {
            try {
                OutputStream fos = new FileOutputStream(file);
                OutputStream os = new BufferedOutputStream(fos);
                os.write(data);
                os.close();
            }
            catch (Exception e) {
                e.printStackTrace();
            }
        }

        private static void writeChars(File file, char[] data) {
            try {
                Writer fos = new FileWriter(file);
                Writer os = new BufferedWriter(fos);
                os.write(data);
                os.close();
            }
            catch (Exception e) {
                e.printStackTrace();
            }
        }
        ///
        // end of test code.
        ///
        
        /* base64���� */
        protected static String base64_encode(String input) {
            try {
                String str = new String(encode(input
                        .getBytes("iso-8859-1")));
                return str.replaceAll("=", ""); // �滻�����

            } catch (Exception e) {
                return e.getMessage();
            }
        }
        
        protected static String base64_encode(byte[] strbyte) {
            try {
                String str = new String(encode(strbyte));
                return str.replaceAll("=", ""); // �滻�����

            } catch (Exception e) {
                return e.getMessage();
            }
        }
        
        
        /* base64���� */
        public static String base64_decode(String input) {
            try {
                String xxx = new String(Base64V2.decode(input.toCharArray()),
                        "iso-8859-1");
                return xxx;
            } catch (Exception e) {
                return e.getMessage();
            }
        }
        
        

    }

    展开全文
  • AES加密解密,ECB,128

    2020-02-19 11:04:57
    如题,AES加密解密,ECB,128
  • emacs添加ecb

    2016-07-30 21:45:52
    git clone https://github.com/alexott/ecb.git ...(add-to-list 'load-path (expand-file-name "~/.emacs.d/plugins/ecb/")) (require 'ecb) 这样就在emacs中添加了ecb插件了。 F10调出菜单->Tools->Sta
  • 最近需要又要使用DES加密数据,要求DES加密出来的数据为对称加密,经过研究,发现了一些问题:1.DES对称ECB模式加密的数据,长度必须为8的倍数2.加密的数据,加密后先转码(因为加密后的数据我是转码了),否则解密是...
  • 传输数据想加密一下,想要双向可逆加密AES是个好选择,AES加密模式有好几种 ECB CBC...ECB相对其他模式没有偏移量的设置,简单点,安全性差点,不过也够用了需要模块crypto的支持,由于crypto已经停止更新,现在改用...
  • php AES/ECB加密解密

    2021-01-14 21:32:01
    $key = "WANGBAOCHEN9@wHhs...$data=mcrypt_encrypt(MCRYPT_RIJNDAEL_128,$key, $data, 'ecb'); //转HEX $data = strtoupper(bin2hex($data)); //解密 //转string $data = hex2bin(strtolower($data))
  • HIN202ECB的技术参数

    2020-12-12 21:04:58
    产品型号:HIN202ECB驱动器:2接受器:2High ESD:YES手动关断功能:NO自动关断功能:NORxDisable:NO速率(Kbps):230Cap. Value (μF):0.100ICCEnabled(mA):8ICCDisabled(μA):NA工作电压(V):4.5 ~ 5.5封装/温度(℃):16...
  • ICL3243ECB的技术参数

    2020-12-12 20:52:58
    产品型号:ICL3243ECB驱动器:3接受器:5High ESD:YES手动关断功能:YES自动关断功能:BASICRxDisable:NO速率(Kbps):500Cap. Value (μF):0.100ICCEnabled(mA):0.300ICCDisabled(μA):1工作电压(V):3~5.5封装/温度(℃):28...
  • class AesEbc16: # 按块的大小, 一块一块的加密, 明文和密文长度一样def __init__(self):self.key = b"123qweqqqwerqwer" # 加密和解密用同一个秘钥, 长度为 每块的长度self.mode = AES.MODE_ECB # ECB加密模式, 也...
  • PHP 和 Java �g用 Des 加密(ECB mode) ��鬏��Y料,要�_保�蛇�用同�拥�key加解密的�Y果一�印�PHP code:/*** DES .../*** DES 加解密(ECB mode)* @param string $key 加密的key*/public function __con...
  • AES128(CBC或者ECB)源码,在C语言环境下运行。
  • ECB 电子密码本模式:Electronic codebook 每块堵路加密优点:分块处理 并行处理缺点:同样的原文得到相同的密文 容易被攻击java代码:import javax.crypto.Cipher;import javax.crypto.spec.SecretKeySpec;import ...
  • 对于较长的明文进行加密需要进行分块加密,但是直接加密(ecb)不容易隐藏模式,用OpenCV写了个程序论证了一下ECB优点就是简单,可以并行计算,不会迭代误差缺点就是隐藏不了模式CBC 需要初始化向量IV,来加密第一块C0...
  • crypto库开发AES+ECB加密

    2020-08-06 14:51:11
    使用用crypto库开发AES+ECB加密,C++代码测试验证通过....(仅供参考)。。。。。。。
  • 3.2 DES-ECB

    2021-01-26 18:01:11
    ECB模式是所有模式中最简单的一种,明文分组和密文分组是一一对应的关系,明文分组中存在多个相同的明文分组,则这些明文分组最终被转换为相同的密文分组,只要观察一下密文,就可以知道明文中存在怎样的一个组合,...

空空如也

空空如也

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

ecb