实现PROXY穿越（4）：DES算法之二

最新推荐文章于 2021-05-23 10:39:34 发布
最新推荐文章于 2021-05-23 10:39:34 发布
阅读量2.6k 收藏
点赞数
分类专栏： 网络通信 文章标签： 算法 permutation function dst algorithm session
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flowingflying/article/details/4811541
版权

　　最近忙，事比较多，活多了，还要降薪，唉。没什么时间看书，将以前的一些技术blog也移到这里。NTLM在去年年底和今年年初研究过一阵子，写了总结和 例子程序。里面涉及很多算法，在网上查了很久。（下面是以前的博客）最近想实现一个通过PROXY穿越的网络编程，将相关的内容进行一下汇总。很多东西来 自网络共产主义，也应该为共产主义有所回馈。介绍DES算法之二的实现。

 

步骤二：16次计算（16 interations)

　　 在步骤一中，我们获取了64bits的s，以及56bits的key。s分为2个32bit的序列，分布成为L和R，根据第一步计算，我们有了L0、R0，以及K0，进行如下的操作：
L1=R0
R1=L0 XOR F(R0,K1)
　　 我们得到了新的L1和R1，重复操作，直至得到L16和R16，操作公式为：
Li = R i-1
Ri = L i-1 XOR F(Ri-1,Ki)

A：Ki的获取
　　在这个过程中，我们每次运算的操作需要得到新的ki进行参与。下面将介绍如何从K0依次16个获取Ki（K1-K16)。K0是一个56bits的数据，我们将其存贮56个字节的key数组中。这56个比特均分为2组，第一组0－27，第二组28－55。
　　 左移偏移量：
　　 　　 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
　　 对于Ki，从左移偏移量选择对应的偏移量，例如K1＝1，K4＝2。将两组28位的比特分别左移指定的便宜量。例如对于K1，经过左移后，第一组为 1－27，0，第二组为29－55，28。得到一个新的56比特的数据，请保留这个新的序列，记做K1',这个数据根据下面进行序列重排：
    |14 17 11 24  1  5|
    | 3 28 15  6 21 10|
    |23 19 12  4 26  8|
    |16  7 27 20 13  2|
    |41 52 31 37 47 55|
    |30 40 51 45 33 48|
    |44 49 39 56 34 53|
    |46 42 50 36 29 32|
　　 经过重新排序后，我们得到48比特的数据，这个就是K1。由此我们获得了第一个参与运算的K1。
　　 对于Ki，将Ki-1'，例如计算K2，将上次我们得到的K1'，分为两组，进行相应的左移操作，得到Ki’，例如计算K2是，我们将K1’分为两组，每组左移1为，得到K2’，将Ki’进行同样排序，得到Ki。
　　 通过这样的操作，我们依次得到16个Ki，代码如下：
static int key_offset[] = {1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1};
static int ip_key[] ={
    14,17,11,24,1,5,
    3,28,15,6,21,10,
    23,19,12,4,26,8,
    16,7,27,20,13,2,
    41,52,31,37,47,55,
    30,40,51,45,33,48,
    44,49,39,56,34,53,
    46,42,50,36,29,32};

//左移操作
static void getkey(IN OUT unsigned char * key,int offset){
    unsigned char temp[28];

    memcpy(temp,key + offset,28-offset);
    memcpy(temp + 28 - offset, key , offset);
    memcpy(key,temp,28);

    memcpy(temp,key + 28 + offset,28-offset);
    memcpy(temp + 28 - offset, key + 28 , offset);
    memcpy(key + 28,temp,28);
}

void algorithm_des(IN unsigned char * src, IN unsigned char * secrect,
                   OUT unsigned char * dst){
    ......
    //步骤二：
    //获取原始的L0和R0
    memcpy(L,s,32);
    memcpy(R,s+32,32);
   
    //进行16次计算
    for(i = 0; i < 16 ; i++){
        //获取Ki'仍然放置在key中
        getkey(key,key_offset[i]);
        //获取Ki,放置在K中
        initail_permutation(key,ip_key,48,K);
    }
}

