github/chiaki
1
0
Fork 0
mirror of https://git.sr.ht/~thestr4ng3r/chiaki synced 2025-08-21 14:03:11 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add LoginPINDialog

Browse source
This commit is contained in:
Florian Märkl 2019-08-25 16:38:13 +02:00
commit 31fb11fd43
No known key found for this signature in database
GPG key ID: 125BC8A5A6A1E857
13 changed files with 208 additions and 26 deletions
Download patch file Download diff file Expand all files Collapse all files

4
lib/include/chiaki/ctrl.h
View file

@ -40,7 +40,7 @@ typedef struct chiaki_ctrl_t
bool should_stop;
bool login_pin_entered;
uint8_t *login_pin; // not owned
uint8_t *login_pin;
size_t login_pin_size;
ChiakiStopPipe notif_pipe;
ChiakiMutex notif_mutex;
@ -55,7 +55,7 @@ typedef struct chiaki_ctrl_t
CHIAKI_EXPORT ChiakiErrorCode chiaki_ctrl_start(ChiakiCtrl *ctrl, struct chiaki_session_t *session);
CHIAKI_EXPORT void chiaki_ctrl_stop(ChiakiCtrl *ctrl);
CHIAKI_EXPORT ChiakiErrorCode chiaki_ctrl_join(ChiakiCtrl *ctrl);
CHIAKI_EXPORT void chiaki_ctrl_set_login_pin(ChiakiCtrl *ctrl, uint8_t *pin, size_t pin_size);
CHIAKI_EXPORT void chiaki_ctrl_set_login_pin(ChiakiCtrl *ctrl, const uint8_t *pin, size_t pin_size);
#ifdef __cplusplus
}

4
lib/include/chiaki/rpcrypt.h
View file

@ -41,8 +41,8 @@ CHIAKI_EXPORT void chiaki_rpcrypt_aeropause(uint8_t *aeropause, const uint8_t *a
CHIAKI_EXPORT void chiaki_rpcrypt_init_auth(ChiakiRPCrypt *rpcrypt, const uint8_t *nonce, const uint8_t *morning);
CHIAKI_EXPORT void chiaki_rpcrypt_init_regist(ChiakiRPCrypt *rpcrypt, const uint8_t *ambassador, uint32_t pin);
CHIAKI_EXPORT ChiakiErrorCode chiaki_rpcrypt_generate_iv(ChiakiRPCrypt *rpcrypt, uint8_t *iv, uint64_t counter);
CHIAKI_EXPORT ChiakiErrorCode chiaki_rpcrypt_encrypt(ChiakiRPCrypt *rpcrypt, uint64_t counter, uint8_t *in, uint8_t *out, size_t sz);
CHIAKI_EXPORT ChiakiErrorCode chiaki_rpcrypt_decrypt(ChiakiRPCrypt *rpcrypt, uint64_t counter, uint8_t *in, uint8_t *out, size_t sz);
CHIAKI_EXPORT ChiakiErrorCode chiaki_rpcrypt_encrypt(ChiakiRPCrypt *rpcrypt, uint64_t counter, const uint8_t *in, uint8_t *out, size_t sz);
CHIAKI_EXPORT ChiakiErrorCode chiaki_rpcrypt_decrypt(ChiakiRPCrypt *rpcrypt, uint64_t counter, const uint8_t *in, uint8_t *out, size_t sz);
#ifdef __cplusplus
}

2
lib/include/chiaki/session.h
View file

