ascii-chat
Binary v0.16.50-198-g78f51665f
Library lib/v0.3.2-2240-g78f51665f
Video chat in your terminal
Loading...
Searching...
No Matches
lib/network/browser/session.c
Go to the documentation of this file.
9#include <emscripten.h>
10#include <string.h>
11
20
22 if (!peer)
23 return "Browser session is closed";
24 if (HAS_ERRNO(&peer->error))
25 return peer->error.context_message;
26 return "Peer security operation failed";
27}
28
33
35 if (!peer)
36 return;
40 SAFE_FREE(peer);
41}
42
43browser_session_t *browser_session_create(bool server, int encryption, const char *password, const uint8_t *identity, const uint8_t *expected_key) {
44 browser_session_t *peer = SAFE_CALLOC(1, sizeof(*peer), browser_session_t *);
45 if (!peer) {
46 SET_ERRNO(ERROR_MEMORY, "Cannot allocate peer security state");
47 return NULL;
48 }
49 crypto_policy_t policy = {.transport_secure = true,
50 .encrypt = encryption == 1,
51 .no_encrypt = encryption == 0,
52 .has_password = password && password[0],
53 .has_identity = identity != NULL,
54 .has_verification_key = expected_key != NULL};
55 asciichat_error_t result = crypto_policy_resolve(&policy, &peer->security.mode);
57 peer->security.require_encryption = policy.encrypt;
59 if (result == ASCIICHAT_OK)
60 result = policy.has_password ? crypto_handshake_init_with_password("browser_peer", ctx, server, password) : crypto_handshake_init("browser_peer", ctx, server);
61 if (result != ASCIICHAT_OK) {
63 return NULL;
64 }
65 if (identity) {
66 private_key_t *key = server ? &ctx->server_private_key : &ctx->client_private_key;
67 public_key_t *public_key = server ? &ctx->server_public_key : &ctx->client_public_key;
69 memcpy(key->key.ed25519, identity, ED25519_PRIVATE_KEY_SIZE);
71 public_key->type = KEY_TYPE_ED25519;
72 memcpy(public_key->key, identity + ED25519_SEED_SIZE, ED25519_PUBLIC_KEY_SIZE);
73 }
74 if (expected_key && server) {
76 if (!ctx->client_whitelist) {
78 SET_ERRNO(ERROR_MEMORY, "Cannot allocate peer key whitelist");
79 return NULL;
80 }
82 memcpy(ctx->client_whitelist[0].key, expected_key, ED25519_PUBLIC_KEY_SIZE);
84 ctx->require_client_auth = true;
85 } else if (expected_key) {
86 ctx->verify_server_key = true;
88 memcpy(ctx->expected_server_key_bytes, expected_key, ED25519_PUBLIC_KEY_SIZE);
89 }
91 if (!peer->browser) {
93 return NULL;
94 }
95 // The browser owns the actual WebSocket/WebRTC channel. It must explicitly
96 // publish that channel's state; the transport is not connected merely
97 // because its C object exists.
98 return peer;
99}
100
102 if (!peer)
103 return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid peer security state");
105}
106
108 if (peer)
110}
111
113 return peer && peer->security.ready;
114}
115
117 return peer ? browser_transport_queued_bytes(peer->browser) : 0;
118}
119
120bool browser_session_writable(const browser_session_t *peer, size_t additional_bytes) {
121 return peer && browser_transport_writable(peer->browser, additional_bytes);
122}
123
125 return peer ? browser_transport_output_data(peer->browser) : NULL;
126}
127
131
133 return peer ? peer->received : NULL;
134}
135
137 return peer ? peer->received_length : 0;
138}
139
140asciichat_error_t browser_session_send(browser_session_t *peer, const void *data, size_t length) {
141 if (!peer || !data || !length)
142 return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid peer packet or security state");
143 if (!peer->security.ready)
144 return SET_ERRNO(ERROR_INVALID_STATE, "Peer security is not ready");
145 return acip_transport_send(browser_transport_base(peer->browser), data, length);
146}
147
148asciichat_error_t browser_session_receive(browser_session_t *peer, const void *data, size_t length) {
149 if (!peer || !data)
150 return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid peer packet or security state");
151 if (length < sizeof(packet_header_t))
152 return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid peer packet");
154 peer->received = NULL;
155 peer->received_length = 0;
156 packet_header_t header;
157 memcpy(&header, data, sizeof(header));
158 size_t payload_length = length - sizeof(header);
159 const void *payload = (const uint8_t *)data + sizeof(header);
160 packet_type_t type = NET_TO_HOST_U16(header.type);
161 asciichat_error_t validation = packet_validate(data, length, 0, NULL);
162 if (validation != ASCIICHAT_OK)
163 return validation;
164 if (!peer->security.ready) {
165 asciichat_error_t result = acip_security_receive(&peer->security, browser_transport_base(peer->browser), type, payload, payload_length);
166 if (result != ASCIICHAT_OK || !peer->quic_handshake || type != PACKET_TYPE_PROTOCOL_VERSION)
167 return result;
177 if (result != ASCIICHAT_OK || !caps.requires_verification)
178 return result;
180 }
181 bool encrypt = ACIP_CRYPTO_HAS_ENCRYPT(peer->security.mode);
182 if (packet_is_initial_handshake_type(type) || (encrypt != (type == PACKET_TYPE_ENCRYPTED)))
183 return SET_ERRNO(ERROR_CRYPTO, "Peer packet does not match negotiated security");
184 if (!encrypt) {
185 peer->received = buffer_alloc(NULL, length);
186 if (!peer->received)
187 return SET_ERRNO(ERROR_MEMORY, "Cannot allocate peer input");
188 memcpy(peer->received, data, length);
189 peer->received_length = length;
190 return ASCIICHAT_OK;
191 }
192 bool consumed = false;
193 uint64_t sequence;
195 &peer->received_length, &sequence, &consumed);
196 if (consumed) {
198 peer->received = NULL;
199 peer->received_length = 0;
200 }
201 return result;
202}
203
205 if (!peer)
206 return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid peer security state");
207 if (!peer->security.ready || peer->quic_handshake || !ACIP_CRYPTO_HAS_ENCRYPT(peer->security.mode))
208 return ASCIICHAT_OK;
210}
211
213 if (!peer || peer->security.version_received || peer->quic_handshake || !ACIP_CRYPTO_HAS_ENCRYPT(peer->security.mode))
214 return SET_ERRNO(ERROR_INVALID_STATE, "Invalid peer QUIC handshake transition");
215 peer->quic_handshake = true;
216 return ASCIICHAT_OK;
217}
218
222
223asciichat_error_t browser_session_security_packet(browser_session_t *peer, bool seal, uint32_t channel, uint32_t delivery, const uint8_t *packet, size_t length, uint8_t *output, size_t capacity,
224 size_t *out_length, uint64_t *sequence) {
225 return peer ? browser_transport_security_packet(peer->browser, seal, channel, delivery, packet, length, output, capacity, out_length, sequence)
226 : SET_ERRNO(ERROR_INVALID_STATE, "Browser session is closed");
227}
228
232
233asciichat_error_t browser_session_security_output(browser_session_t *peer, uint8_t *output, size_t capacity, size_t *length, uint32_t *channel) {
234 return peer ? browser_transport_security_output(peer->browser, output, capacity, length, channel) : SET_ERRNO(ERROR_INVALID_STATE, "Browser session is closed");
235}
236
#define SET_ERRNO(code,...)
#define HAS_ERRNO(context)
browser_transport_t * browser_transport_create(void)
asciichat_error_t browser_transport_security_output(browser_transport_t *browser, uint8_t *output, size_t capacity, size_t *length, uint32_t *channel)
size_t browser_transport_output_size(browser_transport_t *browser)
asciichat_error_t browser_transport_security_init(browser_transport_t *browser)
acip_transport_t * browser_transport_base(browser_transport_t *browser)
bool browser_transport_writable(const browser_transport_t *browser, size_t additional_bytes)
asciichat_error_t browser_transport_security_packet(browser_transport_t *browser, bool seal, uint32_t channel, uint32_t delivery, const uint8_t *packet, size_t length, uint8_t *output, size_t capacity, size_t *out_length, uint64_t *sequence)
double browser_transport_security_epoch(browser_transport_t *browser)
size_t browser_transport_queued_bytes(const browser_transport_t *browser)
asciichat_error_t browser_transport_security_tick(browser_transport_t *browser)
const void * browser_transport_output_data(browser_transport_t *browser)
void browser_transport_set_connected(browser_transport_t *browser, bool connected)
void browser_transport_output_pop(browser_transport_t *browser)
void browser_transport_destroy(browser_transport_t *browser)
void * buffer_alloc(buffer_domain_t *domain, size_t size)
Definition buffer.c:272
#define buffer_release(data)
Definition buffer.h:99
asciichat_error_t crypto_handshake_init(const char *name, crypto_handshake_context_t *ctx, bool is_server)
Initialize named crypto handshake context.
asciichat_error_t crypto_handshake_init_with_password(const char *name, crypto_handshake_context_t *ctx, bool is_server, const char *password)
Initialize named crypto handshake context with password authentication.
🔄 Network byte order conversion helpers
#define HOST_TO_NET_U16(val)
Definition endian.h:100
#define NET_TO_HOST_U16(val)
Definition endian.h:115
unsigned int uint32_t
#define SAFE_FREE(ptr)
#define SAFE_CALLOC(count, size, cast)
unsigned long long uint64_t
unsigned char uint8_t
asciichat_error_t
Error and exit codes - unified status values (0-255).
Definition error_codes.h:48
@ ERROR_INVALID_STATE
@ ERROR_NETWORK_PROTOCOL
Definition error_codes.h:80
@ ERROR_MEMORY
Definition error_codes.h:55
@ ASCIICHAT_OK
Definition error_codes.h:50
@ ERROR_CRYPTO
Definition error_codes.h:97
@ ERROR_INVALID_PARAM
uint8_t key[CRYPTO_PUBLIC_KEY_SIZE]
Definition key_types.h:78
uint8_t ed25519[ED25519_PRIVATE_KEY_SIZE]
Definition key_types.h:104
key_type_t type
Definition key_types.h:102
uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE]
Definition key_types.h:109
key_type_t type
Definition key_types.h:77
union private_key_t::@040247167361101132173265304166142033301213115260 key
@ KEY_TYPE_ED25519
Definition key_types.h:58
asciichat_error_t packet_validate(const void *packet, size_t length, size_t limit, packet_header_t *output)
Definition packet.c:81
#define AUTH_ALGO_ED25519
Ed25519 authentication (Edwards-curve signatures).
Definition packet.h:1140
#define ACIP_CRYPTO_HAS_AUTH(mode)
Check if crypto mode includes authentication.
Definition packet.h:1174
#define KEX_ALGO_X25519
X25519 key exchange (Curve25519).
Definition packet.h:1139
#define ACIP_CRYPTO_HAS_ENCRYPT(mode)
Check if crypto mode includes payload encryption.
Definition packet.h:1167
packet_type_t
Network protocol packet type enumeration.
Definition packet.h:315
#define AUTH_ALGO_NONE
No authentication (plaintext mode).
Definition packet.h:1141
#define CIPHER_ALGO_NONE
No encryption (plaintext mode).
Definition packet.h:1143
#define CIPHER_ALGO_XSALSA20_POLY1305
XSalsa20-Poly1305 authenticated encryption.
Definition packet.h:1142
@ PACKET_TYPE_CRYPTO_CLIENT_HELLO
Client -> Server: Expected server key fingerprint for multi-key selection (UNENCRYPTED).
Definition packet.h:328
@ PACKET_TYPE_ENCRYPTED
Encrypted packet (after handshake completion).
Definition packet.h:369
@ PACKET_TYPE_PROTOCOL_VERSION
Protocol version and capabilities negotiation.
Definition packet.h:317
@ PACKET_TYPE_CRYPTO_CAPABILITIES
Client -> Server: Supported crypto algorithms (UNENCRYPTED).
Definition packet.h:336
struct browser_transport browser_transport_t
struct browser_session browser_session_t
asciichat_error_t browser_session_security_tick(browser_session_t *peer)
double browser_session_security_epoch(browser_session_t *peer)
const void * browser_session_output_data(browser_session_t *peer)
void browser_session_output_pop(browser_session_t *peer)
void browser_session_destroy(browser_session_t *peer)
size_t browser_session_queued_bytes(const browser_session_t *peer)
asciichat_error_t browser_session_security_packet(browser_session_t *peer, bool seal, uint32_t channel, uint32_t delivery, const uint8_t *packet, size_t length, uint8_t *output, size_t capacity, size_t *out_length, uint64_t *sequence)
const char * browser_session_error(browser_session_t *peer)
bool browser_session_ready(browser_session_t *peer)
asciichat_error_t browser_session_security_output(browser_session_t *peer, uint8_t *output, size_t capacity, size_t *length, uint32_t *channel)
asciichat_error_t browser_session_send(browser_session_t *peer, const void *data, size_t length)
size_t browser_session_received_size(browser_session_t *peer)
browser_session_t * browser_session_create(bool server, int encryption, const char *password, const uint8_t *identity, const uint8_t *expected_key)
asciichat_error_t browser_session_tick(browser_session_t *peer)
asciichat_error_t browser_session_receive(browser_session_t *peer, const void *data, size_t length)
asciichat_error_t browser_session_start(browser_session_t *peer)
bool browser_session_writable(const browser_session_t *peer, size_t additional_bytes)
size_t browser_session_output_size(browser_session_t *peer)
void browser_session_set_connected(browser_session_t *peer, bool connected)
asciichat_error_t browser_session_security_init(browser_session_t *peer)
const void * browser_session_received_data(browser_session_t *peer)
asciichat_error_t browser_session_quic_begin(browser_session_t *peer)
asciichat_error_t acip_security_start(acip_security_t *security, acip_transport_t *transport)
void acip_security_cleanup(acip_security_t *security)
asciichat_error_t acip_security_open(crypto_context_t *crypto, acip_traffic_class_t flow, acip_delivery_t delivery, const void *packet, size_t length, uint8_t **output, size_t *written, uint64_t *sequence, bool *consumed)
asciichat_error_t acip_security_flush(acip_transport_t *transport)
asciichat_error_t acip_security_receive(acip_security_t *security, acip_transport_t *transport, packet_type_t type, const void *payload, size_t length)
asciichat_error_t crypto_policy_resolve(const crypto_policy_t *policy, uint8_t *mode)
Definition policy.c:4
#define CRYPTO_RECORD_ANY_CHANNEL
Definition record.h:15
struct acip_security acip_security_t
acip security is intentionally a small, concrete record. Fields such as handshake,...
asciichat_error_t acip_transport_send(acip_transport_t *transport, const void *data, size_t len)
Definition send.c:145
asciichat_error_t packet_send_via_transport(acip_transport_t *transport, packet_type_t type, const void *payload, size_t payload_len, uint32_t client_id)
Definition send.c:183
ACIP shared/bidirectional packet sending functions.
#define ED25519_PUBLIC_KEY_SIZE
Ed25519 public key size in bytes.
Definition sizes.h:37
#define ED25519_SEED_SIZE
Definition sizes.h:169
#define ED25519_PRIVATE_KEY_SIZE
Ed25519 private key size (seed + public) in bytes.
Definition sizes.h:39
🔤 String Manipulation and Shell Escaping Utilities
bool require_encryption
Definition security.h:22
uint8_t mode
Definition security.h:20
crypto_handshake_context_t handshake
Definition security.h:19
bool forbid_encryption
Definition security.h:21
bool version_received
Definition security.h:23
browser_transport_t * browser
asciichat_error_context_t error
Crypto capabilities packet structure (Packet Type 14).
Definition packet.h:1027
uint8_t preferred_auth
Preferred authentication algorithm (AUTH_ALGO_*).
Definition packet.h:1039
uint16_t supported_auth_algorithms
Supported authentication algorithms bitmask (AUTH_ALGO_*).
Definition packet.h:1031
uint16_t supported_kex_algorithms
Supported key exchange algorithms bitmask (KEX_ALGO_*).
Definition packet.h:1029
uint8_t preferred_cipher
Preferred cipher algorithm (CIPHER_ALGO_*).
Definition packet.h:1041
uint16_t supported_cipher_algorithms
Supported cipher algorithms bitmask (CIPHER_ALGO_*).
Definition packet.h:1033
uint8_t preferred_kex
Preferred key exchange algorithm (KEX_ALGO_*).
Definition packet.h:1037
uint8_t requires_verification
Server verification requirement flag (1=required, 0=optional).
Definition packet.h:1035
Cryptographic handshake context structure.
The useful part of crypto policy is in transport_secure, encrypt, no_encrypt, no_auth: together they ...
Definition policy.h:17
bool no_encrypt
Definition policy.h:20
bool has_password
Definition policy.h:22
Fixed prefix shared by every ACIP packet on the wire.
Definition packet.h:641
Private identity-key material used for server authentication and signing.
Definition key_types.h:101
The normalized public identity used by ascii-chat's crypto and key-management code.
Definition key_types.h:76
@ ACIP_DELIVERY_RELIABLE
Definition traffic.h:16