B：F计算
　　我们已经有R0，对于每次计算Ri，都将有Ri-1，根据A的步骤，我们已经有了K1，对于每次计算，我们也有Ki。在这个步骤中，我们将实现F（Ri-1，Ki）。

step B.1：
　　 对于Ri-1进行序列交换，生成一个48比特的数据，排序方式如下：
   | 32  1  2  3  4  5 |
   |  4  5  6  7  8  9 |
   |  8  9 10 11 12 13 |
   | 12 13 14 15 16 17 |
   | 16 17 18 19 20 21 |
   | 20 21 22 23 24 25 |
   | 24 25 26 27 28 29 |
   | 28 29 30 31 32  1 |
　　 这组48比特的数据和Ki进行异或（XOR），得到一组新的48bite的数据，我们暂时记做E.

step B.2: S box的运算
　　48比特的数据均分为8份，每份6比特，我们分别根据S-box的变换，每份产生4比特的数据，生成一个32bite的数据。
1、从6比特的数据中获取一个行号m和一个列号n。
　　m＝b0b5，n＝b1b2b3b4
　　例如6比特的数据为100101，则m=11(3)，n=0010(2)
2、根据行号和列号，在S-box的序列中，查到相应的数值。48比特分为8组，每组查询的S-box是不一样的，分别为S1, S2, S3, S4, S5, S6, S7，S8具体如下：
S1：   0列 1列 2列 3列 4列 5列 6列 7列 8列 9列 A列 B列 C列 D列 E列 F列
0行    14  4   13  1   2   15  11  8   3   10  6   12  5   9   0   7
1行    0   15  7   4   14  2   13  1   10  6   12  11  9   5   3   8
2行    4   1   14  8   13  6   2   11  15  12  9   7   3   10  5   0
3行    15  12  8   2   4   9   1   7   5   11  3   14  10  0   6   13
S2：
    15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,
    3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,
    0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,
    13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9
S3：
    10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8,
    13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1,
    13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7,
    1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12
S4
    7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15,
    13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9,
    10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4,
    3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14
S5
    2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9,
    14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6,
    4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14,
    11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3
S6
    12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11,
    10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8,
    9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6,
    4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13
S7
    4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,
    13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,
    1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,
    6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12
S8
    13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,
    1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,
    7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,
    2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11
　　我们仍以100101为例子，假设它的第一组6比特，得到m＝3，n＝2，我们查询S1，在第3行，第2列中查得8，将其翻译为二进制，则转换为4比特 的数据1000，这样我们得到了新的第一组4比特，如此类推，我们得到了8组4比特的数据，按顺序组合成一个32比特的数据，暂时记为E'。

stepＢ.3:更换顺序
将32比特的E’根据下面进行序列更换，得到新的32位数据。
   |16 7  20 21|
   |29 12 28 17|
   |1  15 23 26|
   |5  18 31 10|
   |2  8  24 14|
   |32 27 3  9 |
   |19 13 30 6 |
   |22 11 4  25|
至此我们完成了F运算。

C：获得新的Ri和Li
这步骤比较简单，如下
Li = R i-1
Ri = L i-1 XOR F(Ri-1,Ki)

D：重复16次计算，得到L16和R16

static int ip_e[] = {
    32,1,2,3,4,5,
    4,5,6,7,8,9,
    8,9,10,11,12,13,
    12,13,14,15,16,17,
    16,17,18,19,20,21,
    20,21,22,23,24,25,
    24,25,26,27,28,29,
    28,29,30,31,32,1};
static int ip_p[] = {
    16,7,20,21,29,12,28,17,
    1,15,23,26,5,18,31,10,
    2,8,24,14,32,27,3,9,
    19,13,30,6,22,11,4,25};

