DES加密的C语言实现

最新推荐文章于 2024-01-05 16:53:44 发布
最新推荐文章于 2024-01-05 16:53:44 发布
阅读量1.5k 收藏 2
点赞数 1
分类专栏： Cryptography C 文章标签： c语言 加密 DES S-box 密码学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csdn_moming/article/details/50599255
版权

DES（Data Encryption Standard）原理：Wikipedia https://en.wikipedia.org/wiki/Data_Encryption_Standard

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define fPath "F:\\Plaintext.txt" //Can't be Chinese

const int num = 16;
const int length = 64;
const int cdlength = 28;
const int keylength = 48;
const int lrlength = 32;

void HexToBinary(int Hex[], int Binary[]);
void BinaryToHex(int Binary[], int Hex[]);
int IntPow(int x, int n);
void GetSubkey(int key[], int Subkey[][keylength]);
void LeftMove(int x[], int y[], int n);
void Replace(int C[], int D[], int key[]);
void Combine(int C[], int D[], int key[]);
void Encrypt(int Plaintext[], int Subkey[][keylength], int Ciphertext[]);
void ReplaceIP(int Plaintext[], int L[], int R[]);
void ArrayCopy(int x[], int y[]);
void EncryptCore(int output[], int L[], int R[], int K[]);
void InverseReplaceIP(int output[], int L[], int R[]);
void ESelect(int output[], int x[]);
void Sbox(int x[], int y[]);
void Reorder(int x[], int output[]);
void Decrypt(int Ciphertext[], int Subkey[][keylength], int DePlaintext[]);
void Display(int x[], int n);
void DecToBinary(int x[], int n);
int AddToArray(int Cipher[], int input[], int flag);

int main()
{
    int i, Key[num], result[num], j, k, len, pos, s;
    int OriginKey[length], OriginPlaintext[length], OriginCipher[length], Ciphertext[length];
    int Subkey[num][keylength], Cipher[10000], flag = 0;

    char input[10000];
    FILE *fp = NULL;

    if((fp = fopen(fPath, "r")) == NULL)
    {
        printf("Can't open file!\n");
        exit(1);
    }

    for(i = 0; (input[i] = fgetc(fp)) != EOF; i++) {}

    fclose(fp);

    len = i;
    int cycle = ceil(len / 8.0);
    int plain[cycle * 64], temp[len], cmd[8];
    pos = 0;

    for(i = 0; i < len; i++)
    {
        temp[i] = (int)(input[i]);
        DecToBinary(cmd, temp[i]);

        for(j = 0; j < 8; j++, pos++)
        {
            plain[pos] = cmd[j];
        }
    }

    for(; pos < cycle * 64; pos++)
    {
        plain[pos] = 0;
    }

    printf("Enter your 16 bits hexadecimal key:\n");

    for(i = 0; i < num; i++)
    {
        scanf("%x", &Key[i]);
    }

    HexToBinary(Key, OriginKey);
    GetSubkey(OriginKey, Subkey);

    //Encrypt
    printf("\nThe Ciphertext is:\n");

    for(i = 0; i < cycle; i++)
    {
        for(j = 0; j < 64; j++)
        {
            OriginPlaintext[j] = plain[i * 64 + j];
        }

        Encrypt(OriginPlaintext, Subkey, Ciphertext);
        flag = AddToArray(Cipher, Ciphertext, flag);

        BinaryToHex(Ciphertext, result);

        for(k = 0; k < 16; k++)
        {
            printf("%x", result[k]);
        }
    }

    //Decrypt
    printf("\n\nThe Plantext is:\n");

    for(i = 0; i < cycle; i++)
    {
        for(j = 0; j < 64; j++)
        {
            Ciphertext[j] = Cipher[i * 64 + j];
        }

        Decrypt(Ciphertext, Subkey, OriginCipher);

        for(k = 0; k < 8; k++)
        {
            for(s = 0; s < 8; s++)
            {
                cmd[s] = OriginCipher[k * 8 + s];
            }

            if(BinaryToDec(cmd) != 0)
            {
                printf("%c", BinaryToDec(cmd));
            }
        }
    }

    printf("\n");
    return 0;
}

