🥮 mooncakes.io

moontls-parser

TLS ClientHello parser and JA3/JA4-style fingerprint toolkit for MoonBit traffic-audit probes.

tls
ja3
ja4
fingerprint
security
parser
moon add yhsrtty/moontls-parser@0.1.2
Download zip
Author
Version
0.1.2
License
Apache-2.0
Repository
Last updated
6 days ago
Downloads
15

Dependencies

README

#MoonTLS-Parser

MoonTLS-Parser is a MoonBit library for passive TLS record inspection, handshake parsing (ClientHello, ServerHello, Certificate, Alert), and fingerprint generation (JA3, JA4-a, JA4S-a). It is designed for traffic-audit probes, sidecar policy filters, and Wasm-based gateways that need routing, auditing, and client-classification signals without decrypting payloads.

This release focuses on the unencrypted TLS handshake surface and features:

  • TLS record parsing and length validation.
  • Streaming parse of fragmented ClientHello records.
  • SNI, ALPN, cipher suite, supported group, EC point format, and signature algorithm extraction from ClientHello.
  • GREASE filtering for JA3-compatible fields.
  • JA3 canonical string and MD5 digest generation.
  • A compact JA4-a style summary for coarse client bucketing.
  • ServerHello Handshake Parsing: negotiated version (supporting TLS 1.3 supported_versions extensions), cipher suite, random, session ID, and selected ALPN.
  • JA4S-a Fingerprinting: server handshake fingerprinting for audit classification.
  • Alert Record Parsing: extract Alert Level and Alert Description with readable string conversion (e.g., handshake_failure, close_notify).
  • Certificate Handshake Parsing: extract DER certificate lengths in the chain for size auditing.
  • JSON Serialization: built-in .to_json() methods for ClientHello, ServerHello, Alerts, and Certificates.

#Why This Project

The OSC2026 requirement favors reusable MoonBit ecosystem libraries with clear scope, tests, documentation, and maintainable public APIs. TLS record parsing is a good fit because it is useful in security tooling but still small enough to implement as a focused MoonBit package.

This repository is an original MoonBit implementation. It references public TLS, JA3, and JA4 behavior, but it does not copy code from any upstream parser.

#Install

#Option 1: Via Mooncakes Package Manager (Recommended)

Add moontls-parser directly to your MoonBit project using moon add:

moon add yhsrtty/moontls-parser

Or manually declare the dependency in your moon.mod:

import {
  "yhsrtty/moontls-parser@0.1.2",
}

Or in JSON format (moon.mod.json):

{
  "deps": {
    "yhsrtty/moontls-parser": "0.1.2"
  }
}

#Option 2: Local Development & Building from Source

To build, test, and run locally:

git clone https://github.com/yhsrtty/MoonTLS-Parser.git
cd MoonTLS-Parser
moon check --deny-warn
moon test --deny-warn
moon run cmd/main

#Minimal API

#Parsing TLS Records

You can parse any TLS record (Handshake, Alert, etc.) using parse_tls_record:

let parsed = parse_tls_record(packet_bytes)
match parsed {
  Ok(ClientHelloRecord(hello)) => {
    println(hello.server_name)
    println(hello.ja3_digest())
    println(hello.to_json())
  }
  Ok(ServerHelloRecord(hello)) => {
    println(hello.selected_alpn)
    println(hello.ja4s_a())
    println(hello.to_json())
  }
  Ok(AlertRecord(alert)) => {
    println(alert.description_string())
  }
  Ok(CertificateRecord(cert)) => {
    println(cert.cert_lengths)
  }
  Ok(GenericRecord(ty, payload)) => {
    println("Other TLS Record")
  }
  Err(err) => println(err)
}

For incremental capture pipelines, use ClientHelloStream:

let stream = ClientHelloStream::new()
let a = stream.push(first_fragment)
let b = stream.push(second_fragment)

