LibTomcrypt Invalid input packet while decrypting

Question

Im trying to create an API from C to Lua for lua can use ecc_encrypt and decrypt from libtomcrypt, for it have the function encrypt that encrypt the mensage given by blocks and when im trying do decrypt it by blocks when it start the second block always get the error invalid input packet

This is my C code

#define LTM_DESC 
#include <tomcrypt.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "lua.h"
#include "lauxlib.h"

// variáveis globais
prng_state prng;
int err, prng_idx , hash_idx;

// criando a estrutura do output
typedef struct {
    unsigned long exported_key_len;
    unsigned long ctlen;
} Pair;

Pair pair;


static int gera_chave_lua(lua_State *L) {
    ecc_key mykey;
    unsigned char exported_key_public[1024];
    size_t exported_key_public_len = sizeof(exported_key_public);
    unsigned char exported_key_private[1024];
    size_t exported_key_private_len = sizeof(exported_key_private);

    if (register_prng(&yarrow_desc) == -1) {
        lua_pushstring(L, "Erro ao registrar Yarrow.");
        lua_error(L);
    }
    
    if (register_hash(&sha512_desc) == -1) {
        lua_pushstring(L, "Erro ao registrar sha256.");
        lua_error(L);
    }

    prng_idx = find_prng("yarrow");
    hash_idx = find_hash("sha512");

    if ((err = rng_make_prng(256, prng_idx ,&prng, NULL)) != CRYPT_OK) {
        lua_pushfstring(L, "Erro ao configurar PRNG: %s", error_to_string(err));
        lua_error(L);
    }

    if ((err = ecc_make_key(&prng, prng_idx, 65, &mykey)) != CRYPT_OK) {
        lua_pushfstring(L, "Erro ao criar a chave: %s", error_to_string(err));
        lua_error(L);
    }

    if ((err = ecc_export(exported_key_public ,&exported_key_public_len , PK_PUBLIC, &mykey)) != CRYPT_OK) {
        lua_pushfstring(L, "Erro ao exportar a chave pública: %s", error_to_string(err));
        lua_error(L);
    }

    if ((err = ecc_export(exported_key_private ,&exported_key_private_len , PK_PRIVATE, &mykey)) != CRYPT_OK) {
        lua_pushfstring(L, "Erro ao exportar a chave privada: %s", error_to_string(err));
        lua_error(L);
    }

    lua_pushlstring(L, (const char *)exported_key_public, exported_key_public_len);
    lua_pushlstring(L, (const char *)exported_key_private, exported_key_private_len);
    return 2;
}


// Alterações na função encriptar para receber texto e chave pública do Lua

static int encriptar_lua(lua_State *L) {
    ecc_key mykey;
    const char *plaintext = lua_tostring(L, 1);
    const char *pb_key = lua_tostring(L, 2);
    size_t ptlen = strlen(plaintext);
    size_t numBlocks = ptlen / 64 + ((ptlen % 64 != 0) ? 1 : 0); // Calcula o número de blocos necessários
    size_t blockCount = 1; // Contador do bloco atual
    size_t totalLen = numBlocks * 1024; // Tamanho total estimado do buffer

    unsigned char *buffer = (unsigned char *)malloc((totalLen + 1) * sizeof(unsigned char)); // Aloca memória para o buffer
    if (buffer == NULL) {
        lua_pushstring(L, "Erro ao alocar memória para o buffer.");
        lua_error(L);
    }

    size_t bufferIndex = 0;

    if ((err = ecc_import((unsigned char *)pb_key, &pair.exported_key_len, &mykey)) != CRYPT_OK) {
        free(buffer); // Libera a memória alocada para o buffer
        lua_pushfstring(L, "Erro ao importar a chave ECC: %s", error_to_string(err));
        lua_error(L);
    }

    while (ptlen > 0) {
        unsigned char ciphertext[1024];
        size_t ctlen = sizeof(ciphertext);
        size_t len = (ptlen > 64) ? 64 : ptlen; // Calcula o tamanho do bloco

        printf("entrei aqui x vezes\n");
        if ((err = ecc_encrypt_key((const unsigned char *)plaintext, len, ciphertext, &ctlen, &prng, prng_idx, hash_idx, &mykey)) != CRYPT_OK) {
            free(buffer); // Libera a memória alocada para o buffer
            lua_pushfstring(L, "Erro ao criptografar o texto: %s", error_to_string(err));
            lua_error(L);
        }

        // Adiciona os dados criptografados ao buffer
        memcpy(buffer + bufferIndex, ciphertext, ctlen);
        bufferIndex += ctlen;

        ptlen -= len;
        plaintext += len;
        blockCount++;
    }

    buffer[bufferIndex] = '\0'; // Adiciona o caractere nulo no final do buffer

    pair.ctlen = numBlocks; // Atualiza o número de blocos na estrutura Pair

    // Empurra a string resultante para a pilha Lua
    lua_pushlstring(L, (const char *)buffer, bufferIndex);

    free(buffer); // Libera a memória alocada para o buffer
    return 1;
}

