对套接字使用AES\u ctr128\u加密时出现SIGSEGV错误

当我试图使用AES\u ctr128\u encrypt加密文件的数据时，我得到了SIGBUS错误。在这里，我使用

read（）

函数将数据从文件读取到

bufptr[32k]

，每次读取32k块。对于每个数据块，我只想使用AES\u ctr128\u encrypt（bufptr+200、outdata、bytes\u encrypt和key、state.ivec、state.ecoount和state.num）加密部分数据仅加密所需的数据，然后再次将其发送到服务器，然后再次解密并添加到缓冲区。有人能帮我解决这个问题吗？提前谢谢

第一个客户端能够将文件大小发送到服务器，当它到达

AES\u ctr128\u encrypt（）

时，我得到分段错误（内核转储），gdb说它是SIGSEGV

我的头文件

#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <malloc.h>
#include <string.h>
#include <sys/socket.h>
#include <resolv.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/sendfile.h>
#include <pthread.h>
#include <sys/syscall.h>
#include <openssl/ssl.h>
#include <openssl/err.h>
#include <sys/time.h>
#include <openssl/aes.h>
#include <openssl/rand.h>
#include <openssl/modes.h>
#include <openssl/crypto.h>
#define FAIL    -1
#define SEGMENT_SIZE 32768
#define j 10
#define OUT1 AES_BLOCK_SIZE
#define BYTES_ENCRYPT AES_BLOCK_SIZE

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#定义失败-1
#定义段_大小32768
#定义j 10
#定义OUT1 AES\u块大小
#定义字节\u加密AES\u块\u大小

我的客户程序

#include "headers.h"
#define FILE "/tmp/book"

struct ctr_state {
    unsigned char ivec[AES_BLOCK_SIZE];
    unsigned int num;
    unsigned char ecount[AES_BLOCK_SIZE];
};

int init_ctr(struct ctr_state *state, const unsigned char iv[8])
{
    /* aes_ctr128_encrypt requires 'num' and 'ecount' set to zero on the
     * first call. */
    state->num = 0;
    memset(state->ecount, 0, 16);

    /* Initialise counter in 'ivec' to 0 */
    memset(state->ivec + 16, 0, 16);

    /* Copy IV into 'ivec' */
    memcpy(state->ivec, iv, 16);
}

int main(int argc, char* argv[])
{
size_t count;   
AES_KEY key;
unsigned char ckey[] =  "/home/nandan/aes.key"; 
unsigned char iv[AES_BLOCK_SIZE];
struct ctr_state state;   

// validate proper usage
if (argc != 3)
{
    fprintf(stderr, "Usage: %s <serverIP> <serverPort>\n", argv[0]);
    exit(-1);
}

// store the command line arguments 
char *server_ip = argv[1];
int server_port = htons(atoi(argv[2]));
// stores address of remote server to connect
struct sockaddr_in server_addr;
int fd, option;

fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd == -1)
{
    fprintf(stderr, "Error creating socket\n");
    exit(-1);
}

memset(&server_addr, 0, sizeof(server_addr));

server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = inet_addr(server_ip);
server_addr.sin_port = server_port;

if (connect(fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1)
{
    fprintf(stderr, "Error connecting to server\n");
    exit(-1);
}

struct stat stats;
stat("/tmp/book", &stats);
int size = stats.st_size;
// send size of file to the client
send(fd, &size, sizeof(int),0);
printf("Written \n");
unsigned char outdata[OUT1];
in = open (FILE, O_RDONLY);
to_read = size;
char *bufptr = malloc(SEGMENT_SIZE);
  do
  {
   n = read (in, bufptr, SEGMENT_SIZE);
   if(n < 0)
   {  
    perror("Read Error:");
   }
   init_ctr(&state, iv);
   AES_ctr128_encrypt(bufptr+200, outdata, BYTES_ENCRYPT, &key, state.ivec, state.ecount, &state.num);
   memcpy(bufptr+200,outdata,BYTES_ENCRYPT);
   sending = send(fd, bufptr, n,0);
   to_read = to_read-n;
   } while (to_read != 0);  
close(fd);
}