/* Add Ciphertext to the Array and return the position */
int AddToArray(int Cipher[], int input[], int flag)
{
    int i;

    for(i = 0; i < 64; i++, flag++)
    {
        Cipher[flag] = input[i];
    }

    return flag;
}

/* Binary to Dec */
int BinaryToDec(int x[])
{
    int i, result = 0;

    for(i = 0; i < 8; i++)
    {
        if(x[i] == 1)
        {
            result += IntPow(2, 7 - i);
        }
    }

    return result;
}

/* Dec to Binary */
void DecToBinary(int x[], int n)
{
    int i, num = n;
    x[0] = 0;

    for(i = 1; i < 8; i++)
    {
        if(num >= IntPow(2, 8 - i - 1))
        {
            x[i] = 1;
            num -= IntPow(2, 8 - i - 1);
        }
        else
        {
            x[i] = 0;
        }
    }
}

/* x^n */
int IntPow(int x, int n)
{
    int result = 1;

    while(n-- > 0)
    {
        result *= x;
    }

    return result;
}

/* transform hex to binary */
void HexToBinary(int Hex[], int Binary[])
{
    int i = 0, j = 0;

    for(i = 0; i < num; i++)
    {
        for(j = 0; j < 4; j++)
        {
            if(Hex[i] >= IntPow(2, (3 - j)))
            {
                Binary[i * 4 + j] = 1;
                Hex[i] -= IntPow(2, (3 - j));
            }
            else
            {
                Binary[i * 4 + j] = 0;
            }
        }
    }
}

/* transform binary to hex */
void BinaryToHex(int Binary[], int Hex[])
{
    int i = 0;

    for(i = 0; i < num; i++)
    {
        Hex[i] = Binary[i * 4] * 8 + Binary[i * 4 + 1] * 4 + Binary[i * 4 + 2] * 2 + Binary[i * 4 + 3];
    }
}

/* get the subkey */
void GetSubkey(int key[], int Subkey[][keylength])
{
    int C[num + 1][cdlength], D[num + 1][cdlength];
    int i = 0;
    int Left[] = {1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1};
    Replace(C[0], D[0], key);

    for(i = 0; i < num; i++)
    {
        LeftMove(C[i], C[i + 1], Left[i]);
        LeftMove(D[i], D[i + 1], Left[i]);
        Combine(C[i + 1], D[i + 1], Subkey[i]);
    }
}

/* y = x << n */
void LeftMove(int x[], int y[], int n)
{
    int i = 0;

    for(i = 0; i < cdlength; i++)
    {
        y[i] = x[(i + n) % 28];
    }
}

/* Replacement 1 */
void Replace(int C[], int D[], int key[])
{
    int C0[] = {57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18,
                10, 2, 59, 51, 43, 35, 27, 19, 11, 3, 60, 52, 44, 36
               };
    int D0[] = {63, 55, 47, 39, 31, 23, 15, 7, 62, 54, 46, 38, 30, 22,
                14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 28, 20, 12, 4
               };
    int i = 0;

    for(i = 0; i < cdlength; i++)
    {
        C[i] = key[C0[i] - 1];
        D[i] = key[D0[i] - 1];
    }
}

/* Combine C and D to Key */
void Combine(int C[], int D[], int key[])
{
    int i = 0, temp[cdlength * 2];
    int R[] = {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
              };

    for(i = 0; i < cdlength; i++)
    {
        temp[i] = C[i];
    }

    for(i = 0; i < cdlength; i++)
    {
        temp[i + cdlength] = D[i];
    }

    for(i = 0; i < keylength; i++)
    {
        key[i] = temp[R[i] - 1];
    }
}

