C语言解析pem私钥文件

最新推荐文章于 2024-07-25 16:26:56 发布

放码过来呀！！！

最新推荐文章于 2024-07-25 16:26:56 发布

阅读量1k

点赞数

分类专栏：原创 C语言文章标签：加密解密 c语言

本文链接：https://blog.csdn.net/m0_46671092/article/details/108279068

版权

原创同时被 2 个专栏收录

23 篇文章 11 订阅

订阅专栏

C语言

4 篇文章 2 订阅

订阅专栏

本文提供了一段C语言代码，用于从PEM文件中读取并解析私钥信息，包括模块、指数等数据，适用于RSA 2048位密钥。代码首先将PEM文件转换为字符串，然后进行Base64解码，最后解析出关键的RSA私钥组件。

摘要由CSDN通过智能技术生成

直接上代码。。。

/*按行读取一个pem文件所有字符并拼接为一整个字符串返回，去除首行、尾行及换行符*/
char* LoadPemFile(char* pemFilePath,int* length)
{
    FILE* file;
    size_t size = 0;
    char* buff;

    file = fopen(pemFilePath,"rb");
    if(file==NULL)
    {
        return NULL;
    }

    fseek(file,0L,SEEK_END); /*定位至文件尾*/
    size = ftell(file); /*获取文件大小*/
    buff = (char*)malloc(size);
    fseek(file,0L,SEEK_SET); /*定位至文件首*/
    size = 0;

    char line[1024]; //假设单行最长不超过1024,pem文件单行不会超过此限制

    while (!feof(file) && !ferror(file))
    {
        memset(line,0,sizeof(line));
        fgets(line, sizeof(line), file);
        int len=strlen(line);
        line[len-1]=0;//为了去除行尾的\n
        if(line[0]!='-') //去除首行和尾行
        {
            memcpy(buff+size,line,strlen(line));
            size += strlen(line);
        }
    }

    fclose(file);
    *length = size;
    //printf("%s",buff);
    return buff;
}


/*解码Base64,参数bindata需预先分配足够内存。返回值为解码后的实际长度*/
int base64_decode( const char * base64, unsigned char * bindata )
{
    int i, j;
    unsigned char k;
    unsigned char temp[4];
    const char * base64char = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    for ( i = 0, j = 0; base64[i] != '\0' ; i += 4 )
    {
        memset( temp, 0xFF, sizeof(temp) );
        for ( k = 0 ; k < 64 ; k ++ )
        {
            if ( base64char[k] == base64[i] )
                temp[0]= k;
        }
        for ( k = 0 ; k < 64 ; k ++ )
        {
            if ( base64char[k] == base64[i+1] )
                temp[1]= k;
        }
        for ( k = 0 ; k < 64 ; k ++ )
        {
            if ( base64char[k] == base64[i+2] )
                temp[2]= k;
        }
        for ( k = 0 ; k < 64 ; k ++ )
        {
            if ( base64char[k] == base64[i+3] )
                temp[3]= k;
        }

        bindata[j++] = ((unsigned char)(((unsigned char)(temp[0] << 2))&0xFC)) |
                ((unsigned char)((unsigned char)(temp[1]>>4)&0x03));
        if ( base64[i+2] == '=' )
            break;

        bindata[j++] = ((unsigned char)(((unsigned char)(temp[1] << 4))&0xF0)) |
                ((unsigned char)((unsigned char)(temp[2]>>2)&0x0F));
        if ( base64[i+3] == '=' )
            break;

        bindata[j++] = ((unsigned char)(((unsigned char)(temp[2] << 6))&0xF0)) |
                ((unsigned char)(temp[3]&0x3F));
    }
    return j;
}

/*从一个私钥pem文件中解析出module、exp数据至rsa_sk_t结构体*/
int ParseRsa2048PrivatePemFile(char* pemFilePath,rsa_sk_t *sk)
{
    int length=0;
    char* srcData = LoadPemFile(pemFilePath,&length);
    if(srcData==NULL)
    {
        return -2; //打开文件错误
    }
    uint8_t destData[1193];
    memset(destData,0,sizeof(destData));
    length = base64_decode(srcData,destData);
    free(srcData);

    if(length>=1191)
    {
        int startIndex = 0;
        if(destData[10]==1)
        {
            startIndex = 12;
        }
        else
        {
            startIndex = 11;
        }
        sk->bits = 2048;
        memcpy(&sk->modulus         [RSA_MAX_MODULUS_LEN-256 ],  destData + startIndex,  256);
        startIndex = startIndex + 256 + 2;
        memcpy(&sk->public_exponet  [RSA_MAX_MODULUS_LEN-3],  destData + startIndex,  3);
        if(destData[startIndex + 6]==1)
        {
            startIndex = startIndex + 8;
        }
        else
        {
            startIndex = startIndex + 7;
        }
        memcpy(&sk->exponent        [RSA_MAX_MODULUS_LEN-256 ],  destData + startIndex,  256);
        if(destData[startIndex + 259]==1)
        {
            startIndex = startIndex + 261;
        }
        else
        {
            startIndex = startIndex + 260;
        }
        memcpy(&sk->prime1          [RSA_MAX_PRIME_LEN - 128 ],  destData + startIndex,  128);
        if(destData[startIndex + 131]==1)
        {
            startIndex = startIndex + 133;
        }
        else
        {
            startIndex = startIndex + 132;
        }
        memcpy(&sk->prime2          [RSA_MAX_PRIME_LEN - 128 ],  destData + startIndex, 128);
        if(destData[startIndex + 131]==1)
        {
            startIndex = startIndex + 133;
        }
        else if(destData[startIndex + 131]==0)
        {
            startIndex = startIndex + 132;
        }
        else
        {
            startIndex = startIndex + 131;
        }
        memcpy(&sk->prime_exponent1 [RSA_MAX_PRIME_LEN - 128 ],  destData + startIndex, 128);
        if(destData[startIndex + 131]==1)
        {
            startIndex = startIndex + 133;
        }
        else if(destData[startIndex + 131]==0)
        {
            startIndex = startIndex + 132;
        }
        else
        {
            startIndex = startIndex + 131;
        }
        memcpy(&sk->prime_exponent2 [RSA_MAX_PRIME_LEN - 128 ],  destData + startIndex, 128);
        if(destData[startIndex + 131]==1)
        {
            startIndex = startIndex + 133;
        }
        else if(destData[startIndex + 131]==0)
        {
            startIndex = startIndex + 132;
        }
        else
        {
            startIndex = startIndex + 131;
        }
        memcpy(&sk->coefficient     [RSA_MAX_PRIME_LEN - 128 ],  destData + startIndex,  128);

        return 0;
    }
    else
    {
        return -1; //文件长度错误
    }
    return 0;
}