static unsigned char s1[64] = {
    14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7,
    0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,
    4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,
    15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13 };

static unsigned char s2[64] = {
    15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,
    3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,
    0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,
    13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9 };

static unsigned char s3[64] = {
    10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8,
    13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1,
    13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7,
    1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12 };

static unsigned char s4[64] = {
    7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15,
    13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9,
    10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4,
    3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14 };

static unsigned char s5[64] = {
    2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9,
    14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6,
    4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14,
    11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3 };

static unsigned char s6[64] = {
    12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11,
    10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8,
    9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6,
    4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13 };

static unsigned char s7[64] = {
    4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,
    13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,
    1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,
    6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12 };

static unsigned char s8[64] = {
    13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,
    1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,
    7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,
    2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11 };

static void s_box_function(IN unsigned char * data,IN unsigned char * sbox,
                           OUT unsigned char * dst){
    int m = data[0] * 2 + data[5];
    int n = data[1] * 8 + data[2] * 4 + data[3] * 2 + data[4];
    unsigned char c = sbox[m* 16 + n];
    if(c >= 8){
        dst[0] = 1;
        c = c-8;
    }else{
        dst[0] = 0;
    }
    if(c >= 4){
        dst[1] = 1;
        c = c-4;
    }else{
        dst[1] = 0;
    }
    if(c >= 2){
        dst[2] = 1;
        c = c-2;
    }else{
        dst[2] = 0;
    }
    dst[3] = c;
}

void algorithm_des(IN unsigned char * src, IN unsigned char * secrect,
                   OUT unsigned char * dst){
    ......
    //步骤二：
    //获取原始的L0和R0
    memcpy(L,s,32);
    memcpy(R,s+32,32);
   
    //进行16次计算
    for(i = 0; i < 16 ; i++){
        //获取Ki
        getkey(key,key_offset[i]);
        initail_permutation(key,ip_key,48,K);

        //F计算
        initail_permutation(R,ip_e,48,E);
        xorbit(E,K,48,E);
        s_box_function(E,s1,E);
        s_box_function(E + 6,s2,E + 4);
        s_box_function(E + 12,s3,E + 8);
        s_box_function(E + 18,s4,E + 12);
        s_box_function(E + 24,s5,E + 16);
        s_box_function(E + 30,s6,E + 20);
        s_box_function(E + 36,s7,E + 24);
        s_box_function(E + 42,s8,E + 28);
        initail_permutation(E,ip_p,32,E);

        //更换序列
        xorbit(E,L,32,E);
        memcpy(L,R,32);
        memcpy(R,E,32);
    }
}
相关链接：我的网络通信相关文章

NTLM的实现：

