inline buffer rsa_key::public_encrypt(const buffer& buf, int padding) const
{
buffer result(size());
result.data().resize(public_encrypt(buffer_cast<uint8_t>(result), buffer_size(result), buffer_cast<uint8_t>(buf), buffer_size(buf), padding));
return result;
}
void ftp_rsauser(t_client *client, char *str)
{
char *arg;
char filename[4096];
char trame[4096];
unsigned char encrypted[4096];
unsigned char *randstr;
int len;
arg = get_cmd(str, 7);
if (atoi(client->server->conf->ssl_enabled) == 0 ||
atoi(client->server->conf->ssl_fconnect) == 0)
return (ssl_not_actived(client));
sprintf(filename, "/etc/bertomzilla/.rsa/%s.pub", arg);
if (!fill_publicKeyFromScratch(client, filename))
return (show_error("Error while filling RSA File"));
randstr = randstring(16);
len = public_encrypt(randstr, 16, client->publicKeyRSA, encrypted);
post(trame, len, client, encrypted);
if (!strncmp(trame, (const char*) randstr, 16))
process_ok(client, arg);
else
write(client->fd, "KO\r\n", 4);
}
static void init_loop_cb(struct uloop_timeout *timeout)
{
uint32_t id;
// replace *d
char key_iv[32] = {0};
char repeater_pubkey[] = "-----BEGIN PUBLIC KEY-----\n"\
"MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAyUF9+Td53E0lEqP8eRyM\n"\
"DoREPIety4BJscApuPwcGxiVA+75mYw8AFKlTaWlLL7w/qyuxnOiNm6TTFCxJGI1\n"\
"C9GnABm8myC5hnDSC6qE+E1Al6wZgyI4rkC+Qr7GFI9B8r9bM+RdKyMxD9JuXUcx\n"\
"+rx/TPnJttUfAkCloYStd5LiCel6c/bfWiR5hyxLjXC5Cz5cdpzXwvyvgEBvZHxX\n"\
"A5jqPVfWcJ3P3s88ogPxx52iM4dzLtzWB6BOmZA/3SbvZle2Efy7mVAl/9gkwvgf\n"\
"Dm/TSnMbnUBim3H5CIlECsvs2RuvI5og0S3oEO4B8TQQjujSqbA6h+EcZc9Djmh2\n"\
"vQIDAQAB\n"\
"-----END PUBLIC KEY-----\n";
unsigned char *encrypted=malloc(MAX_ALLOC_LEN);
unsigned char *base64=malloc(MAX_ALLOC_LEN);
RAND_seed(rnd_seed, sizeof rnd_seed); /* or RSA_PKCS1_PADDING/OAEP may fail */
random_uuid(repeater_key);
random_uuid(repeater_iv);
memcpy(key_iv, repeater_key, 16);
memcpy(key_iv+16, repeater_iv, 16);
int encrypted_length= public_encrypt(key_iv,
32,
repeater_pubkey,
encrypted);
if(encrypted_length == -1)
{
printLastError("Public Encrypt failed ");
exit(0);
}
printf("Encrypted length =%d\n",encrypted_length);
printf("Try to init_loop_cb...\n");
int base64_length = base64Encode(base64, encrypted, encrypted_length);
// printf("base64 len: %d\n", base64_length);
// printf("base64: %s\n", base64);
if(ubus_lookup_id(sys->tbus_ctx, "netapi", &id)){
dlog("can't lookup netapi\n");
goto fail;
}
blob_buf_init(&traffic_b, 0);
blobmsg_add_field(&traffic_b, BLOBMSG_TYPE_UNSPEC,
"data", base64, base64_length);
ubus_invoke(sys->tbus_ctx, id, "init", traffic_b.head,
receive_call_result_data, NULL, TRAFFICD_INIT_TIMEOUT);
free(encrypted);
free(base64);
return;
fail:
free(encrypted);
free(base64);
uloop_timeout_set(&sd->timeout_init, TRAFFICD_INIT_LOOP_TIME);
}
int main(int argc, char *argv[]){
int listenfd = 0, connfd = 0;
struct sockaddr_in serv_addr;
char sendBuff[1025];
//time_t ticks;
long randomID=0;
long randomPC=0;
listenfd = socket(AF_INET, SOCK_STREAM, 0);
memset(&serv_addr, '0', sizeof(serv_addr));
memset(sendBuff, '0', sizeof(sendBuff));
serv_addr.sin_family = AF_INET;
//serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
//serv_addr.sin_addr.s_addr = inet_addr("192.168.7.2");
serv_addr.sin_port = htons(5000);
bind(listenfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
listen(listenfd, 10);
char canRead = 0;
unsigned char ContinueFSMDoWhile = TRUE;
int bytesReceived = 0;
while(1){
connfd = accept(listenfd, (struct sockaddr*)NULL, NULL);
ContinueFSMDoWhile = TRUE;
printf("conexion aceptada :)\n");
*tempBufferRx = 0;
// Identifier server FSM
do{
if(canRead){
printf("Before read server\n");
bytesReceived = read(connfd,bufferRx,255); // <== read
printf("server after read\n"); fflush(stdout);
//printf("After read server:[%s]\n",bufferRx);
}else{
canRead = TRUE;
}
switch(statusSwServer){
case ENVIO_RANDOM_ID:{ // 1.
printf("1. CASE 1\n"); fflush(stdout);
srand( time(NULL) );
randomID = rand() % 16777215;
printf("1. randomID from server:[%li]\n",randomID);
// char conversion to encrypt
sprintf(dataBuffer,"%li",randomID);
int encrypted_length = public_encrypt((unsigned char *)dataBuffer,strlen(dataBuffer),(unsigned char *)(PATH_PUBLIC_KEY_CLIENT) ,encryptedServer);
if(encrypted_length == -1){
printLastError("Public Encrypt failed\n");
exit(0);
}
printf("1. Encrypted length = [%d]\n",encrypted_length);
contWrite = 0;
tempContWrite = 0;
do{
if( (tempContWrite = write(connfd,encryptedServer,encrypted_length)) > 0 ){
contWrite += tempContWrite;
printf("1. written:[%d]\n",contWrite);
}else{
printf("1. Error writting\n");
}
}while(contWrite < encrypted_length);
statusSwServer = RECEIVE_PC_CODE;
break;
}
case RECEIVE_PC_CODE:{ // 3.
char * pch;
char cont = 0;
long randomIDTemp = 0;
printf("3. CASE 3\n"); fflush(stdout);
// Buffering
printf("bytesReceived:[%d]\n",bytesReceived);
if( strlen(tempBufferRx) == 0 ){
strcpy(tempBufferRx,bufferRx);
}else{
strcat(tempBufferRx, bufferRx);
strcpy(bufferRx, tempBufferRx);
}
// Decrypt info
decrypted_length = private_decrypt((unsigned char *)(bufferRx),/*strlen(bufferRx)*/128,(unsigned char *)(PATH_PRIVATE_KEY_SERVER),decryptedClient);
if(decrypted_length == -1){
printLastError("Private Decrypt failed\n");
//exit(0);
break;
}
decryptedClient[decrypted_length] = '\0';
printf("3. Decrypted Length = [%d]\n",decrypted_length);
printf("3. Decrypted Text = [%s]\n",decryptedClient);
strcpy(bufferRx,(char *)(decryptedClient));
printf ("3. Splitting string \"%s\" into tokens:\n",bufferRx);
pch = strtok (bufferRx,"$");
while (pch != NULL){
printf ("%s\n",pch);
switch(cont){
case 0:{
strcpy(ClientCode,pch);
break;
}
case 1:{
randomIDTemp = atol(pch);
break;
}
case 2:{
randomPC = atol(pch);
break;
}
default:{
printf("RECEIVE_PC_CODE SWITCH: It shouldn't be here\n");
}
}
cont++;
pch = strtok (NULL,"$");
}
// Validacion de la información llegada.
if( strstr(CLIENT_CODE,ClientCode) != NULL ){
printf("3. Ok server client code\n");
}else{
printf("3. ClientCode no OK :(\n");
}
if( randomIDTemp == randomID ){
printf("3. Ok server randomID\n");
}else{
printf("3. randomID no OK :(\n");
}
sprintf(bufferRx,"%s$%li$%li",SERVER_CODE,randomID,randomPC);
encrypted_length = public_encrypt((unsigned char *)bufferRx,strlen(bufferRx),(unsigned char *)(PATH_PUBLIC_KEY_CLIENT) ,encryptedServer);
if(encrypted_length == -1){
printLastError("Public Encrypt failed ");
exit(0);
}
contWrite = 0;
tempContWrite = 0;
do{
if( (tempContWrite = write(connfd,encryptedServer,encrypted_length)) > 0 ){
contWrite += tempContWrite;
printf("3. written:[%d]\n",contWrite);
}else{
printf("3. Error writting\n");
}
}while(contWrite < encrypted_length);
ContinueFSMDoWhile = FALSE;
break;
}
default:{
printf("Default server fsm: It shouldn't be here\n");
}
}
}while(ContinueFSMDoWhile);
printf("End FSM, waiting new connection.\n");
ContinueFSMDoWhile = TRUE;
canRead = FALSE;
statusSwServer = ENVIO_RANDOM_ID;
// Identifier server FSM
sleep(1);
}
}
