精华内容
下载资源
问答
  • base64 三个jar包

    2017-09-09 21:53:59
    使用base64加解密的jar包,提供三种,对应就有三种方法。详细操作博客里有,不会的小伙伴可以自己去查看!啊啊啊啊,还不够100字。
  • base64encoder jar包

    2018-02-12 10:36:08
    java base64encoder jar包 可用MD5加密。亲测可用。。
  • Java 从网络中读取图片 转换成Base64字符串
  • 最新的PCIE4.0文档,正式版1.0文档,PCI Express® Base Specification Revision 4.0 Version 1.0 September 27, 2017
  • android.util.Base64类

    热门讨论 2015-07-26 13:25:47
    android.util.Base64类
  • jquery.base64.js

    千次下载 热门讨论 2014-05-22 14:06:04
    jquery.base64.js
  • Base64编码jar包

    千次下载 热门讨论 2014-04-06 16:47:14
    Base64编码jar包,下载之后导入工程项目中即可使用。具体使用方法在:http://blog.csdn.net/junhuahouse
  • BASE64源码及JAR包

    千次下载 热门讨论 2015-02-11 10:49:39
    sun.misc.BASE64Encoder 的源码及JAR包
  • 开源-base64、base32、base16 的编码与解码 纯C源码可以再任何环境下编译
  • 本篇《Base64系列第四篇 C/C++中使用Base64编码解码(从chromium库中抽取)》将从大名鼎鼎的chromium库抽取代码,保证健壮高效的完成Base64编码解码。
  • JS实现密码加密(base64, md5, sha1)

    热门讨论 2015-06-18 14:27:16
    JS实现密码加密(base64, md5, sha1)
  • 网上经常看到类似于10BASE-T、100BASE-T4、100BASE-FX、1000BASE-X等等定义,很多人对这些规格名称都是一脸懵圈,一知半解。它们各自到底表示什么意思,彼此之间又有什么区别呢?别急,首先我们拆解一下这些个标准...

    以太网(Ethernet)是现实世界中最普遍的一种计算机网络,最早是由美国的Xerox公司和Stanford大学合作研制出来的。1980年,DEX、Intel和Xerox 3个公司合作制定了有关以太网的工业标准,提出了Ethernet规范V1.0,即蓝皮书《以太网:数据链路层和物理层规范1.0版》。1982年修改为第二版规范,即DIX Ethernet V2,成为世界上第一个局域网产品的规范。1983年,IEEE802委员会以DIX Ethernet V2为基础,推出了IEEE802.3。IEEE802.3标准是以太网核心的内容,也是一个不断发展的协议体系。截止到现在IEEE802.3工作组总共定义了标准以太网、快速以太网、千兆以太网、万兆以太网、新型以太网五大以太网标准体系。这些标准最明显的区别就是速率不同。

    • IEEE802.3标准为采用不同传输介质的标准以太网制定对应标准,主要包括采用细同轴电缆的10BASE-2、采用粗同轴电缆的10BASE-5和采用双绞线的10BASE-T;
    • IEEE802.3u标准为采用不同传输介质的快速以太网制定相应规范,包括采用双绞线介质的100BASE-Tx和100BASE-T4,采用多模光纤介质的100BASE-Fx以及10/100M速率自协商功能;
    • IEEE802.3z和IEEE802.3ab标准定义了采用光纤为传输介质的1000BASE-SX/LX以及采用双绞线介质的1000BASE-T规范;
    • IEEE802.3ae标准定义了万兆以太网的特点:光纤传输、全双工模式,不再使用半双工和CSMA/CD介质访问控制技术,采用局域网和广域网两种物理模型,将以太网技术引入到广域网中;
    • IEEE802.3ba标准同时包含40Gbps与100Gbps两种速率接口。该标准解决了数据中心、运营商网络和其他流量密集的高性能计算环境,以及日益增长的应用对带宽的需求。

    以太网实现了网络上无线电系统多个节点发送信息的想法,每个节点必须获取电缆或者信道的才能传送信息,有时也叫作以太(Ether)(这个名字来源于19世纪的物理学家假设的电磁辐射媒体-光以太。后来的研究证明光以太不存在)。 每一个节点有全球唯一的48位地址也就是制造商分配给网卡的MAC地址,以保证以太网上所有节点能互相鉴别。由于以太网十分普遍,许多制造商把以太网卡直接集成进计算机主板。

    以太网上的计算机任何时候都可以发送信息,但发送之前都需先检测网络是否空闲,即“侦听”,如果某时刻有两个或者更多的分组发生冲突,则检测到冲突,欲发送数据的计算机就都需等待一段时间,即“回退”,各个计算机的回退时间随机产生,一般情况下都不相同。回退时间过后各计算机再次试图发送。这就是以太网技术必须提到的 CSMA/CD(载波侦听多路访问/冲突检测)机制。

    网上经常看到类似于10BASE-T、100BASE-T4、100BASE-FX、1000BASE-X等等定义,很多人对这些规格名称都是一脸懵圈,一知半解。它们各自到底表示什么意思,彼此之间又有什么区别呢?别急,首先我们拆解一下这些个标准的名字构成:

    • 10/100/1000:表示网线设计的频率,单位MHz。值越大,网线所支持的速度就越快。100 MHz表示以每秒100Mbit的速度传输,这在理论上指的就是12.5 MB/s。当然,实际应用中考虑到冗余设计和干扰等因素,真实值可能会小很多。
    • BASE:BASE是英文BASEband的缩写,指的就是基带。表示没有使用频分复用或者其它频率转换技术,每一个信号在一个单一频率上完全控制线缆。
    • 数字/T/F/C等:最后一个如果是数字,则表示单段网线的最大长度(基准单位是100m);如果是字母,则依次解释如下:T代表承载信号的物理介质是双绞线缆(Twisted Pair Cable,又分为UTP(Unshielded Twisted Pair,非屏蔽双绞线)和STP(Shielded Twicted Pair,屏蔽双绞线)两种),在这里每一对传送信号的双绞线互相缠绕以减少电磁干扰和串扰;F表示光纤;
    • 最后的字母或数字(4/X等): 在同一种传送速率下有多种不同的标准,它们之间以一个字母或数字跟随T/F/C之后的方式来区隔(例如TX)。它显示了网线的结构并指出包含的绞线对的数量。某些高速标准使用同轴电缆,则分配代号为CX。

    然后我们就按照以太网的速度和发展历史,对上述以太网中各种常见的标准和规范逐一进行解读和对比:

    原始以太网:1Mbps以太网

    • 施乐以太网(Xerox Ethernet,又称“施乐以太网”):是以太网的雏型。最初的2.94Mbit/s以太网仅在施乐公司里内部使用。而在1982年,Xerox与DEC及Intel组成DIX联盟,并共同发表了Ethernet Version 2(EV2)的规格,并将它投入商场市场,且被普遍使用。而EV2的网络就是目前受IEEE承认的10BASE5;
    • 10BROAD36:已经过时。一个早期的支持长距离以太网的标准。它在同轴电缆上使用,以一种类似线缆调制解调器系统的宽带调制技术;
    • 1BASE5:也称为星型局域网,速率是1Mbit/s。在商业上很失败,但同时也是双绞线的第一次使用;

    标准以太网:10Mbps以太网

    最开始以太网只有10Mbps的吞吐量,它所使用的是CSMA/CD(带有冲突检测的载波侦听多路访问)的访问控制方法,通常把这种最早期的10Mbps以太网称之为标准以太网。以太网主要有两种传输介质,那就是双绞线和同轴电缆。所有的以太网都遵循IEEE 802.3标准。

    10BASE-5

    • 10BASE-5解释:10指的是其10Mbit/s的传输速度,BASE是基带信号的缩写(与宽带相反),5代表最大段长度为500米(1600英尺);
    • 10BASE-5也被称为Thick Ethernet or Thicknet,是以太网的第一个商用变体;
    • 使用直径10mm的50欧姆粗同轴电缆(Coaxial Cable),总线拓扑结构,站点网卡的接口为DB-15连接器,每个网段允许有100个站点,每个网段最大允许距离为500m,网络直径为2500m,可由5个500m长的网段和4个中继器组成;
    • 利用基带的10M传输速率,采用曼彻斯特编码传输数据;
    • 现在这一标准实际上被10BASE2取代;

    10BASE-2

    • 10BASE-2解释:10表示10 Mbit/s的传输速度,BASE代表基带信令,2代表最大段长度接近200米(实际最大长度为185米);
    • 10BASE-2也被称为Cheapernet,Thin Ethernet,Thinnet或者Thinwire,是为了降低10BASE-5的安装成本和复杂性而设计的,使用以BNC连接器端接的同轴电缆;
    • 其使用廉价的R9-58型50欧姆细同轴电缆,总线拓扑结构;每个网段允许30个站点,每个网段最大允许距离为185m,仍保持10BASE-5的4中继器/5网段设计能力,允许的最大网络直径为5x185=925m。
    • 利用基带的10M传输速率,采用曼彻斯特编码传输数据;
    • 10BASE-2虽然在能力、规格上不及10BASE5,但是因为其线材较细、布线方便、成本也便宜,所以得到更广泛的使用,淘汰了10BASE5。由于双绞线的普及,它也被各式的双绞线网络取代;

    10BASE-T

    • 10BASE- T解释:10表示10Mbit/s的传输速度,BASE表示使用基带传输,T表示双绞线(Twisted pair cables),每个信号的一对导线绞合在一起以减少对之间的电磁干扰和串扰;
    • 对于相同传输速度有几种标准的情况下,它们通过T之后的字母或数字来区分,例如TX,指的是编码方法和通道数量。
    • 使用两对非屏蔽双绞线,一对线发送数据,另一对线接收数据,用RJ-45模块作为端接器,星形拓扑结构,信号频率为20MHz,最大距离为100m;
    • 双绞线以太网是以太网技术的主要进步之一,此前的以太网都是使用同轴电缆,自此以后,双绞线正式取代同轴电缆走上了历史舞台。10BASE-T因为价格便宜、配置灵活和易于管理而流行起来,现在占整个以太网销售量的90%以上。

    10BASE-F

    • 10BASE- T解释:10表示10Mbit/s的传输速度,BASE表示使用基带传输,F表示光纤,使用双工光缆,一条光缆用于发送数据,另一条用于接收;
    • 分为FP、FB 、FL三种链接类型,FP使用无源集线器连接,传输距离500米。FB使用有源连接器,传输距离2000米。FL可以使用多个中继器,可以进一步延长器传输距离;

    10BASE-FP

    • P为Passive的缩写,用来说明点对点的连接方式,一个网段的长度可达500m;
    • 一个光缆无源星形耦合器最多可连接33台计算机。这形成了一个以信号耦合器为中心的星型网络;
    • 没有已知的设备实现了这个标准;

    10BASE-FB

    • B为Backbone的缩写,是用来说明一个同步信令骨干网段,用于在一个跨越远距离的转发主干网系统中将专用的10BASE-FB同步信令中继器连接在一起。单个10BASE-FB网段最长可达2000m;
    • 它不用于连接用户工作站。而是用于提供一个同步的信令骨干网,该网允许附加网段和中继器连接到网络上;

    10BASE-FL

    • L是Link的缩写,10BASE-FL是以太网光纤上最常用的10BASE-F规范;
    • 10BASE-FL是路由器之间用光纤连接构成的以太网。最初在DIX规范中称为 FOIRL ,但由 IEE标准化后称为10BASE-FL。支持可达4km的光缆主干以10Mbit/s的速度传输;
    • 如今,10BASE-FL很少用于网络,并已被快速以太网,千兆以太网和100千兆位以太网标准所取代;

    快速以太网:100Mbps以太网

    100Mbps以太网就是业内常说的快速以太网,它由 IEEE 802.3u 标准定义,基本与标准以太网相同,但速度比标准以太网快十倍。快速以太网的速度是通过提高时钟频率和使用不同的编码方式获得的。其传输方案最常用的便是100BASE-T,100BASE-T又包括100BASE-TX 、100BASE-T4以及其他几种。100BASE-T4 是一种 3 类双绞线方案,不支持全双工,目前最广泛使用的都是100BASE-TX,此方案需使用 5 类以上双绞线,时钟信号处理速率高达125MHz。

    100BASE-T

    • 又称Fast Ethernet(快速以太网),是许多以标称速率100 Mbit/s传输流量的以太网标准的统称。在快速以太网标准中,100BASE-TX是最常见的。
    • 名称中的“100”是指100Mbit/s的传输速度,“BASE”是指基带信令,破折号后面的字母T是指承载信号的物理介质为双绞线。快速以太网有时被称为100BASE-X,其中“X”是FX和TX变体的占位符;

    100BASE-T4

    • 100BASE-T4是快速以太网的早期实现。使用的是四对双绞线,一对保留用于发送,一个用于接收,其余两个将通过协商切换方向;
    • 使用RJ-45连接器,最大网段长度为100m,并且在节点间的最小长度是2.5米;
    • 采用EIA568布线标准。由于没有专用的发送或接收线路,所以100BASE-T4不能进行全双工操作;
    • 在传输中采用8B/6T的编码方式,即每8位作为一组的数据转换为每6位一组的三元码组,每条输出信道的信息传输率为33.3Mbps*6/8=25Mbaud;
    • 100BASE-T4未被广泛采用,但为其开发的技术被用于1000BASE-T;

    100BASE-TX

    • 使用两对5类非屏蔽双绞线或1类屏蔽双绞线,一对用于发送数据,另一对用于接收数据;
    • 最大网段长度为100m,布线符合EIA568标准;
    • 采用的是4B/5B编码方式,即把每4位数据用5位的编码组来表示,该编码方式的码元利用率=4/5*100%=80%。然后将4B/5B编码成NRZI进行传输,使其可以125MHz的串行数据流来传送数据;
    • 100BASE-TX采用的物理拓扑结构为星型,在目前的组网方法中,使用最多的是- 100BASE-TX标准的网卡,只支持RJ-45标准,它多用于主干网;
    • 支持全双工,使用MLT-3(多电平传输-3)波形法来降低信号频率到125/3=41.6MHz;
    • 100BASE-TX是100BASE-T中使用最为广泛的物理层规范;

    100BASE-T2

    • 随着数字信号处理技术和集成电路技术的发展,只用2对3类UTP线就可以传送100Mbps的数据,因而针对100BASE-T4不能实现全双工的缺点,IEEE开始制定100BASE-T2标准;
    • 100BASE-T2 采用2对音频或数据级3、4或5类UTP电缆,一对用于发送数据,另一对用于接收数据,可实现全双工操作;采用RJ45连接器,最长网段为100m,符合EIA568布线标准;
    • 采用名为PAM5x5的5电平编码方案;

    100BASE-T1

    • 100BASE-T1是IEEE专门针对100Mb/s汽车以太网的规范,也可以将其称为IEEE802.3bw,这两个名称指的是相同的规范。“-T1”后缀是一个重要的区别,让您知道是指汽车以太网,它与普通100BASE-T不同;
    • 100BASE-T1规范可与OPEN Alliance BroadR-Reach互操作,它们几乎相同(名称通常可互换使用),但有两个的小的差异,第一在物理层电气(物理介质附件PMA)测试规范中,100BASE-T1规范定义了发送端最大峰值差分输出的测试,BroadR-Reach规范中未明确定义此参数。第二个差异是100BASE-T1规范在唤醒命令的协议时序上存在一些差异,以使这些时段更短;
    • 它仅支持全双工,同时在两个方向上传输;
    • 双绞线电缆需要支持66 MHz,最大长度为15米;
    • 没有定义特定的连接器;

    100BASE-X

    • 最新的IEEE Std 802.3™-2015的SECTION 2 的Clause 24 规定了一系列100 Mb/s物理层实现共同使用的物理编码子层(PCS)和物理媒体附加(PMA)子层,统称为100BASE-X;
    • 目前在这个系列中有两个实施例:100BASE-TX和100BASE-FX。100BASE-TX指定通过两对双绞线5类电缆进行操作,100BASE-FX指定通过两根光纤进行操作;

    100BASE-FX

    • 100BASE-FX是光纤上的快速以太网版本。使用两股光纤,一股用于发送数据,另一股用于接收数据。可用单模光纤或者多模光纤。在全双工情况下,单模光纤的最大传输距离是40千米,多模光纤的最大传输距离是2千米;
    • 100BASE-FX使用与100BASE-TX相同的4B5B编码和NRZI线路代码;
    • 100BASE-FX运行于光缆上,使得它非常适合于高速主干网和长距离传输、或有强电气干扰的环境、或要求较高安全保密链接的环境;

    千兆以太网:1Gbps以太网

    千兆以太网标准IEEE 802.3z于1998年6月获得批准,它为三种传输媒质定义了三种收发器:1000BASE-LX用于安装单模光纤,1000BASE-SX用于安装多模光纤,1000BASE-CX用于平衡、屏蔽铜缆,可以用于机房内设备的互连。IEEE 802.3ab定义了在5类线的基础上运行千兆以太网1000BASE-T的物理层,并在1999年6月得到批准。

    1000BASE-X

    • IEEE802.3z定义了基于光纤和短距离铜缆的1000BASE-X;
    • 采用8B/10B编码技术,信道传输速度为1.25Gbit/s,去耦后实现1000Mbit/s传输速度;

    1000BASE-CX

    • 采用的是150Ω平衡屏蔽双绞线(STP),使用9芯D型连接器连接电缆;
    • 采用8B/10B编码方式,最大传输距离25米;
    • 适用于交换机之间的连接,尤其适用于主干交换机和主服务器之间的短距离连接;

    1000BASE-LX

    • 1000BASE-LX采用单模或多模长波激光器(long wavelength laser)的规格。
    • 采用直径为9um或10um的单模光纤,工作波长范围为1270-1355nm,传输距离为5km左右。
    • 采用直径为62.5um或50um的多模光纤时,工作波长范围为1270-1355nm,传输距离为550m;

    1000BASE-SX

    • 1000BASE-X 采用多模短波激光器(short wave-length laser)的规格;
    • 只支持多模光纤,可以采用直径为62.5um或50um的多模光纤,工作波长为770-860nm,传输距离为220-550m;

    1000BASE-T

    • 采用四对五类平衡电缆的1000 Mb/s物理层规格。与10BASE-T、100BASE-T完全兼容;
    • 千兆以太网可以在下列四种媒质上运行:单模光纤,最大连接距离至少可达5公里;多模光纤,最大连接距离至少550米;同轴电缆,最大连接距离至少25米;超五类/六类线,最大连接距离为100米;

    万兆以太网:10Gbps以太网

    10G以太网于2002年7月在IEEE通过。10G以太网包括10GBASE-X、10GBASE-R和10GBASE-W。

    • 10GBASE-X使用一种特紧凑包装,含有1个较简单的WDM器件、4个接收器和4个在1300nm波长附近以大约25nm为间隔工作的激光器,每一对发送器/接收器在3.125Gbit/s速度(数据流速度为2.5Gbit/s)下工作;
    • 10GBASE-R是一种使用64B/66B编码(不是在千兆以太网中所用的8B/10B)的串行接口,数据流为10.000Gbit/s,因而产生的时钟速率为10.3Gbit/s;
    • 10GBASE-W是广域网接口,与SONET OC-192兼容,其时钟为9.953Gbit/s数据流为9.585Gbit/s;
    展开全文
  • Base64编解码及其C++实现

    万次阅读 2018-09-07 23:07:13
    这两天在为公司的框架添加一个Base64加解密的模块,于是就想分享一下Base64的原理及自己的C++实现,借鉴了poco库。博文中的代码都是这两天写的代码的简洁版,可以完成Base64的编解码,方便易用。 不推荐造轮子,...

    这两天在为公司的框架添加一个Base64加解密的模块,于是就想分享一下Base64的原理及自己的C++实现,借鉴了poco库。博文中的代码都是这两天写的代码的简洁版,可以完成Base64的编解码,方便易用。

    不推荐造轮子,但是轮子在别的车上,你得自己拆下来,然后根据自己车的尺寸DIY你的轮子,安在自己的车上,当然,你还需要了解这个轮子的原理,万一哪天轮子坏了要你来修呢。

    Base64简介

    Base64是一种字节编码方式,一个字节可表示256个值,那么ASCII中0x20 ~ 0x7E是可打印字符,也就是说只有这么些范围的字符打印出来是可见的。Base64编码就是把字节转化成ASCII码中可打印的字符(Base64编码是从二进制到可见字符的过程)。它是一种任意二进制到文本字符串的编码方法,常用于在URL、Cookie、网页中传输少量二进制数据。

    Base64应用

    • 由于二进制的一些字符在网络协议中属于控制字符,不能直接传送,因此需要用Base64编码之后传输,编码之后传输的是一些很普通的ASCII字符。
    • Base64常用于邮件编码,当邮件中有二进制数据时,就要编码转换。
    • 图片的编码
    • Url中有二进制数据,这个时候需要Base64编码(Web安全的Base64)
    • 可以进行简单的加密,Base64的编解码规则是透明的,因此用Base64加密时要加盐。

    Base64原理

    用一句话来说明Base64编码的原理:“把3个字节变成4个字节”。

    这么说吧,3个字节一共24个bit,把这24个bit依次分成4个组,每个组6个bit,再把这6个bit塞到一个字节中去(最高位补两个0就变成8个bit),就会变成4个字节。没了。

    因为6个bit最多能表示 26=64 2 6 = 64 ,也就是说Base64编码出来的字符种类只有64个,这也是Base64名字的由来。

    那我们就要从ASCII中0x20 ~ 0x7E是可打印字符选出64个普通的ASCII字符

    下面就是映射表(来自维基百科):

    这里写图片描述

    解密的过程就是一个逆的过程,加解密下面有一张我自己绘制的图,看了你就明白了。

    这里写图片描述

    看了这张图片,你会发现貌似只有字节数是3的倍数才能处理啊,那么显示情况中,不是3的倍数的情况多的是,怎么办?补零加=号,看下图:

    这里写图片描述

    因此Base64编码后有时候可以看到=或者==这都是正常的。

    那么解码的密文就有一定的要求的,从前面的分析中得出来,加密之后形成的密文长度一定是4的倍数,且字符串中的字符一定要在映射表中,或者字符为=,还有,只可能有一个=或一个==

    C++编码实现Base64

    首先需要做出两张表,一张是编码映射表,一张是解码映射表。

    编码表:

    const unsigned char Base64EncodeMap[64] =
    {
        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
        'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
        'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
        'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
        'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
        'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
        'w', 'x', 'y', 'z', '0', '1', '2', '3',
        '4', '5', '6', '7', '8', '9', '+', '/'
    };

    打编码表可以使用下面的代码:

    for (int i = 0; i < 26; Base64EncodeMap[0 + i] = 'A' + i, ++i) {}
    for (int i = 0; i < 26; Base64EncodeMap[26 + i] = 'a' + i, ++i) {}
    for (int i = 0; i < 10; Base64EncodeMap[52 + i] = '0' + i, ++i) {}
    Base64EncodeMap[62] = '+';
    Base64EncodeMap[62] = '/';

    解码表:

    unsigned char Base64DecodeMap[256] =
    {
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0x3E, 0xFF, 0xFF, 0xFF, 0x3F,
        0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B,
        0x3C, 0x3D, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF,
        0xFF, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
        0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
        0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
        0x17, 0x18, 0x19, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20,
        0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
        0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30,
        0x31, 0x32, 0x33, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
    };

    打解码表可以使用下面的代码:

    for (int i = 0; i < (1 << 8); Base64DecodeMap[i++] = 0xFF) {}
    for (int i = 0; i < (1 << 8); Base64DecodeMap[Base64EncodeMap[i]] = i, ++i) {}
    Base64DecodeMap['='] = 0;

    编解码的步骤就是上面两张图,用位运算就可以搞定了。下面是核心代码。

    /*Encode*/
    
    // 0 index byte
    index = _group[0] >> 2;
    _buf.push_back(_encodeMap[index]);
    // 1 index byte
    index = ((_group[0] & 0x03) << 4) | (_group[1] >> 4);
    _buf.push_back(_encodeMap[index]);
    // 2 index byte
    index = ((_group[1] & 0x0F) << 2) | (_group[2] >> 6);
    _buf.push_back(_encodeMap[index]);
    // 3 index byte
    index = _group[2] & 0x3F;
    _buf.push_back(_encodeMap[index]);
    /*Decode*/
    
    buff[0] = (_decodeMap[_group[0]] << 2) | (_decodeMap[_group[1]] >> 4);
    if (_group[2] != '=')
    {
        buff[1] = ((_decodeMap[_group[1]] & 0x0F) << 4) | (_decodeMap[_group[2]] >> 2);
        top = 2;
    }
    if (_group[3] != '=')
    {
        buff[2] = (_decodeMap[_group[2]] << 6) | _decodeMap[_group[3]];
        top = 3;
    }
    
    for (unsigned int i = 0; i < top; ++i)
    {
        _buf.push_back(buff[i]);
    }
    

    然后把编码做成一个类Base64Encrypt,解码也做成一个类Base64Decrypt

    你要考虑到的一点是,编解码有时候不会一次性完成,为什么呢,实际情况中,要编解码的字符串可能很长,你不可能把字符串一次性读到内存中,因此就要分批编解码,但是我们编码是以3个字节为一组进行编码,因此,在类中需要设置一个缓存,长度为3,当缓存满了,就直接把让3个字节去编码。poco库就是这么实现的。

    编码出来的结果用vector去存储,但是vector存储又会发生内存的频繁复制(考虑下vector的实现)。怎么办呢?由于Base64的编解码规则是透明的,给你一段字符串,你马上可以计算出加密出来的字符串有多长。这样子就可以使用std::vector::reserve成员函数来为vector预先分配空间。

    Base64Encrypt

    class Base64Encrypt
    {
    public:
        Base64Encrypt() : _groupLength(0) {}
        Base64Encrypt(const void *input, size_t length) : Base64Encrypt()
        {
            Update(input, length);
        }
    
        void Update(const void *input, size_t length)
        {
            static const size_t LEN = 3;
            _buf.reserve(_buf.size() + (length - (LEN - _groupLength) + LEN - 1) / LEN * 4 + 1);
            const unsigned char *buff = reinterpret_cast<const unsigned char *>(input);
            unsigned int i;
    
            for (i = 0; i < length; ++i)
            {
                _group[_groupLength++] = buff[i];
                if (_groupLength == LEN)
                {
                    Encode();
                }
            }
        }
        const unsigned char *CipherText()
        {
            Final();
            return _buf.data();
        }
        std::string GetString()
        {
            const char *pstr = (const char *)CipherText();
            size_t length = GetSize();
            return std::string(pstr, length);
        }
        void Reset()
        {
            _buf.clear();
            _groupLength = 0;
            for (unsigned int i = 0; i < sizeof(_group) / sizeof(_group[0]); ++i)
            {
                _group[i] = 0;
            }
        }
        size_t GetSize()
        {
            CipherText();
            return _buf.size();
        }
    
    private:
        Base64Encrypt(const Base64Encrypt &) = delete;
        Base64Encrypt & operator = (const Base64Encrypt &) = delete;
    
        void Encode()
        {
            unsigned char index;
    
            // 0 index byte
            index = _group[0] >> 2;
            _buf.push_back(Base64EncodeMap[index]);
            // 1 index byte
            index = ((_group[0] & 0x03) << 4) | (_group[1] >> 4);
            _buf.push_back(Base64EncodeMap[index]);
            // 2 index byte
            index = ((_group[1] & 0x0F) << 2) | (_group[2] >> 6);
            _buf.push_back(Base64EncodeMap[index]);
            // 3 index byte
            index = _group[2] & 0x3F;
            _buf.push_back(Base64EncodeMap[index]);
    
            _groupLength = 0;
        }
        void Final()
        {
            unsigned char index;
    
            if (_groupLength == 1)
            {
                _group[1] = 0;
                // 0 index byte
                index = _group[0] >> 2;
                _buf.push_back(Base64EncodeMap[index]);
                // 1 index byte
                index = ((_group[0] & 0x03) << 4) | (_group[1] >> 4);
                _buf.push_back(Base64EncodeMap[index]);
                // 2 index byte
                _buf.push_back('=');
                // 3 index byte
                _buf.push_back('=');
            }
            else if (_groupLength == 2)
            {
                _group[2] = 0;
                // 0 index byte
                index = _group[0] >> 2;
                _buf.push_back(Base64EncodeMap[index]);
                // 1 index byte
                index = ((_group[0] & 0x03) << 4) | (_group[1] >> 4);
                _buf.push_back(Base64EncodeMap[index]);
                // 2 index byte
                index = ((_group[1] & 0x0F) << 2) | (_group[2] >> 6);
                _buf.push_back(Base64EncodeMap[index]);
                // 3 index byte
                _buf.push_back('=');
            }
    
            _groupLength = 0;
        }
    
    private:
        std::vector<unsigned char> _buf;
        unsigned char _group[3];
        int _groupLength;
    
        static const unsigned char Base64EncodeMap[64];
    };

    注意_buf.reserve(_buf.size() + (length - (LEN - _groupLength) + LEN - 1) / LEN * 4 + 1);这行代码,好好体会下。

    Base64Decrypt

    class Base64Decrypt
    {
    public:
        Base64Decrypt() : _groupLength(0) {}
        Base64Decrypt(const void *input, size_t length) : Base64Decrypt()
        {
            Update(input, length);
        }
    
        void Update(const void *input, size_t length)
        {
            static const size_t LEN = 4;
            _buf.reserve(_buf.size() + (length + (LEN - _groupLength) + LEN - 1) / LEN * 3 + 1);
            const unsigned char *buff = reinterpret_cast<const unsigned char *>(input);
            unsigned int i;
    
            for (i = 0; i < length; ++i)
            {
                if (Base64DecodeMap[buff[i]] == 0xFF)
                {
                    throw std::invalid_argument("ciphertext is illegal");
                }
    
                _group[_groupLength++] = buff[i];
                if (_groupLength == LEN)
                {
                    Decode();
                }
            }
        }
    
        const unsigned char *PlainText()
        {
            if (_groupLength)
            {
                throw std::invalid_argument("ciphertext's length must be a multiple of 4");
            }
            return _buf.data();
        }
        void Reset()
        {
            _buf.clear();
            _groupLength = 0;
            for (unsigned int i = 0; i < sizeof(_group) / sizeof(_group[0]); ++i)
            {
                _group[i] = 0;
            }
        }
        size_t GetSize()
        {
            PlainText();
            return _buf.size();
        }
    
    private:
        Base64Decrypt(const Base64Decrypt &) = delete;
        Base64Decrypt & operator = (const Base64Decrypt &) = delete;
    
        void Decode()
        {
            unsigned char buff[3];
            unsigned int top = 1;
            if (_group[0] == '=' || _group[1] == '=')
            {
                throw std::invalid_argument("ciphertext is illegal");
            }
    
            buff[0] = (Base64DecodeMap[_group[0]] << 2) | (Base64DecodeMap[_group[1]] >> 4);
            if (_group[2] != '=')
            {
                buff[1] = ((Base64DecodeMap[_group[1]] & 0x0F) << 4) | (Base64DecodeMap[_group[2]] >> 2);
                top = 2;
            }
            if (_group[3] != '=')
            {
                buff[2] = (Base64DecodeMap[_group[2]] << 6) | Base64DecodeMap[_group[3]];
                top = 3;
            }
    
            for (unsigned int i = 0; i < top; ++i)
            {
                _buf.push_back(buff[i]);
            }
    
            _groupLength = 0;
        }
    
    private:
        std::vector<unsigned char> _buf;
        unsigned char _group[4];
        int _groupLength;
    
        static unsigned char Base64DecodeMap[256];
    };

    使用Base64Decrypt需要用try-catch代码块包裹起来,因为对密文进行解码,密文可能不合法,这个时候Base64Decrypt类只能通过抛出std::invalid_argument异常来告诉用户。

    Web安全版Base64

    Web安全版Base64其实和标准版一样,只不过映射表中的+对应-, /对应_,所有代码只要根据这两个地方具体改动,就可以完成Web安全版的Base64,Web安全版Base64也叫SafeUrlBase64。

    测试

    怎么知道你写的Base64是正确的,这需要测试,我们需要知道一段字符串通过Base64加密出来正确的密文,这个可以通过在线的Base64编解码网站实现,不过,更推荐Python中的base64模块,其中的base64.b64encode方法编码,base64.urlsafe_b64encode可以进行Web安全的Base64编码,有了正确的密文,进行比较;之后可以把这些正确的密文解码回来,看看是不是等于之前的字符串。


    参考

    展开全文
  •   在搞网络这一块的时候,看到了100Base-T、100Base-TX等这些东西,在IEEE802.3中,也到处是这些词。大体了解了一下,下面是正文。   以太网采用CSMA/CD(Carrier Sense Multiple Access/Collision Detection,...

      在搞网络这一块的时候,看到了100Base-T、100Base-TX等这些东西,在IEEE802.3中,也到处是这些词。大体了解了一下,下面是正文。
      以太网采用CSMA/CD(Carrier Sense Multiple Access/Collision Detection,载波监听多路存取和冲突检测)介质访问控制方式的局域网技术,最初由Xerox公司于1975年研制成功,1979年7月~1982年间,由DEC、Intel和Xerox三家公司制定了以太网的技术规范DIX,以此为基础形成的IEEE802.3以太网标准在1989年正式成为国际标准。在20多年中以太网技术不断发展,成为迄今最广泛应用的局域网技术,产生了多种技术标准。
      这些名字都是不同时期的以太网标准,标准名字来源于所使用的物理介质,下面先拆解一下这类名词:

    • 10/100/1000: 数字100用单位MHz (Megahertz)表示网线设计的频率。即100 MHz。MHz的值越大,网线所支持的速度就越快。如果你尝试将这种类型的网线用于更高的频率(和速度)中,那么它将不工作或者变得极为不可靠。100 MHz以每秒100Mbit的速度传输,这在理论上指的就是12 Mbps。然而,在实际中,可能还无法获得超过4 Mbps。
    • BASE: BASE是英文baseband的缩写,指的就是基带。表示没有使用频分复用或者其它频率转换技术,每一个信号在一个单一频率上完全控制线缆。
    • 数字T/F/C等: 一般数组表示传输长度;T代表承载信号的物理介质是双绞线缆(分为UTP(Unshielded Twisted Pair,非屏蔽双绞线)和STP(Shielded Twicted Pair,屏蔽双绞线)),在这里每一对传送信号的双绞线互相缠绕以(FEXT和NEXT之间)减少电磁干扰和串扰;F表示光纤
    • 最后的字母或数字(4/X等): 在同一种传送速率下有多种不同的标准,它们之间以一个字母或数字跟随T/F/C之后的方式来区隔(例如TX)。它显示了网线的结构并指出包含的绞线对的数量。某些高速标准使用同轴电缆,则分配代号为CX。

    下面详细说明每种组合的意义:

    10base5

      10BASE5(也被称为thick Ethernet or thicknet)是以太网的第一个商用变体。
      10BASE5的名称来源于物理介质的几个特征:10指的是其10Mbit/s的传输速度; BASE是基带信号的缩写(与宽带相反),5代表最大段长度为500米(1600英尺)。
      使用直径10mm的50欧姆粗同轴电缆(coaxial cable ),总线拓扑结构,站点网卡的接口为DB-15连接器,每个网段允许有100个站点,每个网段最大允许距离为500m,网络直径为2500m,既可由5个500m长的网段和4个中继器组成。
    10BASE5
      利用基带的10M传输速率,采用曼彻斯特编码传输数据。 该系统在安装和维护上难度较大。
      该部分在最新的IEEE Std 802.3™-2015的SECTION 1 的Clause 8有详细的介绍。
    10base5

    从2003年开始,IEEE 802.3已经不再使用这个新安装标准。

    10Base2

      10BASE2(也被称为cheapernet,thin Ethernet,thinnet和thinwire)是以太网的变体,使用以BNC连接器端接的***细同轴电缆***。为降低10base5的安装成本和复杂性而设计的。
      10BASE2这个名字来源于物理介质的几个特性:10来自10 Mbit / s的传输速度; BASE代表基带信令;2代表最大段长度接近200米(实际最大长度为185米)。
      其使用廉价的R9-58型50欧姆细同轴电缆,总线拓扑结构,网卡通过T形接头连接到细同轴电缆上,末端连接50欧姆端接器;每个网段允许30个站点,每个网段最大允许距离为185m,仍保持10Base5的4中继器/5网段设计能力,允许的最大网络直径为5x185=925m。
    10Base2
      利用基带的10M传输速率,采用曼彻斯特编码传输数据。与10base5相比,10Base2以太网更容易安装,更容易增加新站点,能大幅度降低费用。
      该部分在最新的IEEE Std 802.3™-2015的SECTION 1 的Clause 10有详细的介绍。
    10Base2

    在20世纪80年代中后期,这是占主导地位的10 Mbit / s以太网标准
    此MAU不建议用于新安装。 自2011年9月以来,该部分不再考虑维护变更。

    10base-T(涵10BASE-Te)

      标准的通用名称来源于物理媒体的各个方面。 前导号码(10BASE-T中的10)是指以Mbit/s为单位的传输速度。 BASE表示使用基带传输。 T表示双绞线(Twisted pair cables),每个信号的一对导线绞合在一起以减少对之间的电磁干扰和串扰。 对于相同传输速度有几种标准的情况下,它们通过T之后的字母或数字来区分,例如TX,指的是编码方法和通道数量,后面介绍。
      这是1990年通过的以太网物理层标准。使用***两对非屏蔽双绞线***,一对线发送数据,另一对线接收数据,用RJ-45模块作为端接器,星形拓扑结构,信号频率为20MHz,必须使用3类或更好的UTP电缆;布线按照EIA568标准,站点中继器和中继器中继器的最大距离为100m。保持了10base5的4中继器/5网段的设计能力,使10base-T局域网的最大直径为500m。10Base-T的集线器和网卡每16秒就发出“滴答”(Hear-beat)脉冲,集线器和网卡都要监听此脉冲,收到“滴答” 信号表示物理连接已建立,10base-T设备通过LED向网络管理员指示链路是否正常。
    10base-T
      双绞线以太网是以太网技术的主要进步之一,此前的以太网都是使用同轴电缆,自此以后,双绞线正式取代同轴电缆走上了历史舞台。10base-T因为价格便宜、配置灵活和易于管理而流行起来,现在占整个以太网销售量的90%以上。
      该部分在最新的IEEE Std 802.3™-2015的SECTION 1 的Clause 14有详细的介绍。
    10base-T

    10base-F

      是使用光缆的以太网,使用双工光缆,一条光缆用于发送数据, 另一条用于接收;使用ST连接器,星形拓扑结构;网络直径为2500m,定义了4种不同的规范,分别对应于最新的IEEE Std 802.3™-2015的SECTION 1 的Clause 15, Clause 16, Clause 17, and Clause 18
    10base-F

    10Base-FL

      L是Link的缩写,10BASE-FL是以太网光纤上最常用的10BASE-F规范。 在10BASE-FL中,FL代表光纤链路。 它取代了原始的光纤中继器链路(FOIRL)规范,但保留了与基于FOIRL的设备的兼容性。 支持的最大段长度为2000米[2]与FOIRL设备混合时,最大段长度限于FOIRL的1000米。
    10Base-FL

    注意 - 不建议将此MAU用于新安装。 自2003年9月以来,本条款不再考虑维护变更。
    如今,10BASE-FL很少用于网络,并已被快速以太网,千兆以太网和100千兆位以太网标准所取代。

    10Base-FB

      B为Backbone的缩写,是用来说明一个同步信令骨干网段,用于在一个跨越远距离的 转发主干网系统中将专用的10Base-FB同步信令中继器连接在一起。单个10base-FB网段最长可达2000m。
    10Base-FB

    注意 - 不建议将此MAU用于新安装。 自2011年9月以来,本条款不再考虑维护变更。

    10Base-FP

      P为Passive的缩写,是用来说明点对点的连接方式,一个网段的长度可达500m。一个光缆无源星形耦合器最多可连接33台计算机。这形成了一个以信号耦合器为中心的星型网络。 没有已知的设备实现了这个标准。

    100base-T

      又称Fast Ethernet(快速以太网),是许多以标称速率100 Mbit/s(较早的以太网速度为10 Mbit / s)传输流量的以太网标准的统称。在快速以太网标准中,100BASE-TX是最常见的。
      名称中的“100”是指100Mbit/s的传输速度;而“BASE”是指基带信令; 破折号后面的字母(“T”或“F”)是指承载信号的物理介质(分别为双绞线或光纤);而最后一个字符(“X”,“4”等)指的是使用的行代码方法。 快速以太网有时被称为100BASE-X,其中“X”是FX和TX变体的占位符。
      1995年5月正式通过了快速以太网/100Base-T规范,即IEEE 802.3u标准,是对IEEE802.3的补充。与10base-T一样采用星形拓扑结构,但100Base-T包含4个不同的物理层规范, 并且包含了网络拓扑方面的许多新规则。
    对应于最新的IEEE Std 802.3™-2015的SECTION 2:
    100base-T

    在实际使用中,100 Base-T有时候用于指100Base-TX网线规格。

    100Base-T4

      100BASE-T4是快速以太网的早期实现。 它需要四对铜质双绞线,但这些双绞线只需要是3类而不是TX所要求的5类。 一对保留用于发送,一个用于接收,其余两个将通过协商切换方向。
      是为了利用大量的3类音频级布线而设计的。信号频率为25MHz,因而可以使用数据级3、4或5类非屏蔽双绞线,也可使用音频级3类线缆。最大网段长度为100m,并且在节点间的最小长度是2.5米。采用EIA568布线标准;由于没有专用的发送或接收线路,所以***100Base-T4不能进行全双工操作***; 100base-T4采用比曼彻斯特编码法高级的多的6B/6T编码法。
      100BASE-T4未被广泛采用,但为其开发的技术被用于1000BASE-T。
    对应于最新的IEEE Std 802.3™-2015的SECTION 2 的Clause 23:
    100Base-T4

    注 - 不建议将此PHY用于新安装。 自2003年9月以来,本条款不再考虑维护变更。

    100Base-X

    最新的IEEE Std 802.3™-2015的SECTION 2 的Clause 24 规定了一系列100 Mb/s物理层实现共同使用的物理编码子层(PCS)和物理媒体附加(PMA)子层,统称为100BASE-X。 目前在这个系列中有两个实施例:100BASE-TX和100BASE-FX。 100BASE-TX指定通过两对双绞线5类电缆进行操作。 100BASE-FX指定通过两根光纤进行操作。
    对应于最新的IEEE Std 802.3™-2015的SECTION 2 的Clause 24:
    100Base-X

    100Base-TX

      使用两对5类非屏蔽双绞线或1类屏蔽双绞线,一对用于发送数据,另一对用于接收数据,最大网段长度为100m,布线符合EIA568标准;采用4B/5B编码法,使其可以125MHz的串行数据流来传送数据;其支持全双工, 使用MLT-3(多电平传输-3)波形法来降低信号频率到125/3=41.6MHz。***100Base-TX使100Base-T中使用最广的物理层规范。 ***
    对应于最新的IEEE Std 802.3™-2015的SECTION 2 的Clause 25:

    100Base-FX

      100BASE-FX是光纤上的快速以太网版本。 它使用通过两根光纤传输的1300纳米近红外(NIR)光波长,一根用于接收(RX),另一根用于发送(TX)。 对于半双工连接(为了确保检测到碰撞),最大长度为412米(1,350英尺),对于全双工多模光纤,最大长度为2千米(6,600英尺)。 100BASE-FX使用与100BASE-TX相同的4B5B编码和NRZI线路代码。 100BASE-FX应使用SC,ST,LC,MTRJ或MIC连接器,SC是首选。
      使用多模(62.5或125um)或单模光缆,连接器可以是MIC/FDDI 连接器、ST连接器或廉价的SC连接器;最大网段长度根据连接方式不同而变化,例如:对于多模光纤的交换机-交换机连接或交换机-网卡 连接最大允许长度为412m,支持全双工模式,如果是全双工链路,则可达到2000m。100Base-FX主要用于高速主干网,或远距离连接,或有强电气干扰的环 境,或要求较高安全保密链接的环境。
    对应于最新的IEEE Std 802.3™-2015的SECTION 2 的Clause 26。

    #100Base-T2
      随着数字信号处理技术和集成电路技术的发展,只用2对3类UTP线就可以传送100Mbps的数据,因而针对100Base-T4不能实现全双工的缺点,IEEE开始制定100Base-T2标准。100Base-T2 采用2对音频或数据级3、4或5类UTP电缆,一对用于发送数据,另一对用于接收数据,可实现全双工操作;采用RJ45连接器,最长网段为100m,符合EIA568布线标准。采用名为PAM5x5的5电平编码方案。
    对应于最新的IEEE Std 802.3™-2015的SECTION 2 的Clause 32:
    100Base-T2

    注 - 不建议将此PHY用于新安装。 自2003年9月以来,本条款不再考虑维护变更。

    100BASE-T1

    100BASE-T2没有被广泛采用,但为其开发的技术被用于1000BASE-T。100BASE-T1在IEEE 802.3bw-2015条款96中标准化的100BASE-T1中,​​数据通过单个铜线对传输,每个符号3位(PAM3)。 它仅支持全双工,同时在两个方向上传输。 双绞线电缆需要支持66 MHz,最大长度为15米。 没有定义特定的连接器。 该标准适用于汽车应用,或者快速以太网将被集成到其他应用中。 在IEEE标准化之前,它已被开发为BroadR-Reach。

      ***自动协商模式:***在100Base-T问世以后,在以太网RJ-45连接器上可能出现的信 号可能是5种以上不同的以太网信号(10Base-T、10base-T全双工、100base-TX、100Base-TX全双工或100Base-T4)中的任一种。为了简化 管理,3.11.71 IEEE已推出了Nway(IEEE自动协商模式),它能使集线器和网卡知道线路另一端能有的速度,把速度自动调节到线路两端 能达到的最高速度(优先的顺序为:100Base-T2全双工,100Base-T2,100Base-TX全双工,100Base-T4,100Base-TX, 100Base-T全双工, 10Base-T)。这是增强型的10Base-T链路一体化信号方法,并与链路一体化反向兼容。这种技术避免了由于信号不兼容可能造成的网络 损坏。具有这种特性的装置仍允许人工选择可能的模式。

      千兆以太网技术有两个标准:IEEE802.3z和IEEE802.3ab。IEEE802.3z制定了光纤和短程铜线连接方案的标准(1000BASE-X)。IEEE802.3ab制定了五类双绞线上较长距离连接方案的标准(1000BASE-T)。

    1000BASE-X

      IEEE802.3z定义了基于光纤和短距离铜缆的1000Base-X,采用8B/10B编码技术,信道传输速度为1.25Gbit/s,去耦后实现1000Mbit/s传输速度。
    1000BASE-X
    IEEE802.3z具有下列千兆以太网标准:

    1000BASE-CX:

    1000BASE-X 在特制的屏蔽电缆传输的接口规格(参见 IEEE 802.3 Clause 39.)屏蔽类双绞线,传输距离25米。

    1000BASE-LX(long wavelength laser)

    1000BASE-X 采用单模或多模长波激光器的规格(参见 IEEE 802.3 Clause 38.)。采用直径为62.5um或50um的多模光纤时,工作波长范围为1270-1355nm,传输距离为550m;采用直径为9um或10um的单模光纤,工作波长范围为1270-1355nm,传输距离为5km左右。

    1000BASE-SX(short wave-length laser)

    1000BASE-X 采用多模短波激光器的规格(参见 IEEE 802.3 Clause 38.)。只支持多模光纤,可以采用直径为62.5um或50um的多模光纤,工作波长为770-860nm,传输距离为220-550m。

    1000BASE-T

    采用四对五类平衡电缆的1000 Mb/s 物理层规格 (参见 IEEE 802.3 Clause 40.)。与10Base-T、100Base-T完全兼容。

    展开全文
  • sun.misc.BASE64Decoder.jar 绿色版 官方版本自己打包好的,可以直接调用,欢迎下载
  • VC 中使用Base64编解码图片

    热门讨论 2014-03-28 07:35:02
    使用Base64编解码图片的小例子,希望可以对您的学习有帮助。
  • base64原理与实现

    千次阅读 2019-07-13 23:59:37
    1.base64   bse64是一种以64个可见字符集对二进制数据进行编码的编码算法。 1.1应用范围   base64常用于网络数据传输过程的编解码环节。HTTP环境下传递较长的标识信息。例如,在Java Persistence系统Hibernate中...

    1. base64

      bse64是一种以64个可见字符集对二进制数据进行编码的编码算法。


    1.1 应用范围

      base64常用于网络数据传输过程的编解码环节。HTTP环境下传递较长的标识信息。例如,在Java Persistence系统Hibernate中,就采用了base64来将一个较长的一个标识符(一般为128-bit的UUID)编码为一个字符串,用作HTTP表单和HTTP GET URL中的参数。在其他应用程序中,也常常需要把二进制数据编码为适合放在URL(包括隐藏表单域)中的形式。此时,采用Base64编码不仅比较简短,同时也具有不可读性,即所编码的数据不会被人用肉眼所直接看到 [引用百度百科]

    • 电子邮件加密;
    • 数据加密;
    • 采用base64来规避反垃圾邮件工具,因为那些工具通常都不会翻译base64的讯息;
    • 图片、文件网络传输;
    • Json存储二进制数据。

    1.2 编码表

      bse64编码表是64个可见字符集。
    在这里插入图片描述

    1.3 编码过程

      base64编码,每3个8位明文数据为一组,取这3个字数据的ASCII码,然后以6位为一组组成4个新的数据。对于不足3字节的处理:
    【1】不足三字节后面填充0;
    【2】对于编码前的数据产生的6位,如果为0,则索引到的字符为‘A’;因不足3字节而填充的0,用’=’来替代,有点结束符的意思。


      例如对“ABCD”进行base64编码:
    在这里插入图片描述
      对于不足6位的补零(图中浅红色的4位),索引为“A”;对于最后不足3字节,进行补零处理(图中红色部分),以“=”替代,因此,“ABCD”的base64编码为:“QUJDRA==”。


    1.4 解码过程

      base64解码,即是base64编码的逆过程,如果理解了编过过程,解码过程也就容易理解。将base64编码数据根据编码表分别索引到编码值,然后每4个编码值一组组成一个24位的数据流,解码为3个字符。对于末尾位“=”的base64数据,最终取得的4字节数据,需要去掉“=”再进行转换。

    解码过程可以参考上图,逆向理解:“QUJDRA==” ——>“ABCD”


    2. 实现

      base64应用范围很广,因此很多编程语言的标准库都提供base64编解码库,如PHP、Python等,一般不需重复造轮子,但能够重复造一遍轮子,会理解更透彻。


    2.1 C语言版

    #include <stdint.h>
    #include <stdbool.h>
    #include <stdlib.h>  
    #include <string.h>  
    #include <stdio.h>
     
    const char *base64_table="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; /* base64编码表 */ 
    
    static int num_strchr(const char *str, char c) 
    {
        const char *p = strchr(str, c);
    	
        if (NULL == p)
    	{
            return -1;
        }
    	
        return p - str;
    }
    
    uint32_t base64_get_dest_len(uint32_t src_len)
    {
    	return 4 * ((src_len+2)/3);  
    }
    
    uint32_t src_get_dest_len(uint32_t base64_len)
    {
    	return base64_len/4*3 - 2;  
    }
    
    int base64_encode(const char *src_str, uint32_t src_len, char *dest_str, uint32_t dest_len)  
    {  
        uint32_t i = 0;
        uint32_t len = 0;   
    
    	len = base64_get_dest_len(src_len);
    
    	if (dest_len < len)
    	{/* 空间不足 */
    		return -1;
    	}
      
        for (i=0; i<src_len/3; i++)  
        {  
            *dest_str++ = base64_table[(src_str[0]>>2) & 0x3f]; /* 取第一字符前6bit */  
            *dest_str++ = base64_table[((src_str[0]<<4) & 0x30) | ((src_str[1]>>4) & 0x0f)]; /* 第一字符的后2bit与第二字符的前4位进行合并 */  
            *dest_str++ = base64_table[((src_str[1]<<2) & 0x3c) | ((src_str[2]>>6) & 0x03)]; /* 将第二字符的后4bit与第三字符的前2bit组合并 */ 
            *dest_str++ = base64_table[src_str[2] & 0x3f]; /* 取第三字符的后6bit */  
            src_str += 3;
        }  
    
    	/* 非3的整数倍补“=” */
        if (1 == (src_len%3))
        {
        	*dest_str++ = base64_table[(src_str[0]>>2) & 0x3f];  
            *dest_str++ = base64_table[((src_str[0]<<4) & 0x30) | ((src_str[1]>>4) & 0x0f)]; 
            *dest_str++ = '=';  
            *dest_str++ = '=';  
       	}
    	else if (2 == (src_len%3))   
        {      
        	*dest_str++ = base64_table[(src_str[0]>>2) & 0x3f];  
            *dest_str++ = base64_table[((src_str[0]<<4) & 0x30) | ((src_str[1]>>4) & 0x0f)]; 
    		*dest_str++ = base64_table[(src_str[1]<<2) & 0x3c];
        	*dest_str++ = '=';    
    	}  
      	*dest_str = '\0';  
    	
        return 0;  
    }
    
    int base64_decode(const char *src_str, uint32_t src_len, char *dest_str, uint32_t dest_len)
    {
        uint32_t i = 0;
        char buf[4] = {0};
    
    	if (dest_len < src_get_dest_len(src_len))
    	{
    		return -1;
    	}
    	
        for (; (src_str[i]!='\0') && (i<src_len); i+=4)
    	{
            /* 四个码译成三个字符 */
            buf[0] = num_strchr(base64_table, src_str[i]);
            buf[1] = num_strchr(base64_table, src_str[i+1]);
           
            *dest_str++ = ((buf[0] << 2) & 0xfc) | ((buf[1]>>4) & 0x03);
    
            if (src_str[i+2] == '=')
    		{
                break;
            }
            buf[2] = num_strchr(base64_table, src_str[i + 2]);
           
            *dest_str++ = ((buf[1] << 4) & 0xf0) | ((buf[2] >> 2) & 0x0f);
    
            if (src_str[i + 3] == '=')
    		{
                break;
            }
            buf[3] = num_strchr(base64_table, src_str[i + 3]);
    
            *dest_str++ = ((buf[2] << 6) & 0xc0) | (buf[3] & 0x3f);
        }
    
        *dest_str = '\0';
    
        return 0;
    }
    
    int main(int argc,char **argv)  
    {  
        char *buf = NULL;
    	uint32_t dest_len = 0;
        uint32_t src_len = 0;
    
    	if (argc < 3)
    	{
            return -1;
        }
    	
        if (strcmp(argv[1],"decode") == 0) 
        { 
        	src_len = strlen(argv[2]);
    		dest_len = src_get_dest_len(src_len);
    		buf = (char*)malloc(dest_len);
    		if (NULL == buf)
    		{
                return -1;
            }
    		base64_decode(argv[2], src_len, buf, dest_len);
            printf("base64 str:%s\n",argv[2]);   
            printf("base64_decode str:%s\n",buf);
        }
        else if(strcmp(argv[1],"encode") == 0) 
        {
        	src_len = strlen(argv[2]);
        	dest_len = base64_get_dest_len(src_len);
    		buf = (char*)malloc(dest_len);
    		if (NULL == buf)
    		{
                return -1;
            }
    		base64_encode(argv[2], src_len, buf, dest_len);
    		printf("src str:%s\n",argv[2]);   
            printf("base64_encode str:%s\n",buf);   
        }
     
        free(buf);
     	buf = NULL;
        return 0;  
    }
    

      编译测试:
    在这里插入图片描述

      可用base64编码工具验证:http://tool.oschina.net/encrypt?type=3
    在这里插入图片描述

    展开全文
  • Redhat7 安装 yum 亲测 图解 这是安装全量包 包括 CentOS-Base.repo配置文件 亲测博客地址:http://blog.csdn.net/qq_34256348/article/details/78837175
  • Base64以及关于Base64遇到的坑

    千次阅读 2020-05-13 13:35:37
    使用Base64 public String encode(String src) { byte[] encodeBytes = Base64.getEncoder().encode(src.getBytes()); return new String(encodeBytes); } public String decode(String src) { byte[] ...
  • base64.jar

    千次下载 热门讨论 2013-01-16 14:04:40
    base64.jar
  • java base64的jar包

    千次下载 热门讨论 2013-07-30 22:47:43
    http://blog.csdn.net/yx0628/article/details/9633947 这个是gps转百度地图坐标的相关介绍。
  • 1、首先是基础类 ...public final class Base64Util { private static final int BASELENGTH = 128; private static final int LOOKUPLENGTH = 64; private static final int TWENTYFOURBITGROUP = 24; pri...
  • Base64加密解密

    万次阅读 2017-09-20 16:51:14
    Base64是网络上最常见的用于传输8Bit字节码的编码方式之一,Base64就是一种基于64个可打印字符来表示二进制数据的方法。可查看RFC2045~RFC2049,上面有MIME的详细规范。 Base64编码是从二进制到字符的过程,可...
  • Java8 Base64加密和解密

    千次阅读 2019-08-20 16:35:48
    在 Java8中 Base64编码已经成为Java类库的标准,且内置了Base64编码的编码器和解码器。 一、什么是Base64? -- 来自百度百科 Base64是网络上最常见的用于传输 8Bit字节码的编码方式之一, Base64就是一种基于64...
  • Base32 应用与原理解析

    千次阅读 2020-06-23 23:34:16
      Base32编码使用32个ASCII字符对任何数据进行编码,Base32与Base64的实现原理类似,同样是将原数据二进制形式取指定位数转换为ASCII码。首先获取数据的二进制形式,将其串联起来,每5个比特为一组进行切分,每一...
  • excel中进行Base64编解码

    热门讨论 2013-06-05 18:08:28
    在excel中进行Base64编解码的示例XLSM文件
  • Base16,Base32,Base64编码的介绍

    万次阅读 多人点赞 2018-08-30 10:42:18
    简介 在网络传入字符串过程中,如果编码...为了防止这种情况的出现,出现了Base16,Base32,Base64编码方式.我们知道计算机传输的单位是字节,也就是8个比特位,按照一个字节编码的方式结果就有256种状态(每个比特位0或...
  • 在Java中经常用到Base64编码,下面介绍Apache Base64 编码 和 Java8 之后Util 包内Base64 两种编码方式,并加以比较。 一、Base64 简介(百度百科) 1. Base64是网络上最常见的用于传输8Bit字节码的编码方式之一。 2...
  • Base64简介

    千次阅读 2018-12-15 17:38:56
    Base64是一种基于64个可打印字符来表示二进制数据的表示方法。由于2^6=64,所以每6个比特为一个单元,对应某个可打印字符。3个字节有24个比特,对应于4个Base64单元,即3个字节可由4个可打印字符来表示。它可用来...
  • Base64在线转换工具(详解)

    千次阅读 2020-09-01 11:45:53
    而ascii码的128~255之间的值是不可见字符,对于一些只支持可见字符的协议,比如邮件传输协议(SMTP)只支持可见的ASCII字符的传递,如果要传输二进制文件,比如:图片、视 频是无法实现的,因此就有了base64编码格式,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,038,817
精华内容 815,526
关键字:

base