#包括“headers.h”
#定义文件“/tmp/book”
结构中心状态{
无符号字符ivec[AES_块大小]；
无符号整数；
无符号字符计数[AES_块大小]；
};
int init_ctr（struct ctr_state*state，const unsigned char iv[8]）
{
/*aes\u ctr128\u encrypt要求将服务器上的“num”和“ecoount”设置为零
*第一个电话*/
状态->数值=0；
memset（state->ecount，0,16）；
/*将“ivec”中的计数器初始化为0*/
memset（状态->ivec+16,0,16）；
/*将IV复制到“ivec”*/
memcpy（州->ivec，iv，16）；
}
int main（int argc，char*argv[]）
{
大小/数量；
AES_密钥；
无符号字符ckey[]=“/home/nandan/aes.key”；
无符号字符iv[AES_块大小]；
结构中心状态；
//验证正确使用
如果（argc！=3）
{
fprintf（stderr，“用法：%s\n”，argv[0]）；
出口（-1）；
}
//存储命令行参数
char*server_ip=argv[1]；
int server_port=htons（atoi（argv[2]）；
//存储要连接的远程服务器的地址
服务器地址中的结构sockaddr\u；
int-fd，选项；
fd=套接字（AF_INET，SOCK_STREAM，0）；
如果（fd==-1）
{
fprintf（stderr，“创建套接字时出错\n”）；
出口（-1）；
}
memset（&server_addr，0，sizeof（server_addr））；
服务器地址sin家庭=AF网络；
server\u addr.sin\u addr.s\u addr=inet\u addr（服务器ip）；
server\u addr.sin\u port=服务器\u端口；
if（connect（fd，（struct sockaddr*）和server_addr，sizeof（server_addr））=-1）
{
fprintf（stderr，“连接到服务器时出错”）；
出口（-1）；
}
结构统计；
stat（“/tmp/book”、&stats）；
int size=stats.st_size；
//将文件大小发送到客户端
发送（fd、大小、大小（int）、0）；
printf（“书面的”）；
无符号字符outdata[OUT1]；
in=打开（仅文件）；
to_read=大小；
char*bufptr=malloc（段大小）；
做
{
n=读取（英寸，bufptr，段大小）；
if（n<0）
{  
perror（“读取错误：”）；
}
初始中心（和状态，iv）；
AES加密（bufptr+200、outdata、字节加密和密钥、state.ivec、state.ecoount和state.num）；
memcpy（bufptr+200，输出数据，字节加密）；
发送=发送（fd，bufptr，n，0）；
to_read=to_read-n；
}while（to_read！=0）；
关闭（fd）；
}

我的服务器程序

#include "headers.h"
struct ctr_state {
    unsigned char ivec[16]; 
    unsigned int num;
    unsigned char ecount[16];
};
int init_ctr(struct ctr_state *state, const unsigned char iv[8])
{
    /* aes_ctr128_encrypt requires 'num' and 'ecount' set to zero on the
     * first call. */
    state->num = 0;
    memset(state->ecount, 0, 16);

    /* Initialise counter in 'ivec' to 0 */
    memset(state->ivec + 8, 0, 8);

    /* Copy IV into 'ivec' */
    memcpy(state->ivec, iv, 8);
}