/* Encrypt plaintext with subkey */
void Encrypt(int Plaintext[], int Subkey[][keylength], int Ciphertext[])
{
    int L[num + 1][lrlength], R[num + 1][lrlength];
    int i = 0;
    ReplaceIP(Plaintext, L[0], R[0]);

    for(i = 0; i < num; i++)
    {
        ArrayCopy(L[i + 1], R[i]);
        EncryptCore(R[i + 1], L[i], R[i], Subkey[i]);
    }

    InverseReplaceIP(Ciphertext, L[num], R[num]);
}

/* Origin replace ip */
void ReplaceIP(int Plaintext[], int L[], int R[])
{
    int temp[64], i = 0;
    int ReplaceIp[] = {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, 25, 17, 9, 1, 59, 51, 43, 35, 27, 19, 11, 3,
                       61, 53, 45, 37, 29, 21, 13, 5, 63, 55, 47, 39, 31, 23, 15, 7
                      };

    for(i = 0; i < length; i++)
    {
        temp[i] = Plaintext[ReplaceIp[i] - 1];
    }

    for(i = 0; i < lrlength; i++)
    {
        L[i] =  temp[i];
    }

    for(i = 0; i < lrlength; i++)
    {
        R[i] =  temp[i + lrlength];
    }
}

/* copy y's elements to x */
void ArrayCopy(int x[], int y[])
{
    int i = 0;

    for(i = 0; i < lrlength; i++)
    {
        x[i] = y[i];
    }
}

/* the core of DES */
void EncryptCore(int output[], int L[], int R[], int K[])
{
    int select[keylength], temp[keylength], temporary[keylength], i = 0;
    ESelect(select, R);

    for(i = 0; i < keylength; i++)
    {
        temp[i] = select[i] ^ K[i];
    }

    Sbox(temp, temporary);
    Reorder(temporary, output);

    for(i = 0; i < keylength; i++)
    {
        output[i] = output[i] ^ L[i];
    }
}

/* Inverse permutation */
void InverseReplaceIP(int output[], int L[], int R[])
{
    int InverseIP[] = {40, 8, 48, 16, 56, 24, 64, 32, 39, 7, 47, 15, 55, 23, 63, 31,
                       38, 6, 46, 14, 54, 22, 62, 30, 37, 5, 45, 13, 53, 21, 61, 29,
                       36, 4, 44, 12, 52, 20, 60, 28, 35, 3, 43, 11, 51, 19, 59, 27,
                       34, 2, 42, 10, 50, 18, 58, 26, 33, 1, 41, 9, 49, 17, 57, 25
                      };
    int temp[length], i = 0;

    for(i = 0; i < lrlength; i++)
    {
        temp[i] = R[i];
    }

    for(i = 0; i < lrlength; i++)
    {
        temp[i + lrlength] = L[i];
    }

    for(i = 0; i < length; i++)
    {
        output[i] = temp[InverseIP[i] - 1];
    }
}

/* E select operation */
void ESelect(int output[], int x[])
{
    int i = 0;
    int 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
              };

    for(i = 0; i < keylength; i++)
    {
        output[i] = x[E[i] - 1];
    }
}

/* S-Box */
void Sbox(int x[], int y[])
{
    int i = 0, j = 0, row = 0, col = 0, temp = 0;
    int S[8][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
        },
        {   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
        },
        {   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
        },
        {   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
        },
        {   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
        },
        {   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
        },
        {   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
        },
        {   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
        }
    };

    for(i = 0; i < 8; i++)
    {
        row = x[6 * i] * 2 + x[6 * i + 5];
        col = x[6 * i + 1] * 8 + x[6 * i + 2] * 4 + x[6 * i + 3] * 2 + x[6 * i + 4];
        temp = S[i][16 * row + col];

        for(j = 0; j < 4; j++)
        {
            if(temp >= IntPow(2, (3 - j)))
            {
                y[4 * i + j] = 1;
                temp -= IntPow(2, (3 - j));
            }
            else
            {
                y[4 * i + j] = 0;
            }
        }
    }
}