NeedMore means the record header or record body is incomplete. Parsed returns a ClientHello. Rejected means the buffered bytes are not a valid TLS ClientHello record.

#Current Scope

Implemented:

  • TLS record content types handshake (0x16) and alert (0x15).
  • TLS 1.0 through TLS 1.3 record-version range.
  • Handshake types client_hello (1), server_hello (2), and certificate (11).
  • Extensions server_name, application_layer_protocol_negotiation (ALPN), supported_groups, ec_point_formats, signature_algorithms, and supported_versions.
  • Fingerprinting: JA3, JA4-a, and JA4S-a.
  • JSON Serialization for parsed elements.

Not implemented yet:

  • TCP reassembly beyond a single TLS record.
  • Full DER certificate structure parsing (extracts only certificate lengths).
  • Encrypted ClientHello decryption.
  • Live pcap reading.

Those are natural extension points rather than hidden behavior.

#Verification

The test suite includes hand-built ClientHello, ServerHello, Alert, and Certificate record fixtures.

moon test --deny-warn
moon check --deny-warn
moon info

The repository also includes:

  • .github/workflows/ci.yml for GitHub CI (Windows, Linux, macOS).
  • scripts/verify_acceptance.ps1 for local OSC2026-style checks.
  • docs/source-attribution.md for source and licensing notes.
  • docs/acceptance-checklist.md for the current competition-readiness status.

#License

Apache-2.0. See LICENSE.

#
BenchmarkReport

source
pub struct BenchmarkReport {
  test_name : String
  operations : Int
  total_bytes : Int
  efficiency_rating : String
} derive(Eq, 
Debug)

#
CertificateRequest

source
pub struct CertificateRequest {
  certificate_types : Array[Byte]
  supported_signature_algorithms : Array[UInt16]
} derive(Eq, 
Debug)

#
CertificateVerify

source
pub struct CertificateVerify {
  signature_algorithm : UInt16
  signature : Bytes
} derive(Eq, 
Debug)

#
CipherDetails

source
pub struct CipherDetails {
  id : UInt16
  name : String
  kex : String
  enc : String
  mac : String
  strength : Int
  is_recommended : Bool
} derive(Eq, 
Debug)

#
ClientHello

source
pub struct ClientHello {
  legacy_version : UInt16
  record_version : UInt16
  cipher_suites : Array[UInt16]
  compression_methods : Array[Byte]
  extensions : Array[UInt16]
  supported_groups : Array[UInt16]
  ec_point_formats : Array[Byte]
  signature_algorithms : Array[UInt16]
  alpn_protocols : Array[String]
  server_name : String?
  raw_length : Int
} derive(
Debug)

#
ClientHello::ja3_digest

source
fn ClientHello::ja3_digest(self : ClientHello) -> String

#
ClientHello::ja3_string

source
fn ClientHello::ja3_string(self : ClientHello) -> String

#
ClientHello::ja4

source
fn ClientHello::ja4(self : ClientHello) -> String

#
ClientHello::ja4_a

source
fn ClientHello::ja4_a(self : ClientHello) -> String

#
ClientHello::ja4_a_str

source
fn ClientHello::ja4_a_str(self : ClientHello) -> String

#
ClientHello::ja4_b_str

source
fn ClientHello::ja4_b_str(self : ClientHello) -> String

#
ClientHello::ja4_c_str

source
fn ClientHello::ja4_c_str(self : ClientHello) -> String

#
ClientHello::to_json

source
fn ClientHello::to_json(self : ClientHello) -> String

#
ClientHelloStream

source
pub struct ClientHelloStream {
  buffer : Array[Byte]
} derive(
Debug)

#
ClientHelloStream::new

source

#
ClientHelloStream::push

source
fn ClientHelloStream::push(self : ClientHelloStream, chunk : BytesView) -> StreamResult

#
ClientHelloStream::reset

source
fn ClientHelloStream::reset(self : ClientHelloStream) -> Unit

#
ClientKeyExchange

