{"id":366,"date":"2026-11-21T14:45:40","date_gmt":"2026-11-21T14:45:40","guid":{"rendered":"https:\/\/ethertrust.com\/?page_id=366"},"modified":"2026-11-21T18:55:18","modified_gmt":"2026-11-21T18:55:18","slug":"tlsse","status":"publish","type":"page","link":"https:\/\/ethertrust.com\/index.php\/tlsse\/","title":{"rendered":"TLSSE"},"content":{"rendered":"\n<p class=\"wp-block-paragraph\">The Personal Network HSM (pNHSM) is a hardware security module architecture built from one or more secure elements accessible over an IP network. Unlike a conventional HSM, where an application typically invokes a local API such as PKCS#11, pNHSM exposes the cryptographic capabilities of secure elements through end-to-end protected TLS sessions. This architecture builds on work concerning the Internet of Secure Elements (IoSE), secure-element grids, and Personal HSMs .<\/p>\n\n\n\n<pre class=\"wp-block-preformatted\">Client application\n        |\n        | TCP\/IP + TLS 1.3\n        v\n+----------------------+\n| Front-end server     |\n|       IP:PORT        |\n+----------+-----------+\n           |\n       SNI routing\n      +----+----+\n      |         |\n      v         v\n   TLS-SE #1  TLS-SE #2\n      |         |\n   Secure     Secure\n   Element    Element<\/pre>\n\n\n\n<h2 class=\"wp-block-heading\">1. TLS-SE: TLS for Secure Elements<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">TLS-SE (TLS for Secure Elements) is a Java Card application designed for secure elements. It embeds a TLS 1.3 server and provides a secure network channel to cryptographic services executed inside the trusted component . The profile considered here uses Pre-Shared Key (PSK) authentication combined with an ephemeral Diffie\u2013Hellman exchange on the secp256r1 elliptic curve, also known as prime256v1 or P-256. The TLS_AES_128_CCM_SHA256 cipher suite provides AEAD protection for TLS records.<\/p>\n\n\n\n<pre class=\"wp-block-preformatted\">TLS-SE profile\n  authentication  : PSK\n  key exchange    : ECDHE \/ secp256r1 (P-256)\n  cipher suite    : TLS_AES_128_CCM_SHA256<\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">Combining the PSK and ECDHE exchange provides PSK-based authentication while refreshing the session keying material through an ephemeral contribution. The TLS stack, session-secret derivation, and application-data processing all run inside the secure element.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">2. End-to-End Protection<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">A fundamental property of the architecture is that the IP front-end server does not terminate or process the TLS session. It forwards TLS records to the secure element, which is the cryptographic endpoint of the connection. Commands, their parameters, and their responses therefore remain protected between the client and TLS-SE, even when the traffic passes through a front-end host.<\/p>\n\n\n\n<pre class=\"wp-block-preformatted\">Client\n  |\n  | Encrypted TLS records\n  v\nIP network\n  |\n  v\nFront-end server\n  |\n  | Same TLS records\n  v\nSecure Element \/ TLS-SE\n  |\n  v\nCryptographic commands<\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">This arrangement reduces the trust placed in the front end: it primarily provides TCP\/IP connectivity, routing, and adaptation to the secure element&rsquo;s physical interface, while TLS secrets and private keys remain inside the secure component.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">3. Identification by SEN and SNI Routing<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">Each TLS-SE application is associated with a Secure Element Name (SEN). The client sends this name in the TLS Server Name Indication (SNI) extension of the ClientHello. The front end uses the SNI value as a routing name to select the requested TLS-SE instance. In the deployment considered here, the SEN belongs to the signed TLS-SE application and thus contributes to the authenticated application identity, whereas the SEID remains an internal locator within the pNHSM server.<\/p>\n\n\n\n<pre class=\"wp-block-preformatted\">IP:PORT\n   |\n   v\nFront-end server\n   |\n   +-- SNI = key7.com   --&gt; SEID 1010 --&gt; TLS-SE\n   +-- SNI = key8.com   --&gt; SEID 1011 --&gt; TLS-SE\n   +-- SNI = key9.com   --&gt; SEID 1012 --&gt; TLS-SE<\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">The pair (IP:PORT, SEN) thus defines the external access point for a TLS-SE instance. The SEID (Secure Element Identifier, slot number, I2C address, reader identifier, etc.) is not a global identity: the operator uses it only for the local SEN \u2192 SEID \u2192 secure element mapping. Multiple TLS-SE servers may share the same IP address and port.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">4. Front-End Server and Secure-Element Grid<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">The front-end server can manage one or more secure elements. It receives TCP\/TLS connections, extracts the SNI routing information, and forwards packets to the corresponding TLS-SE component. Research on secure-element grids has shown the benefits of this arrangement for increasing the number of available resources and achieving hardware parallelism.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Network routing and cryptographic storage are therefore decoupled: the front end selects a resource, but the TLS session and sensitive operations remain associated with the selected secure element.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">5. Secure Shell Transported over TLS<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">Once the TLS 1.3 session has been established, TLS-SE exposes an application shell. Commands are transported as TLS application data in the form of simple requests, notably p&lt;slot&gt;, s&lt;KeyIndex&gt;, g&lt;slot&gt;, and c&lt;slot&gt;. IoSE work describes this protected-shell model and its use to invoke cryptographic services inside a secure element.<\/p>\n\n\n\n<pre class=\"wp-block-preformatted\">TLS Application Data\n      |\n      +-- \"p&lt;slot&gt;\\r\\n\"\n      +-- \"s&lt;KeyIndex&gt;&lt;payload&gt;\\r\\n\"\n      +-- \"g&lt;slot&gt;\\r\\n\"\n      +-- \"c&lt;slot&gt;\\r\\n\"<\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">The shell thus provides a lightweight network interface that does not depend on operating-system-specific cryptographic middleware. It can, for example, use OpenSSL as a TLS client while the actual execution of private-key operations remains confined to the secure element.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">6. pNHSM as a Personal Network HSM<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">A Personal Network HSM combines an embedded TLS-SE server, SNI routing, a grid of secure elements, and a cryptographic shell. P. Urien&rsquo;s work explicitly presents online secure elements as high-security keystores and remotely accessible Personal HSMs, together with grid architectures and their speedup factors.<\/p>\n\n\n\n<pre class=\"wp-block-preformatted\">pNHSM =\n    TCP\/IP front-end server\n  + SNI \/ SEN routing\n  + secure-element grid\n  + TLS-SE servers\n  + cryptographic-services shell<\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">This arrangement differs from a monolithic HSM: resources can be distributed, routed by name, and replicated while preserving the non-exportability of plaintext keys. It also separates the network plane from the cryptographic trust plane.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">7. TLS-SE and PKCS#11: Two Complementary Abstraction Layers<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">PKCS#11 (Cryptoki) primarily defines a standardized programming API. An application discovers slots, tokens, and objects, opens a session, and then invokes functions such as C_Login, C_FindObjects, or C_Sign [8]. The specification therefore standardizes the logical view of cryptographic resources, but it defines neither TCP\/IP transport nor the network protocol used when an HSM is remote.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">A network HSM can readily be presented to the application through PKCS#11. In that case, a local client library translates Cryptoki calls into a vendor-provided network protocol. The transport, its framing, and its protection may be product-specific. AWS CloudHSM illustrates this separation: the application may use a PKCS#11 library from the Client SDK, while client-to-HSM communication has its own end-to-end protection [44].<\/p>\n\n\n\n<pre class=\"wp-block-preformatted\">Application -&gt; PKCS#11 -&gt; client library\n            -&gt; network protocol -&gt; remote HSM<\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">TLS-SE approaches the problem from the opposite layer. The TLS 1.3 PSK server runs directly inside the secure element and carries a lightweight shell or cryptographic protocol over TLS application data. The secure element itself is therefore the endpoint of the secure channel [24], [25].<\/p>\n\n\n\n<pre class=\"wp-block-preformatted\">Application -&gt; TLS 1.3 PSK -&gt; TLS-SE -&gt; Secure Element<\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">The essential difference is the security boundary. PKCS#11 primarily answers the question, \u201cWhich operation should be requested from a token?\u201d, whereas TLS-SE addresses, \u201cHow can the remote cryptographic resource that will execute this operation be reached and authenticated?\u201d The two approaches are complementary: a PKCS#11 adapter can be built on top of TLS-SE to retain OpenSSL\/Java compatibility while benefiting from an end-to-end TLS channel to the secure element.<\/p>\n\n\n\n<figure class=\"wp-block-table\"><table class=\"has-fixed-layout\"><thead><tr><th scope=\"col\">Property<\/th><th scope=\"col\">PKCS#11<\/th><th scope=\"col\">TLS-SE<\/th><\/tr><\/thead><tbody><tr><td>Nature<\/td><td>Cryptographic API<\/td><td>Remote TLS service<\/td><\/tr><tr><td>Network<\/td><td>Outside specification<\/td><td>Built-in TLS 1.3<\/td><\/tr><tr><td>Interface<\/td><td>C \/ Cryptoki<\/td><td>Shell \/ application protocol<\/td><\/tr><tr><td>Security endpoint<\/td><td>Abstract token<\/td><td>Secure element<\/td><\/tr><tr><td>Addressing<\/td><td>Slot \/ token \/ object<\/td><td>IP:PORT + SEN<\/td><\/tr><tr><td>Authentication<\/td><td>Session \/ PIN<\/td><td>TLS PSK identity<\/td><\/tr><tr><td>Transport<\/td><td>Out of scope<\/td><td>TLS confidentiality + integrity<\/td><\/tr><tr><td>Internet-native<\/td><td>No<\/td><td>Yes<\/td><\/tr><tr><td>Partitioning<\/td><td>Logical \/ token<\/td><td>Physical partitioning possible per SE<\/td><\/tr><tr><td>Legacy OpenSSL\/Java<\/td><td>Mature<\/td><td>Adapter required<\/td><\/tr><tr><td>Endpoint attestation<\/td><td>Outside PKCS#11 core<\/td><td>IoSE\/TLS-SE<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<p class=\"wp-block-paragraph\">RFC 7512 also defines a pkcs11: URI scheme for identifying PKCS#11 objects, tokens, slots, or libraries [43]. This URI facilitates naming within the Cryptoki environment, but it does not turn PKCS#11 into an Internet protocol: it defines neither a network authority nor a transport to the token. With TLS-SE, by contrast, the network authority and SEN directly contribute to locating the remote resource.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">8. ECDSA P-256 Signing Sequence: PKCS#11 versus pNHSM\/TLS-SE<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">The difference between PKCS#11 and pNHSM\/TLS-SE becomes clear when examining a concrete signing operation. The example considered here is an ECDSA signature using the NIST P-256 curve, also known as secp256r1 or prime256v1, over a 32-byte SHA-256 digest. In both architectures, the private key remains non-exportable; the difference lies mainly in resource discovery, session establishment, and key selection.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">In PKCS#11, the application traverses a hierarchical model: Slot \u2192 Token \u2192 Session \u2192 Object \u2192 Mechanism \u2192 Operation. A typical sequence starts with C_Initialize(), followed by C_GetSlotList() to discover available tokens. After selecting a slot, C_OpenSession() creates a session and C_Login() authenticates the user, usually with a PIN. The private EC key is then located using C_FindObjectsInit(), C_FindObjects(), and C_FindObjectsFinal(), for example with the attributes CKA_CLASS=CKO_PRIVATE_KEY, CKA_KEY_TYPE=CKK_EC, and CKA_ID=0x11 [8].<\/p>\n\n\n\n<pre class=\"wp-block-preformatted\">C_Initialize\nC_GetSlotList -&gt; C_OpenSession -&gt; C_Login\nC_FindObjectsInit -&gt; C_FindObjects -&gt; C_FindObjectsFinal\nC_SignInit(CKM_ECDSA, keyHandle) -&gt; C_Sign(hash)<\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">The result of C_FindObjects() is a CK_OBJECT_HANDLE. This handle represents the key object within the PKCS#11 implementation; it is not a permanent address for the key. The application may also inspect CKA_EC_PARAMS to verify that the curve is prime256v1, whose OID is 1.2.840.10045.3.1.7, and CKA_SIGN to check that the key is authorized for signing.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">When the SHA-256 digest has already been computed by the application, CKM_ECDSA is the mechanism most directly comparable to pNHSM. C_SignInit(session, CKM_ECDSA, keyHandle) associates the session, mechanism, and key; C_Sign(session, hash, 32, &#8230;) then executes the operation. For P-256, PKCS#11 normally returns the concatenation r || s, or 64 bytes. This representation must be distinguished from the ASN.1 DER encoding ECDSA-Sig-Value = SEQUENCE { INTEGER r, INTEGER s } used in X.509 and PKCS#10 [8]. A combined mechanism such as CKM_ECDSA_SHA256 can also perform hashing within the token, but CKM_ECDSA is a closer match to the pNHSM model, in which a 32-byte hash is provided to the secure element.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">In pNHSM\/TLS-SE, the application does not discover a token and then an object. Instead, it directly knows the Server:Port network endpoint, the SEN of the TLS-SE instance, and the KeyIndex of the key. The security session is established through TLS 1.3 PSK; the SEN is used for SNI routing to the TLS-SE application, and KeyIndex directly selects the cryptographic resource. Once the session has been established, a signature can be requested with a command such as s11&lt;hash&gt;, where s denotes the signing operation and 11 is the KeyIndex.<\/p>\n\n\n\n<pre class=\"wp-block-preformatted\">TCP connect Server:Port\nTLS 1.3 PSK, SNI = SEN\ns&lt;KeyIndex&gt;&lt;SHA-256 digest&gt; -&gt; signature<\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">With a persistent TLS session, multiple signatures can be executed successively without repeating the handshake. Multi-block mode also allows multiple 32-byte digests to be supplied in a single command and the corresponding signatures to be returned, reducing transport and parsing overhead per operation.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">The following table aligns the main steps of an ECDSA P-256 signature in the two models.<\/p>\n\n\n\n<figure class=\"wp-block-table\"><table class=\"has-fixed-layout\"><thead><tr><th scope=\"col\">Step<\/th><th scope=\"col\">PKCS#11<\/th><th scope=\"col\">pNHSM \/ TLS-SE<\/th><\/tr><\/thead><tbody><tr><td>Initialization<\/td><td>C_Initialize<\/td><td>No global initialization<\/td><\/tr><tr><td>Location<\/td><td>C_GetSlotList \/ slot<\/td><td>Server:Port + SEN<\/td><\/tr><tr><td>Session<\/td><td>C_OpenSession<\/td><td>TCP + TLS 1.3<\/td><\/tr><tr><td>Authentication<\/td><td>C_Login(PIN)<\/td><td>TLS PSK identity<\/td><\/tr><tr><td>Key lookup<\/td><td>C_FindObjectsInit \/ C_FindObjects \/ C_FindObjectsFinal<\/td><td>Direct KeyIndex<\/td><\/tr><tr><td>Type \/ curve<\/td><td>CKA_KEY_TYPE, CKA_EC_PARAMS<\/td><td>Encoded by KeyIndex \/ configuration<\/td><\/tr><tr><td>Mechanism<\/td><td>C_SignInit(CKM_ECDSA, key)<\/td><td>s command + KeyIndex<\/td><\/tr><tr><td>Input<\/td><td>32-byte SHA-256 digest<\/td><td>32-byte SHA-256 digest<\/td><\/tr><tr><td>Signature operation<\/td><td>C_Sign<\/td><td>s&lt;KeyIndex&gt;&lt;hash&gt;<\/td><\/tr><tr><td>P-256 result<\/td><td>r || s, 64 bytes<\/td><td>Signature returned by TLS-SE<\/td><\/tr><tr><td>Persistence<\/td><td>PKCS#11 session<\/td><td>Persistent TLS session<\/td><\/tr><tr><td>Multiple signatures<\/td><td>Successive calls<\/td><td>Multi-block mode<\/td><\/tr><tr><td>Network transport<\/td><td>Outside PKCS#11 core<\/td><td>Built-in TLS 1.3<\/td><\/tr><tr><td>Endpoint<\/td><td>Abstract token \/ HSM<\/td><td>TLS-SE secure element<\/td><\/tr><tr><td>Closure<\/td><td>C_Logout \/ C_CloseSession<\/td><td>TLS\/TCP connection closure<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<p class=\"wp-block-paragraph\">The comparison highlights two approaches. PKCS#11 emphasizes generality and portability: an application discovers objects with attributes and then associates a mechanism with a key handle. pNHSM\/TLS-SE instead emphasizes direct addressing of a network cryptographic service: Server:Port locates the pNHSM, SEN selects the TLS-SE instance, and KeyIndex directly identifies the key and its cryptographic family.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">These approaches are not incompatible. A PKCS#11 adapter can retain the Cryptoki interface for OpenSSL, Java, or existing applications while translating C_Sign() into a TLS-SE command. The resulting architecture is:<\/p>\n\n\n\n<pre class=\"wp-block-preformatted\">OpenSSL \/ Java \/ application\n        -&gt; PKCS#11\n        -&gt; pNHSM adapter\n        -&gt; TLS 1.3\n        -&gt; TLS-SE \/ Secure Element<\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">PKCS#11 and TLS-SE can thus be regarded as complementary: PKCS#11 standardizes the API seen by the application, while TLS-SE standardizes the secure channel and network access all the way to the secure element. A remote PKCS#11 HSM may also use a proprietary network protocol behind its client library; that transport layer nevertheless remains outside the core PKCS#11 specification.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">9. Naming and Locating IoSE Resources<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">The IoSE model can distinguish three levels: the network location of the pNHSM server, the authenticated name of the TLS-SE application, and the internal physical location of the secure element. This separation avoids confusing identity with a hardware address.<\/p>\n\n\n\n<pre class=\"wp-block-preformatted\">Server:Port  = pNHSM network location\nSEN          = TLS-SE instance name\nSEID         = internal locator (slot, I2C, reader)<\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">The pNHSM server is located by Server:Port, where Server is the operator&rsquo;s DNS name or IP address and Port is the service&rsquo;s TCP port. The client need not know the internal hardware topology of the server. The front end receives the ClientHello, reads SNI\/SEN, and performs a local mapping to the corresponding SEID.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">A hierarchical naming convention can be defined as SEN = Instance.Service. Service represents the logical cryptographic function, and Instance distinguishes the different TLS-SE applications providing that service. For a certification authority, the name ca can represent the implicit instance zero, while 1.ca, 2.ca, 3.ca, and so forth represent additional instances.<\/p>\n\n\n\n<pre class=\"wp-block-preformatted\">Service = ca\nca     == 0.ca\n1.ca   = instance 1\n2.ca   = instance 2\n3.ca   = instance 3<\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">In the deployment considered here, the SEN is part of the TLS-SE application signed by the service provider. It is therefore not merely a string used for SNI routing: it is associated with an application identity that can be verified using the IoSE certification and attestation mechanisms described in Section 8 of the IETF IoSE draft. This property enables the client to authenticate the name of the TLS-SE instance terminating its session.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">The SEID serves a different purpose. It is an address local to the pNHSM, such as a slot number or I2C address. Its uniqueness is limited to the infrastructure hosting it, and it is not intended as a global cryptographic identity. A routing table can, for example, contain the following associations:<\/p>\n\n\n\n<pre class=\"wp-block-preformatted\">SEN      SEID\nca       1010\n1.ca     1011\n2.ca     1012\n3.ca     1013<\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">A resource can thus be described conceptually by the string Instance.Service.Server:Port.SEID. This notation expresses the different system layers but does not imply that SEID should be exposed in the client URI. For the application, the preferred stable reference is Server:Port + SEN; SEID remains operator-specific administrative information.<\/p>\n\n\n\n<pre class=\"wp-block-preformatted\">shells:\/\/psk_identity@server:port\/cmd?sen=ca\n                         |              |\n                         |              +-- authenticated TLS-SE instance\n                         +-- operator network location<\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">This separation provides location transparency. The secure element associated with 2.ca can move from I2C slot 1012 to 1027 without changing the SEN or any client configuration; only the operator&rsquo;s local table changes. This is analogous to the Web, where a resource or service name remains stable even when a back-end address changes.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">The Instance.Service convention also provides a natural namespace for replication. A provider can allocate a Service such as ca and then deploy several signed instances\u2014ca, 1.ca, 2.ca, and so on. These instances may contain protected copies of the same logical key through blobs while maintaining separate TLS-SE sessions. The logical service name and the name of each instance then remain independent of the pNHSM&rsquo;s physical topology.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">The resulting model can be summarized by the following resolution chain:<\/p>\n\n\n\n<pre class=\"wp-block-preformatted\">Client URI\n   -&gt; Server:Port\n   -&gt; SEN = Instance.Service\n   -&gt; local SEN -&gt; SEID mapping table\n   -&gt; Secure Element \/ TLS-SE<\/pre>\n\n\n\n<p class=\"wp-block-paragraph\"><\/p>\n","protected":false},"excerpt":{"rendered":"<p>The Personal Network HSM (pNHSM) is a hardware security module architecture built from one or more secure elements accessible over an IP network. Unlike a conventional HSM, where an application typically invokes a local API such as PKCS#11, pNHSM exposes the cryptographic capabilities of secure elements through end-to-end protected TLS sessions. This architecture builds on [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-366","page","type-page","status-publish","hentry"],"_links":{"self":[{"href":"https:\/\/ethertrust.com\/index.php\/wp-json\/wp\/v2\/pages\/366","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/ethertrust.com\/index.php\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/ethertrust.com\/index.php\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/ethertrust.com\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/ethertrust.com\/index.php\/wp-json\/wp\/v2\/comments?post=366"}],"version-history":[{"count":10,"href":"https:\/\/ethertrust.com\/index.php\/wp-json\/wp\/v2\/pages\/366\/revisions"}],"predecessor-version":[{"id":381,"href":"https:\/\/ethertrust.com\/index.php\/wp-json\/wp\/v2\/pages\/366\/revisions\/381"}],"wp:attachment":[{"href":"https:\/\/ethertrust.com\/index.php\/wp-json\/wp\/v2\/media?parent=366"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}