@ -198,7 +198,7 @@ CHIAKI_EXPORT ChiakiErrorCode chiaki_session_start(ChiakiSession *session);
CHIAKI_EXPORT ChiakiErrorCode chiaki_session_stop(ChiakiSession *session);
CHIAKI_EXPORT ChiakiErrorCode chiaki_session_join(ChiakiSession *session);
CHIAKI_EXPORT ChiakiErrorCode chiaki_session_set_controller_state(ChiakiSession *session, ChiakiControllerState *state);
CHIAKI_EXPORT ChiakiErrorCode chiaki_session_set_login_pin(ChiakiSession *session, uint8_t *pin, size_t pin_size);
CHIAKI_EXPORT ChiakiErrorCode chiaki_session_set_login_pin(ChiakiSession *session, const uint8_t *pin, size_t pin_size);
static inline void chiaki_session_set_event_cb(ChiakiSession *session, ChiakiEventCallback cb, void *user)
{

41
lib/src/ctrl.c
View file

@ -104,15 +104,22 @@ CHIAKI_EXPORT ChiakiErrorCode chiaki_ctrl_join(ChiakiCtrl *ctrl)
ChiakiErrorCode err = chiaki_thread_join(&ctrl->thread, NULL);
chiaki_stop_pipe_fini(&ctrl->notif_pipe);
chiaki_mutex_fini(&ctrl->notif_mutex);
free(ctrl->login_pin);
return err;
}
CHIAKI_EXPORT void chiaki_ctrl_set_login_pin(ChiakiCtrl *ctrl, uint8_t *pin, size_t pin_size)
CHIAKI_EXPORT void chiaki_ctrl_set_login_pin(ChiakiCtrl *ctrl, const uint8_t *pin, size_t pin_size)
{
uint8_t *buf = malloc(pin_size);
if(!buf)
return;
memcpy(buf, pin, pin_size);
ChiakiErrorCode err = chiaki_mutex_lock(&ctrl->notif_mutex);
assert(err == CHIAKI_ERR_SUCCESS);
if(ctrl->login_pin_entered)
free(ctrl->login_pin);
ctrl->login_pin_entered = true;
ctrl->login_pin = pin;
ctrl->login_pin = buf;
ctrl->login_pin_size = pin_size;
chiaki_stop_pipe_stop(&ctrl->notif_pipe);
chiaki_mutex_unlock(&ctrl->notif_mutex);
@ -194,8 +201,12 @@ static void *ctrl_thread_func(void *user)
if(ctrl->login_pin_entered)
{
CHIAKI_LOGI(ctrl->session->log, "Ctrl received entered Login PIN, sending to console");
ctrl_message_send(ctrl, CTRL_MESSAGE_TYPE_LOGIN_PIN_REP, ctrl->login_pin, ctrl->login_pin_size);
ctrl->login_pin_entered = false;
free(ctrl->login_pin);
ctrl->login_pin = NULL;
ctrl->login_pin_size = 0;
chiaki_stop_pipe_reset(&ctrl->notif_pipe);
}
else
@ -232,6 +243,21 @@ static ChiakiErrorCode ctrl_message_send(ChiakiCtrl *ctrl, CtrlMessageType type,
{
assert(payload_size == 0 || payload);
uint8_t *enc = NULL;
if(payload && payload_size)
{
enc = malloc(payload_size);
if(!enc)
return CHIAKI_ERR_MEMORY;
ChiakiErrorCode err = chiaki_rpcrypt_encrypt(&ctrl->session->rpcrypt, ctrl->crypt_counter_local++, payload, enc, payload_size);
if(err != CHIAKI_ERR_SUCCESS)
{
CHIAKI_LOGE(ctrl->session->log, "Ctrl failed to encrypt payload");
free(enc);
return err;
}
}
uint8_t header[8];
*((uint32_t *)header) = htonl((uint32_t)payload_size);
*((uint16_t *)(header + 4)) = htons(type);
@ -244,9 +270,10 @@ static ChiakiErrorCode ctrl_message_send(ChiakiCtrl *ctrl, CtrlMessageType type,
return CHIAKI_ERR_NETWORK;
}
if(payload)
if(enc)
{
sent = send(ctrl->sock, payload, payload_size, 0);
sent = send(ctrl->sock, enc, payload_size, 0);
free(enc);
if(sent < 0)
{
CHIAKI_LOGE(ctrl->session->log, "Failed to send Ctrl Message Payload");
@ -437,7 +464,7 @@ static ChiakiErrorCode ctrl_connect(ChiakiCtrl *ctrl)
uint8_t auth_enc[CHIAKI_RPCRYPT_KEY_SIZE];
ChiakiErrorCode err = chiaki_rpcrypt_encrypt(&session->rpcrypt, ctrl->crypt_counter_local++, (uint8_t *)session->connect_info.regist_key, auth_enc, CHIAKI_RPCRYPT_KEY_SIZE);
ChiakiErrorCode err = chiaki_rpcrypt_encrypt(&session->rpcrypt, ctrl->crypt_counter_local++, (const uint8_t *)session->connect_info.regist_key, auth_enc, CHIAKI_RPCRYPT_KEY_SIZE);
if(err != CHIAKI_ERR_SUCCESS)
goto error;
char auth_b64[CHIAKI_RPCRYPT_KEY_SIZE*2];
@ -446,7 +473,7 @@ static ChiakiErrorCode ctrl_connect(ChiakiCtrl *ctrl)
goto error;
uint8_t did_enc[CHIAKI_RP_DID_SIZE];
err = chiaki_rpcrypt_encrypt(&session->rpcrypt, ctrl->crypt_counter_local++, (uint8_t *)session->connect_info.did, did_enc, CHIAKI_RP_DID_SIZE);
err = chiaki_rpcrypt_encrypt(&session->rpcrypt, ctrl->crypt_counter_local++, session->connect_info.did, did_enc, CHIAKI_RP_DID_SIZE);
if(err != CHIAKI_ERR_SUCCESS)
goto error;
char did_b64[CHIAKI_RP_DID_SIZE*2];
@ -458,7 +485,7 @@ static ChiakiErrorCode ctrl_connect(ChiakiCtrl *ctrl)
size_t ostype_len = strlen(SESSION_OSTYPE) + 1;
if(ostype_len > sizeof(ostype_enc))
goto error;
err = chiaki_rpcrypt_encrypt(&session->rpcrypt, ctrl->crypt_counter_local++, (uint8_t *)SESSION_OSTYPE, ostype_enc, ostype_len);
err = chiaki_rpcrypt_encrypt(&session->rpcrypt, ctrl->crypt_counter_local++, (const uint8_t *)SESSION_OSTYPE, ostype_enc, ostype_len);
if(err != CHIAKI_ERR_SUCCESS)
goto error;
char ostype_b64[256];

6
lib/src/rpcrypt.c
View file

@ -104,7 +104,7 @@ CHIAKI_EXPORT ChiakiErrorCode chiaki_rpcrypt_generate_iv(ChiakiRPCrypt *rpcrypt,
return CHIAKI_ERR_SUCCESS;
}
static ChiakiErrorCode chiaki_rpcrypt_crypt(ChiakiRPCrypt *rpcrypt, uint64_t counter, uint8_t *in, uint8_t *out, size_t sz, bool encrypt)
static ChiakiErrorCode chiaki_rpcrypt_crypt(ChiakiRPCrypt *rpcrypt, uint64_t counter, const uint8_t *in, uint8_t *out, size_t sz, bool encrypt)
{
EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
if(!ctx)
@ -151,12 +151,12 @@ static ChiakiErrorCode chiaki_rpcrypt_crypt(ChiakiRPCrypt *rpcrypt, uint64_t cou
return CHIAKI_ERR_SUCCESS;
}
CHIAKI_EXPORT ChiakiErrorCode chiaki_rpcrypt_encrypt(ChiakiRPCrypt *rpcrypt, uint64_t counter, uint8_t *in, uint8_t *out, size_t sz)
CHIAKI_EXPORT ChiakiErrorCode chiaki_rpcrypt_encrypt(ChiakiRPCrypt *rpcrypt, uint64_t counter, const uint8_t *in, uint8_t *out, size_t sz)
{
return chiaki_rpcrypt_crypt(rpcrypt, counter, in, out, sz, true);
}
CHIAKI_EXPORT ChiakiErrorCode chiaki_rpcrypt_decrypt(ChiakiRPCrypt *rpcrypt, uint64_t counter, uint8_t *in, uint8_t *out, size_t sz)
CHIAKI_EXPORT ChiakiErrorCode chiaki_rpcrypt_decrypt(ChiakiRPCrypt *rpcrypt, uint64_t counter, const uint8_t *in, uint8_t *out, size_t sz)
{
return chiaki_rpcrypt_crypt(rpcrypt, counter, in, out, sz, false);
}

19
lib/src/session.c
View file

@ -258,12 +258,12 @@ CHIAKI_EXPORT ChiakiErrorCode chiaki_session_set_controller_state(ChiakiSession
return CHIAKI_ERR_SUCCESS;
}
CHIAKI_EXPORT ChiakiErrorCode chiaki_session_set_login_pin(ChiakiSession *session, uint8_t *pin, size_t pin_size)
CHIAKI_EXPORT ChiakiErrorCode chiaki_session_set_login_pin(ChiakiSession *session, const uint8_t *pin, size_t pin_size)
{
uint8_t *buf = malloc(pin_size);
memcpy(buf, pin, pin_size);
if(!buf)
return CHIAKI_ERR_MEMORY;
memcpy(buf, pin, pin_size);
ChiakiErrorCode err = chiaki_mutex_lock(&session->state_mutex);
assert(err == CHIAKI_ERR_SUCCESS);
if(session->login_pin_entered)
@ -272,6 +272,8 @@ CHIAKI_EXPORT ChiakiErrorCode chiaki_session_set_login_pin(ChiakiSession *sessio
session->login_pin = buf;
session->login_pin_size = pin_size;
chiaki_mutex_unlock(&session->state_mutex);
chiaki_cond_signal(&session->state_cond);
return CHIAKI_ERR_SUCCESS;
}
static void session_send_event(ChiakiSession *session, ChiakiEvent *event)
@ -308,6 +310,14 @@ static bool session_check_state_pred_pin(void *user)
|| session->login_pin_entered;
}
static bool session_check_state_pred_session_id(void *user)
{
ChiakiSession *session = user;
return session->should_stop
|| session->ctrl_failed
|| session->ctrl_session_id_received;
}
#define ENABLE_SENKUSHA
static void *session_thread_func(void *arg)
@ -369,11 +379,16 @@ static void *session_thread_func(void *arg)
goto ctrl_failed;
assert(session->login_pin_entered && session->login_pin);
CHIAKI_LOGI(session->log, "Session received entered Login PIN, forwarding to Ctrl");
chiaki_ctrl_set_login_pin(&session->ctrl, session->login_pin, session->login_pin_size);
session->login_pin_entered = false;
free(session->login_pin);
session->login_pin = NULL;
session->login_pin_size = 0;
// wait for session id again
chiaki_cond_timedwait_pred(&session->state_cond, &session->state_mutex, SESSION_EXPECT_TIMEOUT_MS, session_check_state_pred_session_id, session);
CHECK_STOP(quit_ctrl);
}
if(!session->ctrl_session_id_received)