source
pub struct ClientKeyExchange {
  raw : Bytes
} derive(Eq, 
Debug)

#
EncryptedExtensions

source
pub struct EncryptedExtensions {
  extensions : Array[UInt16]
} derive(Eq, 
Debug)

#
FingerprintEntry

source
pub struct FingerprintEntry {
  fingerprint : String
  client_type : String
  description : String
} derive(Eq, 
Debug)

#
Finished

source
pub struct Finished {
  verify_data : Bytes
} derive(Eq, 
Debug)

#
HandshakeEvent

source
pub struct HandshakeEvent {
  direction_is_client_to_server : Bool
  label : String
  details : Array[String]
} derive(Eq, 
Debug)

#
HelloRequest

source
pub struct HelloRequest {
  dummy : Byte
} derive(Eq, 
Debug)

#
HelloVerifyRequest

source
pub struct HelloVerifyRequest {
  version : UInt16
  cookie : Bytes
} derive(Eq, 
Debug)

#
KeyShareClient

source
pub struct KeyShareClient {
  client_shares : Array[KeyShareEntry]
} derive(Eq, 
Debug)

#
KeyShareEntry

source
pub struct KeyShareEntry {
  group : UInt16
  key_exchange : Bytes
} derive(Eq, 
Debug)

#
KeyShareServer

source
pub struct KeyShareServer {
  server_share : KeyShareEntry
} derive(Eq, 
Debug)

#
NewSessionTicket

source
pub struct NewSessionTicket {
  lifetime : UInt
  age_add : UInt
  ticket : Bytes
} derive(Eq, 
Debug)

#
ParseError

source
pub enum ParseError {
  NotTlsHandshake
  IncompleteRecord(expected~ : Int, available~ : Int)
  BadHandshakeType(Int)
  BadLength(field~ : String, offset~ : Int)
  UnsupportedRecordVersion(UInt16)
  InvalidAlertLength
} derive(Eq, 
Debug)

#
SecurityFinding

source
pub struct SecurityFinding {
  severity : String
  category : String
  finding : String
  suggestion : String
} derive(Eq, 
Debug)

#
ServerHello

source
pub struct ServerHello {
  version : UInt16
  random : Bytes
  session_id : Bytes
  cipher_suite : UInt16
  compression_method : Byte
  extensions : Array[UInt16]
  selected_alpn : String?
  raw_length : Int
} derive(
Debug)

#
ServerHello::ja4s

source
fn ServerHello::ja4s(self : ServerHello) -> String

#
ServerHello::ja4s_a

source
fn ServerHello::ja4s_a(self : ServerHello) -> String

#
ServerHello::ja4s_a_str

source
fn ServerHello::ja4s_a_str(self : ServerHello) -> String

#
ServerHello::ja4s_b_str

source
fn ServerHello::ja4s_b_str(self : ServerHello) -> String

#
ServerHello::ja4s_c_str

source
fn ServerHello::ja4s_c_str(self : ServerHello) -> String

#
ServerHello::to_json

source
fn ServerHello::to_json(self : ServerHello) -> String

#
ServerKeyExchange

source
pub struct ServerKeyExchange {
  raw : Bytes
} derive(Eq, 
Debug)

#
ServerNameEntry

source
pub struct ServerNameEntry {
  name_type : Byte
  name : String
} derive(Eq, 
Debug)

#
ServerNameList

source
pub struct ServerNameList {
  names : Array[ServerNameEntry]
} derive(Eq, 
Debug)

#
Sha256

source
type Sha256

#
Sha256::finalize

source
fn Sha256::finalize(self : Sha256) -> Bytes

#
Sha256::update

source
fn Sha256::update(self : Sha256, data : BytesView) -> Unit

#
StreamResult

source
pub enum StreamResult {
  NeedMore
  Parsed(ClientHello)
  Rejected(ParseError)
} derive(
Debug)

#
SupportedVersionsClient