/* reorder the matrix */
void Reorder(int x[], int output[])
{
    int i = 0;
    int 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
              };

    for(i = 0; i < lrlength; i++)
    {
        output[i] = x[P[i] - 1];
    }
}

/* Dncrypt plaintext with subkey */
void Decrypt(int Ciphertext[], int Subkey[][keylength], int DePlaintext[])
{
    int L[num + 1][lrlength], R[num + 1][lrlength];
    int i = 0;
    ReplaceIP(Ciphertext, L[0], R[0]);

    for(i = 0; i < num; i++)
    {
        ArrayCopy(L[i + 1], R[i]);
        EncryptCore(R[i + 1], L[i], R[i], Subkey[num - i - 1]);
    }

    InverseReplaceIP(DePlaintext, L[num], R[num]);
}

/* test the output */
void Display(int x[], int n)
{
    int i = 0, logo = 0;

    for(i = 0; i < n; i++)
    {
        printf("%d", x[i]);
        logo++;

        if(logo >= 8)
        {
            logo = 0;
            printf(" ");
        }
    }

    printf("\n");
}
csdn_moming
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
DES加密(C语言)
12-08
DES加密的C语言代码，主要为主函数代码，编写时所用的编译器是VC6.0
DES加密 C语言实现
03-06
DES加密算法，已经运用到实际的项目中，能正确加密解密。
DES算法加密C语言实现
热门推荐
lee371042的博客
11-24 1万+
这几天把老师布置作业写了写，主要是DES算法加密，随便写了写，这里是实现对明文为8字节的加密以及对加密产生的密文进行解密，而不能直接输入密文。。。 什么是DES算法，请自行百度学习这里只给出实现代码。 代码每一步都有解释，可能实现的有些麻烦，但是易懂，代码如下： ///DES算法加密 #include<cstdio> #include<cstring> const ...
【密码学】C语言实现DES加密原理
最新发布
sss_haoran的博客
01-05 970
这篇文章简要介绍了DES（Data Encryption Standard）加密算法的基本原理以及用C语言实现该算法的基本步骤。文章首先概述了DES作为一种对称密钥加密算法的背景，并强调了其在现代密码学中可能存在的一些安全性挑战。随后，文章详细解释了DES的基本原理，包括初始置换、轮函数、最终置换等关键步骤。在代码示例中，展示了简化版的C语言实现，涉及初始置换、轮函数和最终置换的基本逻辑框架。
des加密算法的c++ 实现
专注java二开部署
11-30 1812
总的来说，实现一个安全的加密系统需要综合考虑多个因素，并采取适当的措施来确保其安全性、性能和合规性。此外，还需要不断关注最新的安全研究和最佳实践，并及时更新和改进现有的系统。需要注意的是，DES 加密算法已经被认为是不安全的，不建议在现代应用程序中使用。总的来说，实现一个安全的加密系统需要考虑许多因素，并且需要遵循最佳实践来确保其安全性和性能。实现一个安全的加密系统需要综合考虑多个因素，并采取适当的措施来确保其安全性、性能和合规性。除了上述基本的DES加密过程，还有一些其他的步骤和注意事项可以考虑。
解析 DES 加密算法(C语言)：
沐一 · 林 的博客
06-13 7722
目录解析 DES 加密算法(C语言)：DES 简介：DES 算法整体流程：DES 解密：C 语言代码实现加密解密逻辑：内容修改自博客：DES加密算法解析与实现 - luogi - 博客园DES 全称为 Data Encryption Standard，即数据加密标准，是一种使用密钥加密的块算法。DES 算法就是一个把 8 字节 64 位的明文输入块变为 64 位密文输出块的算法，它所使用的密钥也是 64 位（其实只使用到了 56 位，其余 8 位为奇偶校验位）算法特点：分组比较短、密钥太短、密码生命周期短、
基于C语言实现的DES算法
毕业作品网站
07-22 2955
DES 是一种典型的块加密方法：它以 64 位为分组长度，64 位一组的明文作为算法的输入，通过一系列复杂的操作，输出同样 64 位长度的密文。
c语言字符串DES加密,DES加密C语言实现源代码.doc
weixin_39836803的博客
05-17 71
实用标准文案文档void *memcpy( void *dest, const void *src, unsigned char count ){//ASSERT((dest != NULL)&&(src != NULL));unsigned char *temp_dest = (unsigned char *)dest;unsigned char *temp_src = (uns...
DES加密算法（c语言实现）
06-11
提供的压缩包文件6e6cbd12c84540d1aa029a55025426a4可能包含了C语言实现DES加密算法的源代码。通过阅读和理解这些代码，你可以深入学习DES算法的实现细节，如如何进行位操作、如何构造S盒和P盒、以及如何进行迭代...
des加密c语言实现
06-03
在C语言中实现DES加密，需要理解DES算法的核心步骤，并将其转化为C语言代码。 DES算法主要分为以下几个步骤： 1. **初始置换（IP）**：将64位明文分成左右两半，每半32位，然后通过一个固定的置换表进行重新排列。...
DES加密算法—实现(C语言)
09-22
用vs2012写的，可以直接运行想要代码的话，都在一个cpp文件中
C语言实现DES算法
05-22
C语言实现DES算法 C语言实现DES算法 C语言实现DES算法
DES算法C语言实现.c
04-16
DES算法为密码体制中的对称密码体制，又被称为美国数据加密标准，是1972年美国IBM公司研制的对称密码体制加密算法。 明文按64位进行分组，密钥长64位，密钥事实上是56位参与DES运算(第8、16、24、32、40、48、56、64位是校验位， 使得每个密钥都有奇数个1)分组后的明文组和56位的密钥按位替代或交换的方法形成密文组的加密方法。
S-DES密码加密解密
09-04
S-DES加密解密
DES加密算法C语言代码实现
09-26
配套文章解析：https://blog.csdn.net/u013469753/article/details/1083 DES的英文全称是Data Encryption Standard，意思是数据加密标准。而我们本篇文章讨论的是DES的加密算法。希望大家能够将这两个名词区别开来，很多时候我们说的DES都是在指DES算法，而不是DES数据加密标准。DES算法是一种典型的分组密码，即将固定长度的明文通过一系列复杂的操作变成同样长度密文的算法。
DES.rar_DES 加密 C语言
09-19
C语言实现DES加密算法时，需要注意以下几个关键点： 1. **数据类型**：由于DES涉及到的位操作较多，C语言中可以使用`unsigned char`来表示8位的数据，用`struct`定义64位的数据结构。 2. **位操作**：C语言提供了...
c语言中的des加密算法,des加密算法（c语言版）
weixin_32751907的博客
05-24 642
![这里写图片描述][70]![这里写图片描述][70 1]![这里写图片描述][70 2]## main.cpp ###include#include#include"tables.h" //数据表//置换函数//参数： In：待置换数据指针//Out：置换输出指针// n:置换表长度//P：置换表指针//说明：将输入数据的指定位置作为输出数据的第i位。指定位置即置换表第i位的十进制数。得到的输...
c语言字符串DES加密,DES加密算法，c语言实现
weixin_39630048的博客
05-17 198
```cpp//des算法...真的有点难，debug哭了//参考博客https://www.cnblogs.com/songwenlong/p/5944139.html#includeusing namespace std;char str[9];//输入的明文，密钥int express[65];//输入初始明文的二进制int l0[49],r0[49];//初始int l1[49],r1[4...
DES对称加密纯C语言实现
想要和得到之间还有一步，就是要做到
08-04 878
在MSVC2022环境下编译无问题。如有错误和不足之处，敬请指正。
"C语言实现DES加密与解密
《用C语言实现DES加密与解密》是一份详细介绍了如何使用C语言实现DES加密与解密算法的文档。DES（Data Encryption Standard）算法是一种对称密钥加密算法，广泛应用于信息安全领域。本文档主要介绍了DES算法的原理、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值