// Função para descriptar o texto encriptado usando a chave privada
static int descriptar_lua(lua_State *L) {
    ecc_key mykey;
    const char *pv_key = lua_tostring(L, 1);
    const char *ciphertext = lua_tostring(L, 2);

    if ((err = ecc_import((unsigned char *)pv_key, &pair.exported_key_len, &mykey)) != CRYPT_OK) {
        lua_pushfstring(L, "Erro ao importar a chave ECC: %s", error_to_string(err));
        lua_error(L);
    }

    int blockCount = pair.ctlen; // Número de blocos salvos na estrutura Pair
    size_t totalLen = blockCount * 1024; // Tamanho total estimado do texto descriptografado

    unsigned char *buffer = (unsigned char *)malloc((totalLen + 1) * sizeof(unsigned char)); // Aloca memória para o buffer
    if (buffer == NULL) {
        lua_pushstring(L, "Erro ao alocar memória para o buffer.");
        lua_error(L);
    }

    size_t bufferIndex = 0;

    for (int i = 0; i < blockCount; ++i) {
        unsigned char plaintext[1024];
        size_t ptlen = sizeof(plaintext);

        if ((err = ecc_decrypt_key((const unsigned char *)(ciphertext + i * 1024), 1024, plaintext, &ptlen, &mykey)) != CRYPT_OK) {
            free(buffer); // Libera a memória alocada para o buffer
            lua_pushfstring(L, "Erro ao descriptografar o texto: %s", error_to_string(err));
            lua_error(L);
        }

        // Adiciona os dados descriptografados ao buffer
        memcpy(buffer + bufferIndex, plaintext, ptlen);
        bufferIndex += ptlen;
    }

    buffer[bufferIndex] = '\0'; // Adiciona o caractere nulo no final do buffer

    // Empurra a string resultante para a pilha Lua
    lua_pushlstring(L, (const char *)buffer, bufferIndex);

    free(buffer); // Libera a memória alocada para o buffer
    return 1;
}



int luaopen_mylib(lua_State *L) {
    luaL_Reg funcs[] = {
        {"gera_chave_lua", gera_chave_lua},
        {"encriptar_lua", encriptar_lua},
        {"descriptar_lua", descriptar_lua},
        {NULL, NULL}
    };
    luaL_newlib(L, funcs);
    return 1;
}

int main(void) {
    ltc_mp = ltm_desc;

    lua_State *L = luaL_newstate();
    luaL_openlibs(L);
    luaL_requiref(L, "mylib", luaopen_mylib, 1);

    if (luaL_dofile(L, "teste_lua.lua")) {
        printf("Erro ao executar o arquivo Lua: %s\n", lua_tostring(L, -1));
        lua_pop(L, 1);
    }

    lua_close(L);

    return 0;
}

local mylib = require("mylib")

-- Gera chave
local pub_key, prv_key = mylib.gera_chave_lua()

print("Chave Pública:")
print(pub_key)
print("\nChave Privada:")
print(prv_key)

-- Encripta um texto usando a chave pública
local texto_original = "MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM"
print("\nO texto original é")
print(texto_original)
local texto_encriptado = mylib.encriptar_lua(texto_original, pub_key)

print("\nTexto Encriptado:")
print(texto_encriptado)

-- Descriptografa o texto encriptado usando a chave privada
local texto_descriptado = mylib.descriptar_lua(prv_key, texto_encriptado)

print("\nTexto Descriptado:")
print(texto_descriptado)

In my Lua code if I write one mode "M" it will create another block and then error

gcc -I/usr/include/lua5.3 to_lua.c -o to_lua -ltomcrypt -llua5.3

This is how Im compiling