source
pub struct SupportedVersionsClient {
  versions : Array[UInt16]
} derive(Eq, 
Debug)

#
TlsAlert

source
pub struct TlsAlert {
  level : Byte
  description : Byte
} derive(Eq, 
Debug)

#
TlsAlert::description_string

source
fn TlsAlert::description_string(self : TlsAlert) -> String

#
TlsAlert::level_string

source
fn TlsAlert::level_string(self : TlsAlert) -> String

#
TlsAlert::to_json

source
fn TlsAlert::to_json(self : TlsAlert) -> String

#
TlsCertificate

source
pub struct TlsCertificate {
  cert_lengths : Array[Int]
} derive(Eq, 
Debug)

#
TlsCertificate::to_json

source
fn TlsCertificate::to_json(self : TlsCertificate) -> String

#
TlsCookie

source
pub struct TlsCookie {
  cookie : Bytes
} derive(Eq, 
Debug)

#
TlsRecord

source
pub enum TlsRecord {
  ClientHelloRecord(ClientHello)
  ServerHelloRecord(ServerHello)
  AlertRecord(TlsAlert)
  CertificateRecord(TlsCertificate)
  ClientKeyExchangeRecord(ClientKeyExchange)
  ServerKeyExchangeRecord(ServerKeyExchange)
  NewSessionTicketRecord(NewSessionTicket)
  EncryptedExtensionsRecord(EncryptedExtensions)
  HelloRequestRecord(HelloRequest)
  HelloVerifyRequestRecord(HelloVerifyRequest)
  CertificateRequestRecord(CertificateRequest)
  CertificateVerifyRecord(CertificateVerify)
  FinishedRecord(Finished)
  GenericRecord(TlsRecordType, Bytes)
} derive(
Debug)

#
TlsRecord::cipher_summary

source
fn TlsRecord::cipher_summary(self : TlsRecord) -> String

#
TlsRecord::dump_tree

source
fn TlsRecord::dump_tree(self : TlsRecord) -> String

#
TlsRecord::extension_summary

source
fn TlsRecord::extension_summary(self : TlsRecord) -> Array[String]

#
TlsRecord::to_event

source
fn TlsRecord::to_event(self : TlsRecord, from_client : Bool) -> HandshakeEvent

#
TlsRecord::to_json

source
fn TlsRecord::to_json(self : TlsRecord) -> String

#
TlsRecordType

source
pub enum TlsRecordType {
  ChangeCipherSpec
  Handshake
  ApplicationData
  Unknown(Byte)
} derive(Eq, 
Debug)

#
CONTENT_TYPE_ALERT

source
let CONTENT_TYPE_ALERT : Byte

#
CONTENT_TYPE_APPLICATION_DATA

source
let CONTENT_TYPE_APPLICATION_DATA : Byte

#
CONTENT_TYPE_CHANGE_CIPHER_SPEC

source
let CONTENT_TYPE_CHANGE_CIPHER_SPEC : Byte

TLS Record Content Types (RFC 5246 Section 6.2.1)

#
CONTENT_TYPE_HANDSHAKE

source
let CONTENT_TYPE_HANDSHAKE : Byte

#
GROUP_FFDHE2048

source
let GROUP_FFDHE2048 : UInt16

#
GROUP_FFDHE3072

source
let GROUP_FFDHE3072 : UInt16

#
GROUP_FFDHE4096

source
let GROUP_FFDHE4096 : UInt16

#
GROUP_SECP256R1

source
let GROUP_SECP256R1 : UInt16

Supported Cryptographic Groups (RFC 8446 Section 4.2.7)

#
GROUP_SECP384R1

source
let GROUP_SECP384R1 : UInt16

#
GROUP_SECP521R1

source
let GROUP_SECP521R1 : UInt16

#
GROUP_X25519

source
let GROUP_X25519 : UInt16

#
GROUP_X448

source
let GROUP_X448 : UInt16

#
HANDSHAKE_TYPE_CERTIFICATE

