ezpwd-reed-solomon, 在 C++ 中,Javascript & python,Reed Solomon & BCH编码和解码,

分享于 

59分钟阅读

GitHub

  繁體 雙語
Reed-Solomon encoding and decoding, in C++ and Javascript
  • 源代码名称:ezpwd-reed-solomon
  • 源代码网址:http://www.github.com/pjkundert/ezpwd-reed-solomon
  • ezpwd-reed-solomon源代码文档
  • ezpwd-reed-solomon源代码下载
  • Git URL:
    git://www.github.com/pjkundert/ezpwd-reed-solomon.git
    Git Clone代码到本地:
    git clone http://www.github.com/pjkundert/ezpwd-reed-solomon
    Subversion代码到本地:
    $ svn co --depth empty http://www.github.com/pjkundert/ezpwd-reed-solomon
    Checked out revision 1.
    $ cd repo
    $ svn up trunk
    
    solomon solomon版 1.7.2 reed-solomon solomon solomon/

    C++,Javascript和 python 程序的错误和擦除检测和修正。 基于Phil优秀karn实现(。由Linux内核使用),转换为 C++。

    提供了几个使用 reed solomon实现的C++ 和 Javascript。

    Javascript api是使用 emscripten 实现的C++ 实现,而且性能非常高。 所有的Javascript都可以通过MaxCDN在网站中。

    安装

    EZPWD reed solomon依赖:

    PackageFor描述?
    linux-libc-devBCH系统 linux/errno。h 文件

    性能

    编解码器的cyclone for性能通常是产品性能的关键行为,通常影响嵌入式应用的CPU选择。

    ezpwd::RS<...> 编解码器正在校正数据,以避免不必要的复制,使用具有兼容的大小和奇偶字段参数的RS。 在大小相关的Reed Solomon参数中使用 C++ 模板参数可以使编译器为所有内部 table 查找发出最佳代码,有时会显著提高性能。

    25 -75%比竞争的r 编解码器快

    菲尔code的EZPWD代码相比,reed solomon执行r的校正操作速度更快,速度大约为 Phil/ccsds的优化。 它的测试速度比 Shifra C++ 里德库的速度快 25%。 看起来,对于某些应用程序,EZPWD可以能是目前可以用的最快开源通用 C++ 库。

    可用

    源代码位于 https://github.com/pjkundert/ezpwd-reed-solomon。 它在 G++ ( 版本 4.8至 5.1 ) 和clang++下进行了大量测试,并启用了。 在 Hard咨询公司 (hardconsulting.com/products) 获取详细信息,并了解竞争地理编码以及为什么 EZCOD地理定位编码是必需的。

    C++ 生成只需要 header-源

    小心地实现为C++11标准 inline 代码,不需要任何 C++ 对象代码或者库生成过程。 因此,集成到现有的C++ 代码库和构建系统是非常简单的。

    由MaxCDN承载的

    生产弱化Javascript由MaxCDN提供,使用如下网址: https://cdn.rawgit.com/pjkundert/ezpwd-reed-solomon/v1.7.0/js/ezpwd/ezcod.js

    例如要在网站中使用EZCOD位置编码 API,请在你的网站模板的末尾添加这个,在你的application.js 之前:

    <scriptsrc="//cdn.rawgit.com/pjkundert/ezpwd-reed-solomon/v1.7.0/js/ezpwd/ezcod.js"></script>

    注意当前 <版本> 编码为=。"。"。/v <版本>/。"。"。"。

    应用程序可以永久访问 official EZPWD Javascript的任何当前版本或者历史版本,通过编码URL中的<版本> 号,可以在官方 Git repo 中找到标记:

    //cdn.rawgit.com/.../v<VERSION>/...

    使用Swig的 python-接口

    提供了一个高性能 python 2/3 接口,使用 Swig (。C++11支持至少需要 Swig 3.0.5版本)。 由于 python MODULE 是从 C++ 接口生成的,所以必须使用适当的目标操作系统。python 和 C++ 编译器实现生成和编译它。

    因此,没有可用的pip install ezpwd_reed_solomon 绑定;必须使用平台编译器的C++ 编译器,在目标平台上构建和安装它们,使用C++11支持。

    要构建并安装 ezpwd_reed_solomon 软件包,从 https://github.com/pjkundert/ezpwd-reed-solomon 获取源,并使用你希望支持的python ( 2或者 3 ) 版本构建:

    $ cd ezpwd-reed-solomon/swig/python
    $ python setup.py install

    或者:

    $ cd ezpwd-reed-solomon
    $ make swig-python

    目前,只有 ezpwd_reed_solomon.ezcod 可用;请参见 <href="ezcod: 位置代码 API"> EZCOD: python API细节的位置代码API部分。

    Swig 3.0.5 +

    要安装 python API,你需要一个现代的Swig。

    在Mac上,使用 Homebrew:

    $ brew install swig

    在 Linux Debian或者 Ubuntu Linux系统上,你应该能够使用如下( 其他Linux变种应该有类似的包安装设备):

    $ apt-get -u install autoconf autogen libpcre3-dev bison yodl
    $ git clone git@github.com:swig/swig.git
    $ cd swig
    $ autoconf
    $./autogen.sh
    $./configure && make && make install

    许可证

    所有ezpwd-reed-solomon代码均可以在GPLv3和商业许可证下使用。 在phil的代码中,原来的phil是 LGPL,所以我在 ezpwd-reed-solomon/c++/ezpwd/rs ( phil的一些改进和转化到 C++的使用) 中的reed实现可以在LGPL的术语下面。

    GPLv3+授权

    如果你的应用程序符合tmodel的条件,那么你可以使用基于EZPWD的,基于,的api。 软件的所有用户( 例如。 已经安装的应用程序) 或者"软件作为服务"( 例如。 网站必须能够访问所有的软件源代码,以便他们可以自由修改。重建和运行软件。 对底层GPLv3软件的任何修改( IE。 EZPWD ) 也必须提供。

    商业许可和定价

    如果你在产品中使用了任何基于 EZPWD reed的api,但你不希望使你的网站代码来源可用,那么从硬咨询公司 (hardconsulting.com) 获得的商业许可就可用。 价格崩溃如下( 在USD$中):

    ( 每月) usd$usd$/yr
    用户的avg。价格支撑点包含的应用程序帮助
    <1K025有趣的项目询问。: )?
    1K-1M100251 小时
    > 1M10002504 小时

    使用 EZCOD robust solomon的鲁棒地理编码 MODULE 是免费的,永远是免费的。 它可以用于,和,甚至可以在任何语言中自由实现,只要它保持兼容的( 包括簧片的误差修正,以及纬度和经度坐标的等效编码和解码)。

    请致电 +1 -780-970-8148或者在 info@hardconsulting.com 发送电子邮件讨论你的应用程序。

    增强功能

    phil的实现有几个增强功能。

    拒绝不可能的错误位置

    of版本允许r s 解码器计算和返回用于of的未使用部分的错误位置。 我们拒绝这些解决方案,因为它们提供了失败的指示。

    提供的数据和奇偶校验可能不能为给定的reed solomon编解码器使用全部潜在的码字大小。 例如,RS(31,29) 编解码器能解码包含最多 31个数据和奇偶符号的5-bit 符号码;在本例中,2个奇偶符号( 31 -29 == 2 )。

    如果我们提供( 说明) 9数据符号和 2奇偶校验符号,剩余容量的剩余 20符号将有效填充 reed solomon编码和解码操作的零。

    在码字中,如果解码了这样一个码字,而r的Galois域解出现错误,则拒绝码字,返回错误。

    共享数据表/不需要锁定

    而不是计算所有所需的数据表,每个 <容量的实例,*> 和相容的有限项参数共享一组。 此外,RS <容量。负载>/兼容Galias多项式参数的每个实例都共享特定于计算数目的奇偶校验符号的表。

    这些表的初始化本质上是线程安全的。

    ezpwd::RS <。 >: C++ reed solomon

    reed solomon编解码器的C++ 实现。 在 C++ header 文件中完全实现为 inline 代码。 高性能,在 C++ 和Javascript中。

    #include<ezpwd/rs>// Reed Solomon codec w/255 symbols, up to 251 data, 4 parity symbolsezpwd::RS<255,251> rs;
    std::vector<uint8_t> data;//.. . fill data with up to 251 bytes.. .rs.encode( data ); // Adds 4 Reed-Solomon parity symbols (255-251 == 4)//.. . later, after data is possibly corrupted.. .int fixed = rs.decode( data ); // Correct errors, anddata.resize( data.size() - rs.nroots() ); // Discard the 4 R-S parity symbols

    有关一些基本示例,请参见 rssimple.C

    构造 RS(SIZE,PAYLOAD) 实例

    当你决定n 位符号时,你如何决定和创建适合于你的数据负载的for编解码器( 编码器/解码器) 实例。

    选择你的r 码符号位大小,因此你的r 码 SIZE。 然后决定需要多少错误/缺失符号,以及所需的PARITY 符号数。

    现在你有了 SIZE,而 PAYLOADSIZE-PARITY

    finally,将数据分成大部分 LOAD ( 大小 <LOAD 块将被内置在内部,以便用 dbo/0 符号填充;你不需要提供精确的LOAD -sized块。) 块。

    例如对于 8-bit 符号,SIZE = 2 ^8-1 = 255,对于 PARITY的4符号,LOAD = 255 -4 = 251. ,solomon编解码器的符号是 RS(255,251),,这样一个r s 编解码器的C++ 声明是:

    ezpwd::RS<255,251> rs; // Up to 251 symbols data load; adds 4 symbols parity
    码字 SIZE 始终为 2 ^N-1

    例如 8-bit 符号始终使用 RS(255,255-PARITY) 编解码器。 对于 5-bit 符号(。或者,仅更正较大符号的底部 5位),你可以使用 RS(31,31-PARITY) 编解码器。

    码字 PARITY 可以从 1到 SIZE -1

    指定r 编码codec一个小的数据有效负载和剩余的r 等于 1符号,只需 1符号和剩余数据有效负载。

    使用/PARITY r的奇偶校验符号对数据进行压缩

    encoding方法可以将符号添加到 std::string 或者 std::vector<T> ( 其中 Tuint8_t 或者 uint16_t ) 容器中:

    std::string data( "Hello, world!" )
    rs.encode( data ); // Add the 4 R-S parity symbols to data

    另外,可以保持奇偶校验独立,而不干扰原始数据( 未调整容器大小):

    std::string data( "Hello, world!" );
    std::string parity;
    rs.encode( data, parity ); // resize and place rs.nroots() parity symbols

    或者,如果提供固定大小 std::array<size_t,T>,则它将假定奇偶校验的空间必须在末尾处已经存在:

    std::array<17,uint8_t> data(
     'H', 'e', 'l', 'l', 'o', ',', '', 'w', 'o', 'r', 'l', 'd', '!', // 13'x', 'x', 'x', 'x' ); // 4rs.encode( data ); // Place the 4 R-S parity symbols at end of data

    或者,将 uint8_t 或者 uint16_t 迭代器的对传递到所需的任何容器或者缓冲区中:

    std::vector<uint8_t> data( 255 );// Fill data with 251 bytes of payload, eg:for ( uint8_t i = 0; i <251; ++i )
     data[i] = i;// Append 4 symbols of R-S parity, using pairs of iteratorsrs.encode( std::make_pair( data.cbegin(), data.cbegin() + 251 ),
     std::make_pair( data.begin() + 251, data.begin() + 255 ))

    解码数据w/corrupt/丢失符号

    一旦接收到数据 payload+parity,它可能包含未知错误符号( 名名"错误"),或者已知丢失符号( 名名"删除")。 删除更容易纠正( 因为我们知道他们的位置),它们只使用一个r的奇偶校验符号来纠正。 但是,未知错误在位置和值中丢失,所以他们每次都消耗 2 r 奇偶符号。

    如果r s 算法能够纠正任何错误和抹除,并恢复有效的r s"码字",则会报告正值:

    int correct = rs.decode( data );if ( correct> = 0 )
     std::cout <<"Recovered data w/" <<correct <<" errors" <<std::endlelse std::cout <<"Failed to recover data; " <<rs <<" overwhelmed" <<std::endl;

    如果需要,可以通过擦除位置,并获得恢复错误位置( 记住报告的erasures 符号可以能不正确,因这里可以能不会在 position 中报告): !

    std::vector<int> erasures = { 1 }; // Report second symbol missingstd::vector<int> position; // And get back corrected symbols hereint correct = rs.decode( data, erasures, &position );

    丢弃 PARITY r的奇偶校验符号

    rs.encode() 添加符号到可以调整的std::string 或者 std::vector<T> 容器的所有情况下,你的职责是在 rs.decode() 完成后删除它们。 rs.nroots() 方法报告奇偶校验符号的数目。

    基于的BCH误差修正

    实现用于BCH纠错编码和解码的Linux内核 API。 感谢 Ivan Djelic为提供了这里支持,在下

    ::。ezpwd: BCH BCH BCH

    在许多方面,C++ 实现与 ezpwd::RS <类似。 提供>。有 3个类(。ezpwd::bch_baseezpwd::bch<...>ezpwd::bch<...> ),但推荐的是 ezpwd::bch<...>

    根据所需码字大小,负载和位误差修正容量( 如果没有可用的MATCH BCH编解码器,构造函数将引发异常) 创建一个BCH编解码器:

    #include <ezpwd/bch>
    ezpwd::BCH<255,239,2> bch_codec;//By Codeword, Payload and Correction capacities, exactly

    在uint8_t的容器中进行编码:

    std::vector<uint8_t> codeword = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF }//8 data
    bch_codec.encode( codeword )//+ 2 parity added

    解码( 和更正错误)

    int corrections = bch_codec.decode( codeword );
    assert( corrections> 0 );//fail if BCH decode failed
    codeword.resize( codeword.size() - bch_codec.ecc_bytes() );//discard parity

    encodeddecoded 方法返回uint8_t的std::string 或者 vector=/=array 容器的副本,可以选择使用填充的错误位置的std::vector<int>encoded 添加奇偶校验;decoded 更正错误,可以选择填充位置。

    增强某些原始数据w/inetd奇偶:

    std::vector<uint8_t> data = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF }//8 data
    std::vector<uint8_t> codeword = bch_codec.encoded( data );//8 data + 2 parity

    向奇偶校验增强的BCH码引入一个错误,并确保恢复的错误位置 MATCHES的预期数目和所引入错误的位置:

    std::vector<uint8_t> erroneous = codeword;
    erroneous[1] ^= 1<<3;//introduce an error in the 4rd bit of the 2nd byte; the 12th bit (bit index 11)
    std::vector<int> positions;
    std::vector<uint8_t> corrected = bch_codec.decoded( erroneous, positions );
    assert( corrected == codeword && positions.size() == 1 && positions[0] == 11 );

    经典Djelic内核 API

    stock内核C 保留原样,并在 ezpwd:: C++ 命名空间中提供。 初始化BCH编解码器:

    #include<ezpwd/bch_base>// Allocate a BCH codec w/2^8-1 == 255 bit codeword size, and 2 bits of correction capacity.// This results in a BCH( 255, 239, 2) codec: 255-bit codeword, 239-bit data payload capacity,// hence 255-239 == 16 bits of parity.ezpwd::bch_control *bch = ezpwd::init_bch( 8, 2, 0 );

    运行 bch_test 以查看所有可用的BCH编解码器。

    在现有消息末尾的编码奇偶校验位执行如下操作:

    std::array<uint8_t,10> codeword= {
     0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, // data0, 0 }; // parity, initialized to 0unsignedint len = 8;uint8_t *data = &codeword[0];uint8_t *parity = &codeword[len];ezpwd::encode_bch( bch, data, len, parity );

    使用接收错误位置并将更正应用于所提供数据的便捷API进行解码和更正:

    int corrections = correct_bch( bch, data, len, parity );

    当然,: 内核API是可以用的;它不正确地执行,而调用者必须在API检测到的错误位置执行位错误。

    unsignedint errloc[2]; // must be at least bch->t in sizeint corrections = decode_bch( bch, data, len, parity, 0, 0, errloc );for ( int n = 0; n <corrections; ++n )
     if ( errloc[n] <8*len )
     data[errloc[n]/8] ^= 1 <<(errloc[n] % 8);

    有关一些基本示例,请参见 bchsimple.Cbch_test.C,并在真实协议中提供更高级实现的bch_itron.C

    RSKEY: 数据关键 API

    要求用户可靠地输入几个字节的数据( 例如。 一个产品密钥或者赎回码,基本上是不可能的。 有人认为,有人能够完美地读取和输入一个随机的字母和数字,这是不合理的,它有 100%个可靠性。

    导入 js/ezpwd/rskey.js 在应用程序中使用RSKEY错误纠正二进制数据输入令牌。 原始二进制数据( 在Javascript字符串或者ArrayBuffer中) 可以编码到RSKEY中供用户稍后输入。 使用内置奇偶校验( 额外验证) 符号,可以检测到任何错误或者丢失的符号,并可能恢复。 可以通过高度确定的高度确定验证为正确的RSKEY,它与剩余的剩余奇偶校验符号数目成比例。

    Javascript库:js/ezpwd/rskey.js

    rskey_<PARITY>_encode( <bytes>, data, [ sep ] ) -- encode data to RSKEY
    rskey_<PARITY>_decode( <bytes>, key ) -- decode RSKEY 

    支持 2 -5奇偶校验,当 base-32 编码时,最大容量为 base-32 编码数据( 原始数据由因子扩展( <字节> * 8 + 4 )/5的最大容量:。 使用奇偶校验 2,最大容量为 18字节;具有奇偶校验 5,16字节。

    data 可能是字节长度 <= <bytes>的ArrayBuffer。 如果提供了字符串,则可以是以'0.。'开头的十六进制字符串( 所有后续的十六进制数字;。 否则,将字符串解码为 UTF-8 ( 当然,这意味着你不能提供以'0x'。)。

    可选 sep 参数( 默认 5 ) 是将RSKEY分隔为的群集大小;0指定无分隔符。

    将 rskey.js Javascript加载到项目中:

    <scriptsrc="//cdn.rawgit.com/pjkundert/ezpwd-reed-solomon/v1.7.0/js/ezpwd/rskey.js"></script>

    使用rskey的API将数据编码成易于阅读的键。 调用 rskey_<PARITY>_encode API ( 具有奇偶校验 2 -5 ),指定在rskey负载中编码的数据的字节数,并提供一些数据来编码( 作为十六进制字符串"0x3344."。"。"。或者作为 UTF-8 字符串):

    >rskey_5_encode( 12, "Mag.1ckπ" );"9MGNE-BHHCD-MVY00-00000-MVRFN"

    稍后,可以解码- 即使用户添加了错误或者两个('',below ),或者跳过了一些符号( 如果某些不可读,如'_',或者最后几个还没有输入)。 每个错误消耗 2个奇偶校验符号,每个擦除或者遗漏符号使用 1,因此 1个错误+ 2删除结果保留了 20%个奇偶校验结果:

    >rskey_5_decode( 12, "9MGNE-BHHCD-MVY00-00000-MVRFN" )
    {confidence:100, data:ArrayBuffer, utf8:"Mag.1ckπ", hex:"0x4D61672E31636BCF80000000"}>rskey_5_decode( 12, "9MGNE-BHHCD-MVY00-00X00-MVR" ) // 1 error, 2 not yet entered{confidence:20, data:ArrayBuffer, utf8:"Mag.1ckπ", hex:"0x4D61672E31636BCF80000000"}>rskey_5_decode( 12, "9_GNE-BHH_D-MVY00-00X00-MVRFN" ) // 1 error, 2 unreadable w/'_'{confidence:20, data:ArrayBuffer, utf8:"Mag.1ckπ", hex:"0x4D61672E31636BCF80000000"}

    如果你有原始数字数据( 例如。 记录 id,数据HMACs等,使用ArrayBuffer接口。 你可以提供任何类型的原始数据,直到 RSKEY ( 12字节,在本例中)的容量。 然后,即使在入口中引入错误,如果奇偶校验足够,则返回的. data 属性将为 ArrayBuffer。

    > ia =newInt32Array([0x31323334, 0x41424344, 0x51525354])
    [825373492, 1094861636, 1364349780]>rskey_5_encode( 12, ia.buffer ) // raw capacity is 12 bytes, w/5 parity"6GRK4-CA48D-142M2-KA98G-V2MYP"> dec=rskey_5_decode( 12, "6GRK4-CA48D-142M2-KA98G-V2XXP" ) // XX are errors{confidence:20, data:ArrayBuffer, utf8:"4321DCBATSRQ", hex:"0x343332314443424154535251"}>newInt32Array( dec.data ) // recover original data[825373492, 1094861636, 1364349780]

    RSKEY演示: http://rskey.hardconsulting.com

    尝试更改奇偶校验,数据大小和数据。 尝试通过输入一些_ ( 指示缺少/无效符号) 来更改密钥。 我们可以用 reed solomon术语来消除这些,而且我们可以用每个奇偶校验符号来恢复一次擦除。 尝试将一些键值更改为不正确值。 这些 reed solomon错误每个需要 2个奇偶校验符号来检测和纠正。

    你还可以访问控制台(。右键单击,选择Inspect元素,单击"控制台"),并输入 上面 rskey_。 API示例代码。

    示例 node.js: 加密的礼品卡代码

    假设你有一个在线小部件业务,并生成礼品卡。 年度平均约 5000个独立访问者/月份,在圣诞节周围有 25000个峰值。 你想让你的礼品卡赎回更加可靠和安全,而且 LESS 对于你的客户来说是痛苦的。

    你的RSKEY许可以证成本将为 $100,加上 $25个/yr 支持订阅,你可以与支持开发人员一起使用 js/ezpwd/rskey.js API。

    你决定把每个礼品卡与买家( 所以你和礼品卡赠送者可以知道什么时候兑换卡)的账户联系起来。 因此,每个礼品卡RSKEY需要包含:

    • 32位 客户标识
    • 32位 礼品卡 ID

    我们使用RSKEY编码 8字节数据,具有 3个奇偶校验符号,可以防止 1个错误或者 2个清除符号,并保留 1个奇偶校验符号,以便验证。

    参见 rskey_node.js的示例代码( 在客户端网站和 node.js 服务器之间的通信和服务器作为练习)。

    客户端网站RSKEY实现

    在客户端网站上,你可以使用以下内容:

    <script
     src="//cdn.rawgit.com/pjkundert/ezpwd-reed-solomon/v1.7.0/js/ezpwd/rskey.js"></script><script>var client = {
     //// card_key_encode( card ) -- encrypt card's IDs on the server, return RSKEY// card_key_decode( key ) -- recover RSKEY, decrypt IDs on server, return card//// These are run in the browser, and expect to call server methods that// run under Node.js back on the server. For this demo, we'll all just run// here in Node.js...//card_key_encode:function( card ) {
     // Get the server to encrypt the card IDsserver.card_keydata_encode( card );
     // Produce the RSKEY from the card's keydata w/Uint8Array's ArrayBuffercard.key=rskey_3_encode( 8, newUint8Array( card.keydata ).buffer, 4 );
     returncard.key;
     },
     card_key_decode:function( key ) {
     // Decode the ASCII key; will raise an Exception if decode failsvar keyinfo =rskey_3_decode( 8, key );
     // Convert ArrayBuffer (as Uint8Array) to plain javascript Arrayvar keyuint8 =newUint8Array( keyinfo.data );
     var keydata =Array( 8 );
     for ( var i =0; i <8; ++i )
     keydata[i] = keyuint8[i];
     // Get the server to decrypt the card.keydata, return the card IDsreturnserver.card_keydata_decode({ keydata: keydata });
     }
    }// Your first customer ever, buys his first gift card!card = {
     id:0,
     customer: { id:0 },
    }// Encode the card IDs to RSKEYcard_key =client.card_key_encode( card );// ==> {// customer: { id: 0 },// id: 0,// keydata: [ 185, 124, 29, 95, 168, 45, 159, 113 ],// key: 'P5X1-TPW8-5NFP-2M7G'// }////"P5X1-TPW8-5NFP-2M7G" is printed/emailed on gift card//

    随后,礼卡收件人回到网站并输入礼卡密钥,输入一些符号,并使用 lowercase 和备用空格( base-32 编码处理 Z/z/2, S/s/5, I/i/1 和 O/o/0 替换( 这些符号在 EZPWD base-32 中是等价的) ;

    // Decode the customer-entered data using the same RSKEY parameters:// error: v// equivalents: v v v v// original:"P5X1-TPW8-5NFP-2M7G"card_dec =client.card_key_decode( "psxi tpv8 snfp zm7g" );// ==> {// keydata: [ 185, 124, 29, 95, 168, 45, 159, 113 ],// customer: { id: 0 },// id: 0// }//// This is gift card ID 0, purchased by our very first customer ID 0! Find out// what that gift card is still worth, and apply it to the order...//

    服务器 node.js-加密实现

    所有加密都应该在服务器上进行,使用密钥对称加密密钥( 不应该存储在 repo 文件中)。 使用其他安全密钥存储,或者已经存在于服务器上的现有密钥材料。 使用加密所有 64位作为 block ( 如 blowfish )的适当密码在服务器上加密。

    /* * rskey_node.js -- Demonstrate use of rskey in Node.js application *  * Node.js"crypto" uses the Buffer type to manipulate binary data. The * rskey library uses ArrayBuffer, because it is intended to be used in both * Node.js and Browser Javascript applications. *  * The server will expect an Object containing (at least) card.id and * card.customer.id, and produce/consume card.keydata. * */var crypto =require( "crypto" );var crypto_algo ='blowfish'; // 64-bit block ciphervar crypto_secret ='not.here'; // Super secret master key; don't keep in Git...var server = {
     //// card_keydata_encode -- Encipher card IDs into card.keydata Array// card_keydata_decode -- Decipher card IDs from card.keydata Array//// Run these on your server (of course, keeping crypto_secret... secret.)//card_keydata_encode:function( card ) {
     // Create Buffer containing raw card ID datavar buf =newBuffer( 8 );
     buf.writeUInt32LE( card.customer.id, 0 );
     buf.writeUInt32LE( card.id, 4 );
     // Encrypt the Buffer of keydatavar encipher =crypto.createCipher( crypto_algo, crypto_secret );
     encipher.setAutoPadding( false ); // must use exact 64-bit blocksvar enc =Buffer.concat([ 
     encipher.update( buf ),
     encipher.final()
     ]);
     // Return card w/encrypted IDs as plain Javascript Array in. keydatacard.keydata=enc.toJSON().data; // {type: 'Buffer', data: [1,2,...]}return card;
     },
     card_keydata_decode:function( card ) {
     if ( card.keydata.length!=8 )
     throw"Expected 8 bytes of card.keydata, got: "+card.keydata.length;
     // Decrypt the Buffer of keydatavar decipher =crypto.createDecipher( crypto_algo, crypto_secret );
     decipher.setAutoPadding( false ); // must use exact 64-bit blocksvar dec =Buffer.concat([
     decipher.update( newBuffer( card.keydata )),
     decipher.final()
     ]);
     // Recover raw card IDs from Bufferif ( card.customer==undefined )
     card.customer= {};
     card.customer.id=dec.readUInt32LE( 0 );
     card.id=dec.readUInt32LE( 4 );
     return card;
     }
    };

    假设攻击者没有访问服务器用来加密单个 64位 block 中的客户和卡id的加密密钥,那么生成和接受的伪密钥的概率就很小。

    假设他们确实知道你使用的是 EZPWD,因这里总是提供有效的r 字码的RSKEYs。 这里外,假设你拥有很多客户(> 2亿),因这里你的32位 客户with可能会意外地为一个有效的> 50% MATCH。

    解密的客户和卡ID必须是正确的- MATCH 是一个有效的客户和卡标识。 由于每个客户不可以能生成多个礼卡,32位 卡is将意外解密到任何给定值 1/2^32 ( 1 in ~4 )。 组合 64位 RSKEY ( 记住: 所有数据必须使用 block 密码加密,指示有效值的填充 array ;给定范围( 0,2 ^64],只有每个 4-billionth 值都会有效( 比实际情况下的LESS 大多数) ) 中的数字。

    因此,攻击者必须生成并尝试超过 2个有效的RSKEYs,因为他们有可能在一个有效的礼品卡上遇到一个错误,给出了 上面的假设。 即使你没有限制你的卡补偿 API,你也许会注意到你的服务器已经满足礼卡补偿请求。 假设服务器每秒处理 1000次支付,那么攻击者 23天的第2 天就有机会找到他的第一个有效密钥。 因此,我推荐速率限制你的礼物卡赎回API每秒 10请求,增加了 6年的时间。

    因这里,使用RSKEY和简单编码方案提供了一种有效。健壮。安全的礼卡代码生成方法。

    由于mis类型代码的增加,客户增加了,增加了返回访问和正确评审的可以能性。

    EZCOD: 位置代码 API

    为了在地球表面指定某些东西的位置,通常使用纬度和经度对。 要在+/-3m中进行,需要至少 5位精度的经纬度对,在小数点之后至少需要位精度。

    因此,要指定我女儿Amarissa的出生位置,我可以写下坐标:

    53.655832,-113.625433

    这比编写等效的EZCOD更长,更容易出错:

    R3U 1JU QUY.0

    如果位于纬度或者经度坐标中的数字错误,则所引入的错误量将从几厘米到多公里:

    53.655832,-113.62543X == centimeters error
    53.655832,-1X3.625433 == many kilometers error

    默认情况下,EZCOD使用错误/擦除更正来更正多达 1个已知的丢失( 已经删除) 符号,使用 GREATER 擦除/错误检测和纠正可以选择可用的。

    Javascript库:js/ezpwd/ezcod.js:

    ezcod_3_10_encode( lat, lon, [ symbols ] ) -- encode location to EZCOD
    ezcod_3_10_decode( ezcod ) -- decode EZCOD to position

    提供了三种变体:

    • ezcod_3_10_... - 1奇偶校验符号
    • ezcod_3_11_... - 2奇偶校验符号
    • ezcod_3_12_... - 3奇偶校验符号

    将 ezcod.js Javascript加载到项目中:

    <scriptsrc="//cdn.rawgit.com/pjkundert/ezpwd-reed-solomon/v1.7.0/js/ezpwd/ezcod.js"></script>

    将Taj穹顶的位置编码为 3m 精度(。9位位置符号,默认值) 和 20mm 精度( 12符号),以及 3奇偶校验符号( 5-nines 可信度):

    >ezcod_3_12_encode( 27.175036985, 78.042124565 ) // default: 3m (9 symbols)"MMF BBF GC1.2U2">ezcod_3_12_encode( 27.175036985, 78.042124565, 12 ) // 20mm (12 symbols)"MMF BBF GC1 A16.1VD"

    之后,如果输入 EZCOD,错误和擦除将透明更正,直到 reed solomon编码奇偶校验的容量达到:

    >ezcod_3_12_decode( "MMF BBF GC1 A16.1VD" )Object {confidence:100, latitude:27.17503683641553, longitude:78.04212455637753,
     accuracy:0.020401379521588606}>ezcod_3_12_decode( "MMF BBF GC1 A16.1" ) // missing some parityObject {confidence:34, latitude:27.17503683641553, longitude:78.04212455637753,
     accuracy:0.020401379521588606}>ezcod_3_12_decode( "mmf-bbf-Xc1-a16.1vd" ) // An errorObject {confidence:34, latitude:27.17503683641553, longitude:78.04212455637753,
     accuracy:0.020401379521588606}

    ezcod.com 试试。 switch 到"EZCOD 3: 12",并输入"mmf-bbf-xc1-a16.1vd"作为 EZCOD。 你将看到计算精度 20.4毫米,并观察'x'( 错误) 被修正为"g"。 ( 网站默认为 9位精度,因这里它将重新编码位置,丢弃额外的精度。)

    异步加载

    emscripten生成的代码必须在调用它之前初始化它的运行时间。 如果通常获得Javascript资源,它们将异步加载,但是按照你加载的顺序运行,以便在applivation运行时安全初始化。

    如果加载它的他Javascript库和 application.js,,并且异步加载 ezcod.js,必须确保它们不使用任何is库( 如 ezcod.js )。 基于我们的基于 <script onload...>的库是完全自我包含的,所以你可以使用信号来触发 on( 'ready',.. . ) 事件无论 jquery.min.js 或者 ezcod.js 是否先加载,这里代码都将确保你的app.json( 'ready',.. . ) 事件在 ezcod.js 初始化它的Emscripten运行时之前不会触发:

    <scripttype="text/javascript">// Bindings for Emscripten initialization detection.varjquery_release=function() {console.log( "Emscripten run-time initialized before jQuery loaded" );jquery_loaded=function() {}; // nothing left to do after jquery loads };varjquery_loaded=function() {console.log( "Emscripten run-time initialize blocking jQuery..." );$.holdReady(true); // force delay of jQuery.on( 'ready',.. .jquery_release=function() {console.log( "Emscripten run-time initialized; jQuery released" );$.holdReady(false); //.. . 'til Emscripten runtime initialized }; };</script>
    <scriptasynconload="jquery_release()"src="//cdn.rawgit.com/pjkundert/ezpwd-reed-solomon/v1.7.0/js/ezpwd/ezcod.js"></script>
    <scriptdeferonload="jquery_loaded()"src="//ajax.googleapis.com/ajax/libs/jquery/2.1.3/jquery.min.js"></script>
    <scriptdefersrc="js/app.js"></script>

    健壮性

    初始 9之后的所有符号都是 reed solomon代码符号。 每个r的符号可以恢复一个已知的擦除;每两个r的符号可以检测并纠正一个错误的符号。 如果任何r 符号的所有除法和错误都不使用,则整个序列可以确认为r s"码字",确保

    P(1-1/2^(5*excess))

    例如如果剩余一个r 符号,则EZCOD正确的概率是:

    P(1-1/2^5) ==. 969

    如果存在两个多余的r 符号,则概率上升到:

    P(1-1/2^10) == P(1-1/1024) == 0.999

    使用 3,它是:

    P(1-1/2^15) == P(1-1/32768) == 0.99997

    如果需要非常健壮的位置,请在传输准确的位置信息时选择一个带有奇偶校验符号的EZCOD,即使必须将它的写下来。背诵或者输入。

    精度

    要确定在+/- 10英尺( 3m ) 中的位置,很简单: 在 4,194部分中,必须指定纬度( -90,90 ) 到 1,304,( 2 ^23 ),608.

    默认 10-symbol EZCOD传输 22位的经度和 23位的位置数据(。10th 是奇偶校验符号)的9符号的经度。 EZCOD API可以编码位置数据( 29位纬度和 31位经度)的最多 12个符号,产生+/- 20毫米的最大精度能力。

    地球赤道的周长为 ~40,075,000m,,垂直和水平方向的每个部分都是 40,075,000/8,388,608,== 4.777. 如果可以指定垂直和水平 direction 中的长度等于一个部分的rectangle,则在赤道上有 4.777 m。 如果我们知道某些地理坐标的位置,它最多是( 2 * ( 4.777/2 ) ) ^2 ) == 3.378距离平方的中心。

    当你走北或者南时,经度线的周长减小,随着绝对纬度的增加。 地球的平均半径是 ~6,371,000m.。 在 53度北,沿着一条固定纬度的地球的周长是:

    2 * pi * radius * cos( Latitude )
    2 * 3.1415926534 * 6,371,000m * 0.60181502315
    24,090,760m

    因此,垂直轴的每个部分仍为 4.777米,但每个水平部分为:

    24,090,760/8,388,608 == 2.872m.

    现在,每个 rectangle 中的点最多是:

    sqrt( (4.777/2)^2 + (2.872/2)^2 ) == 2.787m

    距离 rectangle 中心的距离。

    因此,对于位置数据,在赤道处精度为 worst/- 编码,encoding encoding,LESS/-3m,平均误差为/。

    EZCOD演示: http://ezcod.com

    要查看实际的EZCOD,请访问 ezcod.com。 尝试输入:

    R3U 1JU QUY.0

    来看看我女儿Amarissa的出生位置。

    你还可以访问控制台(。右键单击,选择Inspect元素,单击"控制台"),并输入 上面 rskey_。 API示例代码。

    EZCOD REST API 演示

    可以使用 EZCOD/http://localhost:8000 安装 python ezpwd_reed_solomon MODULE,在 上提供像 ezcod.com 这样的自承载网站,并运行服务器。 在Mac上,这里过程的完整过程为:

    $ git clone https://github.com/pjkundert/ezpwd-reed-solomon.git
    $ brew install swig
    $ make -C ezpwd-reed-solomon/swig/python install
    $ pip install web.py
    $ cd ezpwd-reed-solomon/examples/ezcod_api
    $./server.py --prefix api --bind localhost:8000
    ArgumentDescription
    --bind <iface>:<port>将web服务器绑定到给定的接口和端口
    --analytics <id>使用给定的ID发出 Google Analytics 代码
    --prefix <path>在URL处承载 REST API: <路径>/<版本>
    --log <ffile>将日志放入给定文件

    REST API URL始终包含版本 v#.#.# ;对于 上面 命令,该API位于以下位置: http://localhost:8000/api/v1.7.0.若要获取EZCOD的详细信息,请将请求编码为EZCOD作为查询选项。 例如使用浏览器访问这里网页: http://localhost:8000/api/v1.7.0ezcod=r3u08mpvt。d 这将把解码后的数据返回为 HTML。 要以JSON形式获取它,请将 .json 附加到API请求路径: http://localhost:8000/api/v1.7.0.json。ezcod=r3u08mpvt。

    这里演示应用程序支持获取查询选项和POST变量( 或者 body 格式的窗体 {...} 或者 [{...},...],具有对象属性) 匹配:

    KeywordDescription
    ezcod一个 EZCOD 3 :10/11/12
    latlon作为字符串的"纬度,经度"对
    latitude纬度的地理纬度
    longitude经度的经度经度
    precision地理定位数据的符号数
    PARITY所需的EZCOD奇偶校验符号数

    例如要使用 wget 获取EZCOD的详细信息,请执行以下操作:

    $ wget -S --header='Content-Type: application/json' 
     -qO - --post-data '{"ezcod":"r3u08mpvt.d","parity":3}' 
     http://localhost:8000/api/v1.7.0
    HTTP/1.1 200 OK
     Cache-Control: no-cache
     Content-Type: application/json
     Transfer-Encoding: chunked
     Date: Wed, 03 May 2017 12:31:38 GMT
     Server: localhost
    {
    "accuracy": 0.0,
    "certainty": 1.0,
    "confidence": 100,
    "ezcod":"R3U 08M PVT.JKG",
    "latitude": 53.55553865432739,
    "latitude_error": 0.0,
    "longitude": -113.87387037277222,
    "longitude_error": 0.0,
    "precision": 9
    }

    你可以提供单个对象,也可以提供列表:

    ... --post-data '[{"ezcod":"r3u08mpvt.d"},{"latlon:""53.5,-113.8"}'
    python 库:ezpwd_reed_solomon

    python ezpwd_reed_solomon 软件包当前包含一个 ezcod 子模块和一个BCH子模块。 尽管完全功能,它们设计为简单易于扩展,如果你的iseries编解码器或者地理编码是唯一的。

    将新的EZCOD或者BCH添加到 python 绑定是非常简单的。 只需编辑 swig/python/ezcod/ezcod.i ( 或者 .../BCH/BCH.i ) 文件,然后安装 python 绑定。

    例如要添加名为 ezcod.ezcod_20mm_15 ( 20mm 位符号+ 位编码符号+ 精度在 3个奇偶校验符号中)的新绑定类,请将以下内容添加到 ezcod.i的底部:

    %template(ezcod_20mm_15) ezpwd::ezcod<3,12>;

    ezpwd_reed_solomon.BCH

    BCH MODULE 提供了几个BCH编解码器类。 目前,所有都是使用djelic的实现实现的,直接来自Linux内核。

    基本 API ( 在 bch_base 中提供) 按照有限域顺序'm'( 从 5 -9 ) 和位误差修正容量't'来指定。 with编解码器提供具有指定容量的( 如果可能的话)。 is码大小为 2 ^m-1,实现位错误修正容量't'需要的ECC位数。 因此,可以使用以下方法计算负载容量的结果 codec 数据:

    2 ** m - 1 - codec.ecc_bits()
    ClassDescription
    bch_base通过指定M 获得一个BCH编解码器
    ( Galois顺序;码字大小 == 2 ^M-1 ) 和
    T ( 位误差修正能力)
    bch_255_<T>指定预先定义的码字大小
    bch_255_1( 2^M-1 ) 和位错误容量T
    bch_255_2
    bch_255_3
    bch_255_4
    bch_255_5
    bch_255_6
    bch_255_7
    bch_255_8
    BCH_255_<PAYLOAD>-<T>特定的BCH编解码器,完全指定
    BCH_255_191_8码字。负载和T 位误差容量
    BCH_255_199_7
    BCH_255_207_6
    BCH_255_215_5
    BCH_255_223_4
    BCH_255_231_3
    BCH_255_239_2
    BCH_255_247_1

    在未来,BCH.BCH_.。 可以使用 C++ 模板实现版本,以提供由于内部表的预定大小而提供的优化。 因此,建议使用固定 bch_。 如果可能,使用版本。

    所有编解码器提供程序:

    MethodDescription
    t()位误差修正能力
    ecc_bits()BCH奇偶校验位的数目
    ecc_bytes()BCH奇偶校验字节的数目
    encoded()返回BCH编码数据,附加了/ECC字节
    decoded()返回BCH解码和修正的数据( 不丢弃ECC字节)

    下面是一些示例代码,演示了 ezpwd_reed_solomon.BCH 模块的一些简单用例:

    from ezpwd_reed_solomon import BCH
    def flip( data, bit ):
     if isinstance( data, str ):
     return data[:bit//8] + chr( ord( data[bit//8] ) ^ 1 <<bit % 8) + data[bit//8 + 1:]
     elif isinstance( data, tuple ):
     return data[:bit//8] + (data[bit//8] ^ 1 <<bit % 8,) + data[bit//8 + 1:]
     elif isinstance( data, list ):
     return data[:bit//8] + [data[bit//8] ^ 1 <<bit % 8,] + data[bit//8 + 1:]
     raise RuntimeError("Unhandled sequence: %r" % data )
    flexi16 = BCH.bch_base( 8, 2 )
    ori = 'abc'
    enc = flexi16.encoded( ori )
    # Add some bit-errors
    err = flip( enc, 14 )
    err = flip( err, 7 )
    #err = flip( err, 21 ) # over bit-error correction capacity
    # Decode and test
    dec = flexi16.decoded( err )
    assert dec[:3] == ori
    # The error positions can be returned; a special BCH.error_position container type
    # must be used (due to the vagaries of the Swig-generated Python wrapper).
    data = [0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF]
    codeword = flexi16.encoded( data )
    erroneous = list( codeword )
    erroneous[1] ^= 1 <<3 # introduce an error in the 4rd bit of the 2nd byte; 12th bit (bit index 11)
    positions = BCH.error_position()
    corrected = flexi16.decoded( erroneous, positions )
    assert corrected == codeword and len( positions ) == 1 and positions[0] == 11, 
    "'codeword: %r'n'erroneous: %r'n'corrected: %r'n'positions: %r'" % (
     codeword, erroneous, corrected, list( positions ))
    "'codeword: %r'n'erroneous: %r'n'corrected: %r'n'positions: %r'" % (
     codeword, erroneous, corrected, list( positions ))
    'codeword: (1, 35, 69, 103, 137, 171, 205, 239, 203, 187)'
    'erroneous: [1, 43, 69, 103, 137, 171, 205, 239, 203, 187]'
    'corrected: (1, 35, 69, 103, 137, 171, 205, 239, 203, 187)'
    'positions: [11]'

    ezpwd_reed_solomon.ezcod

    类提供了默认情况下生成三种EZCOD变体的方法: 3m ( 9符号) 定位精度,加上 1,2或者 3簧片奇偶校验符号。 它们分别命名为 ezcod_3_10ezcod_3_11ezcod_3_12,指示默认的3m 个精度和符号总数。

    $ python
    >>> from ezpwd_reed_solomon import ezcod

    API支持以下类,方法和属性:

    ezcod_3_{10,11,12}("<EZCOD>"|[lat,[lon,...]])

    创建一个包含指定地理位置( 默认为纬度 0.0,经度 0.0,'的<ezcod> 实例。'分隔符和区块 3 )。 如果提供了字符串,则将它的解码为( 如果可能,则在提供的EZCOD无效时引发异常)。

    >>> EZCOD = ezcod.ezcod_3_12( 53.5, -113.8 )
    >>> print repr( EZCOD )
    <R3U 06B MJ3.JXR (100%) == +53.5000000000, -113.8000000000 +/- 0.00mm>

    ezcod_3_{10,11,12}.encode([precision])

    将当前 ezcod_3_{10,11,12}.latitude.longitude 编码为给定数量的精度符号( 默认值: 9,或者 3 m )。 精度可能是从 1到 12 ( 20mm 精度) 符号的任何地方。

    >>> print EZCOD.encode( 12 )
    R3U 06B MJ3 EDD.K56

    ezcod_3_{10,11,12}.decode("<EZCOD>")

    ezcod_3_{10,11,12}的任何变体都可以用预期的数量( 或者更多) 奇偶解码一个有效的EZCOD,只要它包含'。'或者''。

    返回的百分比可以确定- 预期的r 奇偶符号的比例在错误检测和修正之后仍未使用。 值 0表示ezcod的解码没有失败,但是没有任何奇偶符号保持过多,以验证它的有效性。

    >>> print EZCOD.decode("r3u 06b mj3 edd.k56" )
    100
    >>> EZCOD.latitude
    53.49999999627471
    >>> print EZCOD.decode("r3u O6b m_3 edd.k56" )
    67
    >>> print EZCOD.decode("r3u O6b mX3 edd.k56" )
    34
    >>> print repr( EZCOD )
    <R3U 06B MJ3.JXR ( 34%) == +53.4999999963, -113.8000000734 +/- 19.4mm>
    >>>

    如果任何符号未知,则用 _ 或者 ? 替换它们,以表明它们是删除的( 并且只使用一个r的奇偶符号来纠正)。 任何被r 编码解码器纠正的错误错误符号都会消耗 2个奇偶校验符号。 解码(。错误或者删除过多) 失败将引发 RuntimeError 异常:

    >>> EZCOD.decode("r3u 06b mj3 __d.__6" )
    Traceback (most recent call last):
     File"<stdin>", line 1, in <module>
    . . .
    RuntimeError: ezpwd::ezcod::decode: Error correction failed; too many erasures
    >>> EZCOD.decode("r3u 06b mj3 eXd.__6" )
    Traceback (most recent call last):
     File"<stdin>", line 1, in <module>
    . . .
    RuntimeError: ezpwd::ezcod::decode: Error correction failed; R-S decode failed

    如果EZCOD编码解码器需要较少的r 校验符号( 例如。 EZCOD: 编解码器用于对具有更多奇偶校验的EZCOD进行解码( 例如。 一个 EZCOD 3: 12码w/3奇偶码,它只能用短编码器的"强度"解码。

    For的错误,但它只使用了一个r的奇偶校验符号,因此只使用了一个r的奇偶校验符号,因此只能正确地纠正 3字节的擦除。 此外,它只能够提供 1-nines的正确性( 1-1/32 == P(.96875) )

    >>> ezcod.ezcod_3_12().decode("r3u 06b mj3 edd.k56")
    100
    >>> ezcod.ezcod_3_10().decode("r3u 06b mj3 edd.k56")
    100
    >>> ezcod.ezcod_3_12().decode("r3u 06b mj3 ed_.k56") # even though 3 parity available
    67
    >>> ezcod.ezcod_3_10().decode("r3u 06b mj3 ed_.k56") # all codec parity capacity used!
    0
    >>> ezcod.ezcod_3_12().decode("r3u 06b mj3 e__.k56")
    34
    >>> ezcod.ezcod_3_10().decode("r3u 06b mj3 e__.k56")
    Traceback (most recent call last):
     File"<stdin>", line 1, in <module>
    . . .
    RuntimeError: reed-solomon: number of erasures exceeds capacity (number of roots)

    ezcod_3_{10,11,12} 实例属性

    每个 ezcod_3_{10,11,12} 实例中都有以下属性:

    AttributeTypeRangeDescription
    latitude浮点数[-90,90 ]地理位置以度为单位
    longitude浮点数[-180,180 ]"
    latitude_error浮点数[0,inf ]轴的轴误差
    longitude_error浮点数[0,inf ]"
    accuracy浮点数[0,inf ]误差椭圆轴的平均误差
    precisionint[1,12 ]所需的位置符号数目
    confidenceint[0,100 ]剩余的奇偶校验符号的百分比
    certainty浮点数[0.0,1.0 ]确定EZCOD解码是正确
    chunkint[0,6 ]放置每个'区块'位置符号
    separator字符'。','','"'!SEP_NONE/DEFAULT/DOT/BANG/SPACE
    space字符'','-''CHK_NONE/DEFAULT/SPACE/DASH
    SEP_NONE字符'xff'输出无位置/奇偶校验分隔符
    SEP_DEFAULT字符'x00''输出无位置/奇偶校验分隔符
    SEP_DOT字符'。'( 默认)输出'。'位置/奇偶校验分隔符
    SEP_BANG字符''''!输出''位置/奇偶校验分隔符 !
    SEP_SPACE字符''''输出''位置/奇偶校验分隔符
    CHK_NONE字符'xff'输出块之间没有空格
    CHK_DEFAULT字符'x00''输出块之间的默认值
    CHK_SPACE字符''( 默认)在块之间输出''空间
    CHK_DASH字符''-''在块之间输出'-'空间

    建议将 SEP_DOT ( 默认值) 或者 SEP_BANG ( 避免 SEP_NONE ) 用于 separator,以便EZCOD解析器明确确定总EZCOD大小,以及要期望的奇偶符号数量。

    RSPWD: 密码校正 API

    基于reed编码的密码错误检测与纠正的Javascript实现。

    Javascript库:js/ezpwd/rspwd.js

    background

    一个优秀的,易于理解的基本reed的概述。

    ) )

    向更快速的算法转移会受到专利风险的影响。 然而,有一些可能的方法是。 下面是一个有趣的Apache 2许可( 允许商业使用和 GPLv3兼容性。): bulat ziganshin FastECC reed编码器。 它在编码方面取得了良好的性能,但不实现擦除或者错误检测/校正。 描述该算法的关键纸张:

    一个新的文件是在by中实现的,它的中包含了一个( 允许商业使用和GPLv3兼容性) Leopard。 taylor :


    相关文章