恺风
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Cloudflare-Proxy-Server:Cloudflare代理服务器
05-01
在本文中，我们将深入探讨Cloudflare代理服务器的工作原理、主要功能以及如何利用Worker.js脚本来实现自定义代理。 **工作原理** Cloudflare代理服务器的核心是其全球分布式边缘网络。当用户访问配置了Cloudflare...
实现PROXY穿越（5）：DES算法之三
愷风（Wei）的专栏
11-14 2586
最近忙，事比较多，活多了，还要降薪，唉。没什么时间看书，将以前的一些技术blog也移到这里。NTLM在去年年底和今年年初研究过一阵子，写了总结和例子程序。里面涉及很多算法，在网上查了很久。（下面是以前的博客）最近想实现一个通过PROXY穿越的网络编程，将相关的内容进行一下汇总。很多东西来自网络共产主义，也应该为共产主义有所回馈。介绍DES算法之三的实现。  步骤三：获取最后
实现PROXY穿越（3）：DES算法之一
愷风（Wei）的专栏
11-14 3098
　　最近忙，事比较多，活多了，还要降薪，唉。没什么时间看书，将以前的一些技术blog也移到这里。NTLM在去年年底和今年年初研究过一阵子，写了总结和例子程序。里面涉及很多算法，在网上查了很久。（下面是以前的博客）最近想实现一个通过PROXY穿越的网络编程，将相关的内容进行一下汇总。很多东西来自网络共产主义，也应该为共产主义有所回馈。介绍DES算法的实现。 　　在NTLM中使
Feistel算法结构与DES加密算法
weixin_30505225的博客
04-30 945
Feistel分组加密算法结构 Feistel算法结构是一种设计原则，而并非是某种加密算法，提出通过替代和置换交替的操作方式构造密码 加密： 将明文分成左右两部分：明文 = (L0，R0) 每一轮i=1，2，……，n计算：Li=Ri-1，Ri=Li-1⊕ F(Ri-1，Ki)；其中F()是轮函数，Ki是子密钥 密文 = (Ln，Rn) 解密： 密文 = (Ln，...
des算法c语言讲解,DES算法
weixin_34785304的博客
05-23 144
该楼层疑似违规已被系统折叠隐藏此楼查看此楼有人能帮我看看DES算法吗？下面是C代码，调试无错误，但是运行不出结果改了很多次，特别无奈#include#includeint ip[64]={58,50,42,34,26,18,10,2,60,52,44,36,28,20,12,4,62,54,46,38,30,22,14,6,64,56,48,40,32,24,16,8,57,49,41,33,2...
proxy-polyfill:代理对象polyfill
05-07
这是Proxy对象（ES6的一部分）的一个polyfill。 有关Proxy本身的更多信息，请参见或。 与其他Object.observe不同，这不需要Object.observe ，。 polyfill仅支持有限数量的代理“陷阱”。 通过调用传递给Proxy的对象...
proxy4js:代理人
05-25
proxy4js proxy 在文件夹中的URL.js文件 修改link的值为需要跨域的链接（A） npm install npm start 启动中间件服务 本机调用A接口的地方改为
proxypool：Golang实现的IP代理池
02-03
Golang实现的IP代理池 采集免费的代理资源为爬虫提供有效的IP代理 随着时间的推移观星人 版本更新 2019年12月18日v2.4感谢 添加代理网站ip3306，plp-ssl两个 更新数据库结构，添加创建时间和更新时间 更新ip.go当中...
proxy-balancer:代理负载均衡器
04-30
代理平衡器 代理负载均衡器目录安装npm install proxy-balancer用法const Balancer = ... // Proxies should be in this format: // [ http://0.0.0.0:8080, https://0.0.0.0:8081, socks4://0.0.0.0:8000 ] fetch
我的技术博客索引
热门推荐
愷风（Wei）的专栏
09-12 1万+
我的JAVA相关文章我的Clutter相关博客我的网络通信相关文章我的Linux相关文章我的与kernel module有关的文章我的嵌入式Linux相关文章我的MeeGo/Moblin相关文章我的Andriod开发相关文章我的与编程思想相关的文章我的无限网络文章我的产业生态链和杂谈文章我的四方书库生活空间为五斗饭相关文章天南地北相关
云计算学习笔记（二）：云计算机制
愷风（Wei）的专栏
03-05 7870
文章转载只能用于非商业性质，且不能带有虚拟货币、积分、注册等附加条件。转载须注明出处http://blog.csdn.net/flowingflying以及作者@恺风Wei 一些术语和概念 逻辑网络边界（logical network perimeter）通常是由提供和控制数据中心连接的网络设备建立，例如虚拟防火墙，虚拟网络（VLAN、VPN） 虚拟服务器（VM），虚拟基础设施管理器（VIM
实现PROXY穿越（1）：流程和NTLM算法
愷风（Wei）的专栏
11-13 7327
　　最近忙，事比较多，活多了，还要降薪，唉。没什么时间看书，将以前的一些技术blog也移到这里。NTLM在去年年底和今年年初研究过一阵子，写了总结和例子程序。里面涉及很多算法，在网上查了很久。下面是以前的博客　　最近想实现一个通过PROXY穿越的网络编程，将相关的内容进行一下汇总。很多东西来自网络共产主义，也应该为共产主义有所回馈。 HTTPPROXY穿越的
实现PROXY穿越（10）：NTLMv2 response
愷风（Wei）的专栏
11-15 5818
　　最近忙，事比较多，活多了，还要降薪，唉。没什么时间看书，将以前的一些技术blog也移到这里。NTLM在去年年底和今年年初研究过一阵子，写了总结和例子程序。里面涉及很多算法，在网上查了很久。（下面是以前的博客）最近想实现一个通过PROXY穿越的网络编程，将相关的内容进行一下汇总。很多东西来自网络共产主义，也应该为共产主义有所回馈。介绍NTLMv2 response的实现。　　NTLMv1
实现PROXY穿越（6）：LM-Hash的实现
愷风（Wei）的专栏
11-14 5725
 　　最近忙，事比较多，活多了，还要降薪，唉。没什么时间看书，将以前的一些技术blog也移到这里。NTLM在去年年底和今年年初研究过一阵子，写了总结和例子程序。里面涉及很多算法，在网上查了很久。（下面是以前的博客）最近想实现一个通过PROXY穿越的网络编程，将相关的内容进行一下汇总。很多东西来自网络共产主义，也应该为共产主义有所回馈。介绍LM-Hash的实现。 　　经过了对DES的努力
实现PROXY穿越（8）：NT-Hash的实现
愷风（Wei）的专栏
11-15 5451
　　最近忙，事比较多，活多了，还要降薪，唉。没什么时间看书，将以前的一些技术blog也移到这里。NTLM在去年年底和今年年初研究过一阵子，写了总结和例子程序。里面涉及很多算法，在网上查了很久。（下面是以前的博客）最近想实现一个通过PROXY穿越的网络编程，将相关的内容进行一下汇总。很多东西来自网络共产主义，也应该为共产主义有所回馈。介绍NT-hash的实现。　　从IBM设计的LM Hash
NTLM的PROXY穿越
愷风（Wei）的专栏
03-03 5180
以前在sina的坑里面对NTLM技术和实现的方式进行了分析，并给出了代码。记得最凄惨的是找DES算法，N个地方给出的计算值都不一样，郁闷了很久。现在逐步将这些blog移到CSDN上。实现PROXY穿越（1）：流程和NTLM算法实现PROXY穿越（2）：Base64算法实现PROXY穿越（3）：DES算法之一实现PROXY穿越（4）：DES
sip消息的路由
愷风（Wei）的专栏
03-23 5136
不知为何，出现在CSDN的“2011年风云专栏”评选中，两个专栏，入围一个，另一个访问人数多一倍的没有，不知道是什么标准。希望不要最后一名现眼。这种活动，还是自愿参加为好。 今天下午去了大学城，看IMAX《异星战场》。画面制作很精良，而剧情实在受不了，不是说剧情简单问题，只是情节要圆满一些。一开始，出现了三个所谓的使者，而主人公在离开地球之前干掉一个，在第二次离开又干掉一个，还有一个啊。这些
CDMA学习笔记（一）：历史和基本概况
愷风（Wei）的专栏
09-12 5079
在向移动业务发展时，我觉得有必要对CDMA 2000的技术进行一个学习，尤其涉及需要在Rev A上带有QoS要求的业务流。空口的知识几乎除了几个名词都不懂，这方面也不需要了解太深，有个大概印象就可以了，这些东西估计看看也忘了，所以还是记录一些可能能记下的东西。好了，开始学习。
MySQL Proxy配置教程：实现读写分离
"MySQL Proxy用于实现数据库的读写分离，它是一个轻量级的代理服务器，位于MySQL客户端和服务器之间，可以动态地分配读写请求到不同的数据库实例，从而提高系统的可扩展性和性能。本文档主要介绍了如何配置和使用...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值