source
let HANDSHAKE_TYPE_CERTIFICATE : Byte

#
HANDSHAKE_TYPE_CERTIFICATE_REQUEST

source
let HANDSHAKE_TYPE_CERTIFICATE_REQUEST : Byte

#
HANDSHAKE_TYPE_CERTIFICATE_VERIFY

source
let HANDSHAKE_TYPE_CERTIFICATE_VERIFY : Byte

#
HANDSHAKE_TYPE_CLIENT_HELLO

source
let HANDSHAKE_TYPE_CLIENT_HELLO : Byte

#
HANDSHAKE_TYPE_CLIENT_KEY_EXCHANGE

source
let HANDSHAKE_TYPE_CLIENT_KEY_EXCHANGE : Byte

#
HANDSHAKE_TYPE_ENCRYPTED_EXTENSIONS

source
let HANDSHAKE_TYPE_ENCRYPTED_EXTENSIONS : Byte

#
HANDSHAKE_TYPE_END_OF_EARLY_DATA

source
let HANDSHAKE_TYPE_END_OF_EARLY_DATA : Byte

#
HANDSHAKE_TYPE_FINISHED

source
let HANDSHAKE_TYPE_FINISHED : Byte

#
HANDSHAKE_TYPE_HELLO_REQUEST

source
let HANDSHAKE_TYPE_HELLO_REQUEST : Byte

Handshake Protocol Message Types (RFC 8446 Section 4)

#
HANDSHAKE_TYPE_HELLO_VERIFY_REQUEST

source
let HANDSHAKE_TYPE_HELLO_VERIFY_REQUEST : Byte

#
HANDSHAKE_TYPE_KEY_UPDATE

source
let HANDSHAKE_TYPE_KEY_UPDATE : Byte

#
HANDSHAKE_TYPE_MESSAGE_HASH

source
let HANDSHAKE_TYPE_MESSAGE_HASH : Byte

#
HANDSHAKE_TYPE_NEW_SESSION_TICKET

source
let HANDSHAKE_TYPE_NEW_SESSION_TICKET : Byte

#
HANDSHAKE_TYPE_SERVER_HELLO

source
let HANDSHAKE_TYPE_SERVER_HELLO : Byte

#
HANDSHAKE_TYPE_SERVER_HELLO_DONE

source
let HANDSHAKE_TYPE_SERVER_HELLO_DONE : Byte

#
HANDSHAKE_TYPE_SERVER_KEY_EXCHANGE

source
let HANDSHAKE_TYPE_SERVER_KEY_EXCHANGE : Byte

#
SIG_SCHEME_ECDSA_SHA256_NISTP256

source
let SIG_SCHEME_ECDSA_SHA256_NISTP256 : UInt16

#
SIG_SCHEME_ECDSA_SHA384_NISTP384

source
let SIG_SCHEME_ECDSA_SHA384_NISTP384 : UInt16

#
SIG_SCHEME_ECDSA_SHA512_NISTP521

source
let SIG_SCHEME_ECDSA_SHA512_NISTP521 : UInt16

#
SIG_SCHEME_ED25519

source
let SIG_SCHEME_ED25519 : UInt16

#
SIG_SCHEME_ED448

source
let SIG_SCHEME_ED448 : UInt16

#
SIG_SCHEME_RSA_PKCS1_SHA256

source
let SIG_SCHEME_RSA_PKCS1_SHA256 : UInt16

Signature Schemes (RFC 8446 Section 4.2.3)

#
SIG_SCHEME_RSA_PKCS1_SHA384

source
let SIG_SCHEME_RSA_PKCS1_SHA384 : UInt16

#
SIG_SCHEME_RSA_PKCS1_SHA512

source
let SIG_SCHEME_RSA_PKCS1_SHA512 : UInt16

#
SIG_SCHEME_RSA_PSS_RSAE_SHA256

source
let SIG_SCHEME_RSA_PSS_RSAE_SHA256 : UInt16