int main(int argc, char* argv[])
{

size_t count;    
AES_KEY key;   
unsigned char ckey[] =  "/home/nandan/aes.key";
unsigned char iv[AES_BLOCK_SIZE];
struct ctr_state state;   
// validate proper usage
if (argc != 4)
{
    fprintf(stderr, "Usage %s <serverBindIP> <serverBindPort> <CredentialsFilePath>\n", argv[0]);
    exit(-1);
}

int server;
char* ip = argv[1];
int port = htons(atoi(argv[2]));
char* passwd_file = argv[3];
struct sockaddr_in server_addr, client_addr;
clock_t start, end;
double cpu_time_used, timer = 0;
int server_fd, client_fd, result;
socklen_t length;

// Create an internet domain TCP socket
server_fd = socket(AF_INET, SOCK_STREAM, 0);
if (server_fd == -1)
{
    fprintf(stderr, "Unable to create socket\n");
    exit(-1);
}

server_addr.sin_family = AF_INET;
server_addr.sin_port = port;
server_addr.sin_addr.s_addr = inet_addr(ip);

// bind socket to an network interface
result = bind(server_fd, (struct sockaddr*) &server_addr, sizeof(server_addr));
if (result == -1)
{
    fprintf(stderr, "Unable to bind socket\n");
    exit(-1);
}

// mark the socket used for incoming requests
listen(server_fd, 5);

// accept an incoming connection
printf("Waiting for incoming connection\n");
length = sizeof(client_addr);
client_fd = accept(server_fd, (struct sockaddr*) &client_addr, &length);/* accept connection as usual */
if (client_fd == -1)
{
fprintf(stderr, "Unable to accept peer connection\n");
exit(-1);
}  
printf("Connection: %s:%d\n",inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
  int tmp = 0,i,size = 0;  // read file size first
  unsigned char outdata[OUT1]; 
  recv(client_fd, &size, sizeof(int),0);
  printf("%d \n", size);
  int bytes_read = 0;
  int to_read = size;
  printf("%d \n", size);
  FILE* out = fopen("/tmp/x1.pdf", "wb");
  char *buffer = malloc(SEGMENT_SIZE);
   do 
   {
     bytes_read = recv(client_fd, buffer, sizeof(buffer),0);
     init_ctr(&state, iv);
     AES_ctr128_encrypt(buffer+200, outdata, BYTES_ENCRYPT, &key, state.ivec, state.ecount, &state.num);
     memcpy(buffer+200, outdata, BYTES_ENCRYPT);
     tmp = tmp + bytes_read;
    // save content to disk
     fwrite(buffer, 1, bytes_read, out);
   } while (tmp != size);
close(client_fd);         /* close socket */
return 0;
}

#包括“headers.h”
结构中心状态{
无符号字符ivec[16]；
无符号整数；
无符号字符计数[16]；
};
int init_ctr（struct ctr_state*state，const unsigned char iv[8]）
{
/*aes\u ctr128\u encrypt要求将服务器上的“num”和“ecoount”设置为零
*第一个电话*/
状态->数值=0；
memset（state->ecount，0,16）；
/*将“ivec”中的计数器初始化为0*/
memset（状态->ivec+8,0,8）；
/*将IV复制到“ivec”*/
memcpy（州->ivec，iv，8）；
}
int main（int argc，char*argv[]）
{
大小/数量；
AES_密钥；
无符号字符ckey[]=“/home/nandan/aes.key”；
无符号字符iv[AES_块大小]；
结构中心状态；
//验证正确使用
如果（argc！=4）
{
fprintf（stderr，“用法%s\n”，argv[0]）；
出口（-1）；
}
int服务器；
char*ip=argv[1]；
int port=htons（atoi（argv[2]）；
char*passwd_file=argv[3]；
服务器地址、客户端地址中的结构sockaddr\u；
时钟开始、结束；
使用双cpu时间，计时器=0；
int server_fd、client_fd、result；
袜子长度；
//创建internet域TCP套接字
服务器\u fd=socket（AF\u INET，SOCK\u STREAM，0）；
如果（服务器\u fd==-1）
{
fprintf（stderr，“无法创建套接字”\n）；
出口（-1）；
}
服务器地址sin家庭=AF网络；
服务器地址sin端口=端口；
服务器地址sin地址s地址=inet地址（ip）；
//将套接字绑定到网络接口
结果=绑定（server_fd，（struct sockaddr*）和server_addr，sizeof（server_addr））；
如果（结果==-1）
{
fprintf（stderr，“无法绑定套接字”\n）；
出口（-1）；
}
//标记用于传入请求的套接字
听（服务器\u fd，5）；
//接受传入连接
printf（“等待传入连接”）；
长度=sizeof（客户地址）；
client_fd=accept（server_fd，（struct sockaddr*）和client_addr，&length）；/*像往常一样接受连接*/
如果（客户端\u fd==-1）
{
fprintf（stderr，“无法接受对等连接”）；
出口（-1）；
}  
printf（“连接：%s:%d\n”、inet\u ntoa（客户端地址sin\u addr）、ntohs（客户端地址sin\u端口））；
int tmp=0，i，size=0；//首先读取文件大小
无符号字符outdata[OUT1]；
recv（客户的fd和尺寸，尺寸（整数），0）；
printf（“%d\n”，大小）；
int bytes_read=0；
int to_read=大小；
printf（“%d\n”，大小）；
文件*out=fopen（“/tmp/x1.pdf”，“wb”）；
char*buffer=malloc（段大小）；
做
{
字节读取=recv（客户机fd，缓冲区，sizeof（缓冲区），0）；
初始中心（和状态，iv）；
AES加密（缓冲区+200、输出数据、字节加密和密钥、state.ivec、state.ecoount和state.num）；
memcpy（缓冲区+200，输出数据，字节加密）；
tmp=tmp+字节\u读取；