#
SIG_SCHEME_RSA_PSS_RSAE_SHA384

source
let SIG_SCHEME_RSA_PSS_RSAE_SHA384 : UInt16

#
SIG_SCHEME_RSA_PSS_RSAE_SHA512

source
let SIG_SCHEME_RSA_PSS_RSAE_SHA512 : UInt16

#
VERSION_SSL_3_0

source
let VERSION_SSL_3_0 : UInt16

TLS Protocol Versions (RFC 8446 Section 4.2.1)

#
VERSION_TLS_1_0

source
let VERSION_TLS_1_0 : UInt16

#
VERSION_TLS_1_1

source
let VERSION_TLS_1_1 : UInt16

#
VERSION_TLS_1_2

source
let VERSION_TLS_1_2 : UInt16

#
VERSION_TLS_1_3

source
let VERSION_TLS_1_3 : UInt16

#
add_custom_client_fingerprint

source
fn add_custom_client_fingerprint(fp : String, client_type : String, desc : String) -> Unit

#
add_custom_server_fingerprint

source
fn add_custom_server_fingerprint(fp : String, server_type : String, desc : String) -> Unit

#
alert_description_to_string

source
fn alert_description_to_string(desc : Byte) -> String

#
alert_level_to_string

source
fn alert_level_to_string(level : Byte) -> String

#
ascii_bytes

source
fn ascii_bytes(text : String) -> Bytes

#
audit_client_hello_security

source
fn audit_client_hello_security(hello : ClientHello) -> Array[SecurityFinding]

#
audit_server_hello_security

source
fn audit_server_hello_security(hello : ServerHello) -> Array[SecurityFinding]

#
cipher_details_db_size

source
fn cipher_details_db_size() -> Int

#
cipher_suite_id_to_string

source
fn cipher_suite_id_to_string(id : UInt16) -> String

#
client_db_size

source
fn client_db_size() -> Int

#
extension_id_to_string

source
fn extension_id_to_string(id : UInt16) -> String

#
fixture_client_hello_tls12

source
fn fixture_client_hello_tls12() -> Bytes

#
fixture_client_key_exchange

source
fn fixture_client_key_exchange() -> Bytes

#
fixture_encrypted_extensions

source
fn fixture_encrypted_extensions() -> Bytes

#
fixture_new_session_ticket

source
fn fixture_new_session_ticket() -> Bytes

#
fixture_server_hello_tls13

source
fn fixture_server_hello_tls13() -> Bytes

#
fixture_server_key_exchange

source
fn fixture_server_key_exchange() -> Bytes

#
fixture_tls_alert_fatal

source
fn fixture_tls_alert_fatal() -> Bytes

#
fixture_tls_certificate

source
fn fixture_tls_certificate() -> Bytes

#
format_markdown_report

source
fn format_markdown_report(reports : Array[BenchmarkReport]) -> String

#
generate_mermaid_diagram

source
fn generate_mermaid_diagram(records : Array[TlsRecord], directions : Array[Bool]) -> String

#
generate_sequence_diagram

source
fn generate_sequence_diagram(events : Array[HandshakeEvent]) -> String

#
hex_dump

source
fn hex_dump(data : BytesView) -> String

#
is_aead_cipher_id

source
fn is_aead_cipher_id(id : UInt16) -> Bool

fn is_recommended_cipher_id(id : UInt16) -> Bool

#
is_tls_13_cipher_id

source
fn is_tls_13_cipher_id(id : UInt16) -> Bool

#
is_tls_version_supported

source
fn is_tls_version_supported(v : UInt16) -> Bool

#
is_weak_cipher_id

source
fn is_weak_cipher_id(id : UInt16) -> Bool

#
ja3_db_size

source
fn ja3_db_size() -> Int

#
lookup_cipher_details

source
fn lookup_cipher_details(id : UInt16) -> CipherDetails?

#
lookup_client_fingerprint

source
fn lookup_client_fingerprint(fp : String) -> String?

#
lookup_client_fingerprint_ext

source
fn lookup_client_fingerprint_ext(fp : String) -> String?

#
lookup_fingerprint_info

source
fn lookup_fingerprint_info(fp : String) -> String

#
lookup_ja3_fingerprint

source
fn lookup_ja3_fingerprint(fp : String) -> String?

#
lookup_server_fingerprint

source
fn lookup_server_fingerprint(fp : String) -> String?

#
lookup_server_fingerprint_ext

source
fn lookup_server_fingerprint_ext(fp : String) -> String?

#
normalize_u16_list

source
fn normalize_u16_list(values : ArrayView[UInt16]) -> String

#
parse_alert

source
fn parse_alert(data : BytesView) -> Result[TlsAlert, ParseError]

#
parse_certificate

source
fn parse_certificate(data : BytesView) -> Result[TlsCertificate, ParseError]

#
parse_certificate_request

source
fn parse_certificate_request(data : BytesView) -> Result[CertificateRequest, ParseError]

#
parse_certificate_verify

source
fn parse_certificate_verify(data : BytesView) -> Result[CertificateVerify, ParseError]

#
parse_client_hello

source
fn parse_client_hello(data : BytesView) -> Result[ClientHello, ParseError]

#
parse_client_key_exchange

source
fn parse_client_key_exchange(data : BytesView) -> Result[ClientKeyExchange, ParseError]

#
parse_encrypted_extensions

source
fn parse_encrypted_extensions(data : BytesView) -> Result[EncryptedExtensions, ParseError]

#
parse_finished

source
fn parse_finished(data : BytesView) -> Result[Finished, ParseError]

#
parse_hello_request

source
fn parse_hello_request(data : BytesView) -> Result[HelloRequest, ParseError]

#
parse_hello_verify_request

source
fn parse_hello_verify_request(data : BytesView) -> Result[HelloVerifyRequest, ParseError]

#
parse_key_share_client

source
fn parse_key_share_client(data : BytesView) -> Result[KeyShareClient, ParseError]

#
parse_key_share_server

source
fn parse_key_share_server(data : BytesView) -> Result[KeyShareServer, ParseError]

#
parse_new_session_ticket

source
fn parse_new_session_ticket(data : BytesView) -> Result[NewSessionTicket, ParseError]

#
parse_server_hello

source
fn parse_server_hello(data : BytesView) -> Result[ServerHello, ParseError]

#
parse_server_key_exchange

source
fn parse_server_key_exchange(data : BytesView) -> Result[ServerKeyExchange, ParseError]

#
parse_server_name_list

source
fn parse_server_name_list(data : BytesView) -> Result[ServerNameList, ParseError]

#
parse_supported_versions_client

source
fn parse_supported_versions_client(data : BytesView) -> Result[SupportedVersionsClient, ParseError]

fn parse_tls_cookie(data : BytesView) -> Result[TlsCookie, ParseError]

#
parse_tls_record

source
fn parse_tls_record(data : BytesView) -> Result[TlsRecord, ParseError]

fn print_security_audit_report(findings : Array[SecurityFinding]) -> Unit

#
run_and_print_performance_audit

source
fn run_and_print_performance_audit() -> Unit

#
run_detailed_benchmarks

source
fn run_detailed_benchmarks() -> Array[BenchmarkReport]

#
run_parser_benchmark

source
fn run_parser_benchmark(iterations : Int) -> Unit

#
server_db_size

source
fn server_db_size() -> Int

#
sha256_hash

source
fn sha256_hash(data : BytesView) -> Bytes

#
sha256_hex

source
fn sha256_hex(data : BytesView) -> String

#
uint16_to_hex4

source
fn uint16_to_hex4(value : UInt16) -> String

#
visualize_handshake

source
fn visualize_handshake(records : Array[TlsRecord], directions : Array[Bool]) -> String

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io