diff --git a/hwcrypto/hwkey_srv.c b/hwcrypto/hwkey_srv.c
index 12b6b32..8d1130e 100644
--- a/hwcrypto/hwkey_srv.c
+++ b/hwcrypto/hwkey_srv.c
@@ -65,13 +65,6 @@
  */
 static struct list_node opaque_handles = LIST_INITIAL_VALUE(opaque_handles);
 
-static void hwkey_port_handler(const uevent_t* ev, void* priv);
-static void hwkey_chan_handler(const uevent_t* ev, void* priv);
-
-static struct tipc_event_handler hwkey_port_evt_handler = {
-        .proc = hwkey_port_handler,
-};
-
 static uint8_t req_data[HWKEY_MAX_MSG_SIZE + 1];
 static __attribute__((aligned(4))) uint8_t key_data[HWKEY_MAX_MSG_SIZE];
 
@@ -507,11 +500,15 @@
 /*
  *  Read and queue HWKEY request message
  */
-static int hwkey_chan_handle_msg(struct hwkey_chan_ctx* ctx) {
+int hwkey_chan_handle_msg(const struct tipc_port* port,
+                          handle_t chan,
+                          void* received_ctx) {
     int rc;
     size_t req_data_len;
     struct hwkey_msg_header* hdr;
 
+    struct hwkey_chan_ctx* ctx = (struct hwkey_chan_ctx*)received_ctx;
+
     rc = tipc_recv1(ctx->chan, sizeof(*hdr), req_data, sizeof(req_data) - 1);
     if (rc < 0) {
         TLOGE("failed (%d) to recv msg from chan %d\n", rc, ctx->chan);
@@ -579,79 +576,6 @@
 }
 
 /*
- *  HWKEY service channel event handler
- */
-static void hwkey_chan_handler(const uevent_t* ev, void* priv) {
-    struct hwkey_chan_ctx* ctx = priv;
-
-    assert(ctx);
-    assert(ev->handle == ctx->chan);
-
-    tipc_handle_chan_errors(ev);
-
-    if (ev->event & IPC_HANDLE_POLL_HUP) {
-        /* closed by peer. */
-        hwkey_ctx_close(ctx);
-        return;
-    }
-
-    if (ev->event & IPC_HANDLE_POLL_MSG) {
-        int rc = hwkey_chan_handle_msg(ctx);
-        if (rc < 0) {
-            /* report an error and close channel */
-            TLOGE("failed (%d) to handle event on channel %d\n", rc,
-                  ev->handle);
-            hwkey_ctx_close(ctx);
-        }
-    }
-}
-
-/*
- * HWKEY service port event handler
- */
-static void hwkey_port_handler(const uevent_t* ev, void* priv) {
-    uuid_t peer_uuid;
-
-    tipc_handle_port_errors(ev);
-
-    if (ev->event & IPC_HANDLE_POLL_READY) {
-        /* incoming connection: accept it */
-        int rc = accept(ev->handle, &peer_uuid);
-        if (rc < 0) {
-            TLOGE("failed (%d) to accept on port %d\n", rc, ev->handle);
-            return;
-        }
-
-        handle_t chan = (handle_t)rc;
-        if (!hwkey_client_allowed(&peer_uuid)) {
-            TLOGE("access to hwkey service denied\n");
-            close(chan);
-            return;
-        }
-
-        struct hwkey_chan_ctx* ctx = calloc(1, sizeof(*ctx));
-        if (!ctx) {
-            TLOGE("failed (%d) to allocate context on chan %d\n", rc, chan);
-            close(chan);
-            return;
-        }
-
-        /* init channel state */
-        ctx->evt_handler.priv = ctx;
-        ctx->evt_handler.proc = hwkey_chan_handler;
-        ctx->chan = chan;
-        ctx->uuid = peer_uuid;
-
-        rc = set_cookie(chan, &ctx->evt_handler);
-        if (rc < 0) {
-            TLOGE("failed (%d) to set_cookie on chan %d\n", rc, chan);
-            hwkey_ctx_close(ctx);
-            return;
-        }
-    }
-}
-
-/*
  *  Install Key slot provider
  */
 void hwkey_install_keys(const struct hwkey_keyslot* keys, unsigned int kcnt) {
@@ -703,7 +627,7 @@
      */
     uint8_t random_buf[HWKEY_OPAQUE_HANDLE_SIZE + 2];
     while (1) {
-        int rc = hwrng_dev_get_rng_data(random_buf, sizeof(random_buf));
+        int rc = trusty_rng_hw_rand(random_buf, sizeof(random_buf));
         if (rc != NO_ERROR) {
             /* Don't leave an empty entry if we couldn't generate a token */
             delete_opaque_handle(entry);
@@ -766,29 +690,36 @@
 }
 
 /*
- *  Initialize HWKEY service
+ * Create hwkey channel context
  */
-int hwkey_start_service(void) {
-    int rc;
-    handle_t port;
+int hwkey_chan_ctx_create(const struct tipc_port* port,
+                          handle_t chan,
+                          const struct uuid* peer,
+                          void** ctx) {
+    struct hwkey_chan_ctx* chan_ctx = calloc(1, sizeof(*chan_ctx));
 
-    TLOGD("Start HWKEY service\n");
-
-    /* Initialize service */
-    rc = port_create(HWKEY_PORT, 1, HWKEY_MAX_MSG_SIZE,
-                     IPC_PORT_ALLOW_TA_CONNECT);
-    if (rc < 0) {
-        TLOGE("Failed (%d) to create port %s\n", rc, HWKEY_PORT);
-        return rc;
+    if (!chan_ctx) {
+        return ERR_NO_MEMORY;
     }
 
-    port = (handle_t)rc;
-    rc = set_cookie(port, &hwkey_port_evt_handler);
-    if (rc) {
-        TLOGE("failed (%d) to set_cookie on port %d\n", rc, port);
-        close(port);
-        return rc;
-    }
+    chan_ctx->uuid = *peer;
+    chan_ctx->chan = chan;
+    *ctx = chan_ctx;
 
     return NO_ERROR;
 }
+
+/*
+ * Close specified hwkey channel context
+ */
+void hwkey_chan_ctx_close(void* ctx) {
+    struct opaque_handle_node* entry;
+    struct opaque_handle_node* temp;
+    list_for_every_entry_safe(&opaque_handles, entry, temp,
+                              struct opaque_handle_node, node) {
+        if (entry->owner == ctx) {
+            delete_opaque_handle(entry);
+        }
+    }
+    free(ctx);
+}
diff --git a/hwcrypto/hwkey_srv_fake_provider.c b/hwcrypto/hwkey_srv_fake_provider.c
index af34468..532d344 100644
--- a/hwcrypto/hwkey_srv_fake_provider.c
+++ b/hwcrypto/hwkey_srv_fake_provider.c
@@ -35,6 +35,7 @@
 #include <interface/hwkey/hwkey.h>
 #include <lib/system_state/system_state.h>
 #include <lib/tipc/tipc.h>
+#include <lib/tipc/tipc_srv.h>
 #include <trusty_log.h>
 
 #include <hwcrypto_consts.h>
@@ -42,6 +43,9 @@
 
 #pragma message "Compiling FAKE HWKEY provider"
 
+/* 0 means unlimited number of connections */
+#define HWKEY_MAX_NUM_CHANNELS 0
+
 /*
  *  This module is a sample only. For real device, this code
  *  needs to be rewritten to operate on real per device key that
@@ -853,16 +857,6 @@
         &hwbcc_unittest_uuid,
 };
 
-bool hwkey_client_allowed(const uuid_t* uuid) {
-    assert(uuid);
-    for (unsigned int i = 0; i < countof(allowed_clients); i++) {
-        if (memcmp(allowed_clients[i], uuid, sizeof(uuid_t)) == 0) {
-            return true;
-        }
-    }
-    return false;
-}
-
 /*
  *  List of keys slots that hwkey service supports
  */
@@ -1024,9 +1018,37 @@
 }
 
 /*
+ *  Initialize HWKEY service
+ */
+static int hwkey_start_service(struct tipc_hset* hset) {
+    TLOGD("Start HWKEY service\n");
+
+    static struct tipc_port_acl acl = {
+            .flags = IPC_PORT_ALLOW_TA_CONNECT,
+            .uuid_num = countof(allowed_clients),
+            .uuids = allowed_clients,
+    };
+
+    static struct tipc_port port = {
+            .name = HWKEY_PORT,
+            .msg_max_size = HWKEY_MAX_MSG_SIZE,
+            .msg_queue_len = 1,
+            .acl = &acl,
+    };
+
+    static struct tipc_srv_ops ops = {
+            .on_message = hwkey_chan_handle_msg,
+            .on_connect = hwkey_chan_ctx_create,
+            .on_channel_cleanup = hwkey_chan_ctx_close,
+    };
+
+    return tipc_add_service(hset, &port, 1, HWKEY_MAX_NUM_CHANNELS, &ops);
+}
+
+/*
  *  Initialize Fake HWKEY service provider
  */
-void hwkey_init_srv_provider(void) {
+int hwkey_init_srv_provider(struct tipc_hset* hset) {
     int rc;
 
     TLOGE("Init FAKE!!!! HWKEY service provider\n");
@@ -1042,8 +1064,10 @@
     hwkey_install_keys(_keys, countof(_keys));
 
     /* start service */
-    rc = hwkey_start_service();
+    rc = hwkey_start_service(hset);
     if (rc != NO_ERROR) {
         TLOGE("failed (%d) to start HWKEY service\n", rc);
     }
+
+    return rc;
 }
diff --git a/hwcrypto/hwkey_srv_priv.h b/hwcrypto/hwkey_srv_priv.h
index 8ffe97c..84209f1 100644
--- a/hwcrypto/hwkey_srv_priv.h
+++ b/hwcrypto/hwkey_srv_priv.h
@@ -16,6 +16,8 @@
 #pragma once
 
 #include <interface/hwkey/hwkey.h>
+#include <lib/tipc/tipc.h>
+#include <lib/tipc/tipc_srv.h>
 #include <lk/compiler.h>
 #include <stdbool.h>
 #include <sys/types.h>
@@ -136,13 +138,20 @@
                         size_t kbuf_len,
                         size_t* klen);
 
-void hwkey_init_srv_provider(void);
+int hwkey_init_srv_provider(struct tipc_hset* hset);
 
 void hwkey_install_keys(const struct hwkey_keyslot* keys, unsigned int kcnt);
 
-int hwkey_start_service(void);
+int hwkey_chan_handle_msg(const struct tipc_port* _port,
+                          handle_t _chan,
+                          void* _received_ctx);
 
-bool hwkey_client_allowed(const uuid_t* uuid);
+int hwkey_chan_ctx_create(const struct tipc_port* port,
+                          handle_t chan,
+                          const struct uuid* peer,
+                          void** ctx);
+
+void hwkey_chan_ctx_close(void* ctx);
 
 uint32_t derive_key_v1(const uuid_t* uuid,
                        const uint8_t* ikm_data,
diff --git a/hwcrypto/hwrng_srv.c b/hwcrypto/hwrng_srv.c
index ae76945..1757839 100644
--- a/hwcrypto/hwrng_srv.c
+++ b/hwcrypto/hwrng_srv.c
@@ -27,28 +27,24 @@
 #include <hwcrypto/hwrng_dev.h>
 #include <interface/hwrng/hwrng.h>
 #include <lib/tipc/tipc.h>
+#include <lib/tipc/tipc_srv.h>
 #include <trusty_log.h>
 
 #define HWRNG_SRV_NAME HWRNG_PORT
 #define MAX_HWRNG_MSG_SIZE 4096
 
+/* 0 means unlimited number of connections */
+#define HWRNG_MAX_NUM_CHANNELS 0
+
 struct hwrng_chan_ctx {
     struct tipc_event_handler evt_handler;
     struct list_node node;
     handle_t chan;
     size_t req_size;
+    int error;
     bool send_blocked;
 };
 
-static void hwrng_port_handler(const uevent_t* ev, void* priv);
-static void hwrng_chan_handler(const uevent_t* ev, void* priv);
-
-static handle_t hwrng_port = INVALID_IPC_HANDLE;
-
-static struct tipc_event_handler hwrng_port_evt_handler = {
-        .proc = hwrng_port_handler,
-};
-
 static uint8_t rng_data[MAX_HWRNG_MSG_SIZE];
 
 static struct list_node hwrng_req_list = LIST_INITIAL_VALUE(hwrng_req_list);
@@ -74,94 +70,84 @@
 }
 
 /*
- * Close specified HWRNG service channel
- */
-static void hwrng_close_chan(struct hwrng_chan_ctx* ctx) {
-    close(ctx->chan);
-
-    if (list_in_list(&ctx->node))
-        list_delete(&ctx->node);
-
-    free(ctx);
-}
-
-/*
  * Handle HWRNG request queue
  */
-static bool hwrng_handle_req_queue(void) {
+static void hwrng_handle_req_queue(void) {
     int rc;
     struct hwrng_chan_ctx* ctx;
     struct hwrng_chan_ctx* temp;
 
-    /* service channels */
-    bool need_more = false;
-
     /* for all pending requests */
-    list_for_every_entry_safe(&hwrng_req_list, ctx, temp, struct hwrng_chan_ctx,
-                              node) {
-        if (ctx->send_blocked)
-            continue; /* cant service it rignt now */
-
-        size_t len = ctx->req_size;
-
-        if (len > MAX_HWRNG_MSG_SIZE)
-            len = MAX_HWRNG_MSG_SIZE;
-
-        /* get hwrng data */
-        rc = hwrng_dev_get_rng_data(rng_data, len);
-        if (rc != NO_ERROR) {
-            TLOGE("failed (%d) to get hwrng data\n", rc);
-            hwrng_close_chan(ctx);
-            continue;
-        }
-
-        /* send reply */
-        rc = tipc_send1(ctx->chan, rng_data, len);
-        if (rc < 0) {
-            if (rc == ERR_NOT_ENOUGH_BUFFER) {
-                /* mark it as send_blocked */
-                ctx->send_blocked = true;
-            } else {
-                /* just close HWRNG request channel */
-                TLOGE("failed (%d) to send_reply\n", rc);
-                hwrng_close_chan(ctx);
+    bool more_requests;
+    do {
+        more_requests = false;
+        list_for_every_entry_safe(&hwrng_req_list, ctx, temp,
+                                  struct hwrng_chan_ctx, node) {
+            if (ctx->error || ctx->send_blocked) {
+                continue; /* can't service it right now */
             }
-            continue;
+
+            size_t len = ctx->req_size;
+
+            if (len > MAX_HWRNG_MSG_SIZE)
+                len = MAX_HWRNG_MSG_SIZE;
+
+            /* get hwrng data */
+            rc = trusty_rng_hw_rand(rng_data, len);
+            if (rc != NO_ERROR) {
+                TLOGE("failed (%d) to get hwrng data\n", rc);
+                ctx->error = rc;
+                continue;
+            }
+
+            /* send reply */
+            rc = tipc_send1(ctx->chan, rng_data, len);
+            if (rc < 0) {
+                if (rc == ERR_NOT_ENOUGH_BUFFER) {
+                    /* mark it as send_blocked */
+                    ctx->send_blocked = true;
+                } else {
+                    /* just close HWRNG request channel */
+                    TLOGE("failed (%d) to send_reply\n", rc);
+                    ctx->error = rc;
+                }
+                continue;
+            }
+
+            ctx->req_size -= len;
+
+            if (ctx->req_size == 0) {
+                /* remove it from pending list */
+                list_delete(&ctx->node);
+            } else {
+                more_requests = true;
+            }
         }
-
-        ctx->req_size -= len;
-
-        if (ctx->req_size == 0) {
-            /* remove it from pending list */
-            list_delete(&ctx->node);
-        } else {
-            need_more = true;
-        }
-    }
-
-    return need_more;
-}
-
-/*
- * Check if we can handle request queue
- */
-static void hwrng_kick_req_queue(void) {
-    hwrng_handle_req_queue();
+    } while (more_requests);
 }
 
 /*
  *  Read and queue HWRNG request message
  */
-static int hwrng_chan_handle_msg(struct hwrng_chan_ctx* ctx) {
+static int hwrng_chan_handle_msg(const struct tipc_port* port,
+                                 handle_t chan,
+                                 void* received_ctx) {
     int rc;
     struct hwrng_req req;
 
+    struct hwrng_chan_ctx* ctx = (struct hwrng_chan_ctx*)received_ctx;
+
     assert(ctx);
 
+    /* check for an error from a previous send attempt */
+    if (ctx->error) {
+        return ctx->error;
+    }
+
     /* read request */
-    rc = tipc_recv1(ctx->chan, sizeof(req), &req, sizeof(req));
+    rc = tipc_recv1(chan, sizeof(req), &req, sizeof(req));
     if (rc < 0) {
-        TLOGE("failed (%d) to receive msg for chan %d\n", rc, ctx->chan);
+        TLOGE("failed (%d) to receive msg for chan %d\n", rc, chan);
         return rc;
     }
 
@@ -175,111 +161,93 @@
         list_add_tail(&hwrng_req_list, &ctx->node);
     }
 
-    return 0;
+    hwrng_handle_req_queue();
+
+    return ctx->error;
 }
 
 /*
- *  Channel handler where HWRNG requests are coming from
+ * Create hwrng channel context
  */
-static void hwrng_chan_handler(const uevent_t* ev, void* priv) {
-    struct hwrng_chan_ctx* ctx = priv;
+static int hwrng_chan_ctx_create(const struct tipc_port* port,
+                                 handle_t chan,
+                                 const struct uuid* peer,
+                                 void** ctx) {
+    struct hwrng_chan_ctx* chan_ctx = calloc(1, sizeof(*chan_ctx));
 
-    assert(ctx);
-    assert(ev->handle == ctx->chan);
-
-    tipc_handle_chan_errors(ev);
-
-    if (ev->event & IPC_HANDLE_POLL_HUP) {
-        hwrng_close_chan(ctx);
-    } else {
-        if (ev->event & IPC_HANDLE_POLL_SEND_UNBLOCKED) {
-            ctx->send_blocked = false;
-        }
-
-        if (ev->event & IPC_HANDLE_POLL_MSG) {
-            int rc = hwrng_chan_handle_msg(ctx);
-            if (rc) {
-                hwrng_close_chan(ctx);
-            }
-        }
+    if (!chan_ctx) {
+        return ERR_NO_MEMORY;
     }
 
-    /* kick state machine */
-    hwrng_kick_req_queue();
+    /* init channel state */
+    chan_ctx->chan = chan;
+    *ctx = chan_ctx;
+
+    return NO_ERROR;
 }
 
 /*
- * Port were HWRNG requests are coming from
+ * Close specified hwrng channel context
  */
-static void hwrng_port_handler(const uevent_t* ev, void* priv) {
-    uuid_t peer_uuid;
+static void hwrng_chan_ctx_close(void* ctx_rcv) {
+    struct hwrng_chan_ctx* ctx = (struct hwrng_chan_ctx*)ctx_rcv;
 
-    tipc_handle_port_errors(ev);
+    if (list_in_list(&ctx->node))
+        list_delete(&ctx->node);
 
-    if (ev->event & IPC_HANDLE_POLL_READY) {
-        handle_t chan;
+    close(ctx->chan);
+    free(ctx);
+}
 
-        /* incoming connection: accept it */
-        int rc = accept(ev->handle, &peer_uuid);
-        if (rc < 0) {
-            TLOGE("failed (%d) to accept on port %d\n", rc, ev->handle);
-            return;
-        }
-        chan = (handle_t)rc;
+static int hwrng_handle_send_unblocked(const struct tipc_port* port,
+                                       handle_t chan,
+                                       void* ctx_v) {
+    struct hwrng_chan_ctx* ctx = ctx_v;
 
-        /* allocate state */
-        struct hwrng_chan_ctx* ctx = calloc(1, sizeof(*ctx));
-        if (!ctx) {
-            TLOGE("failed to alloc state for chan %d\n", chan);
-            close(chan);
-            return;
-        }
-
-        /* init channel state */
-        ctx->evt_handler.priv = ctx;
-        ctx->evt_handler.proc = hwrng_chan_handler;
-        ctx->chan = chan;
-
-        /* attach channel handler */
-        rc = set_cookie(chan, &ctx->evt_handler);
-        if (rc) {
-            TLOGE("failed (%d) to set_cookie on chan %d\n", rc, chan);
-            free(ctx);
-            close(chan);
-            return;
-        }
+    if (ctx->error) {
+        return ctx->error;
     }
+
+    ctx->send_blocked = false;
+
+    hwrng_handle_req_queue();
+
+    return ctx->error;
 }
 
 /*
  *  Initialize HWRNG services
  */
-int hwrng_start_service(void) {
+int hwrng_start_service(struct tipc_hset* hset) {
     int rc;
 
     TLOGD("Start HWRNG service\n");
 
-    /* create HWRNG port */
-    rc = port_create(HWRNG_SRV_NAME, 1, MAX_HWRNG_MSG_SIZE,
-                     IPC_PORT_ALLOW_TA_CONNECT);
-    if (rc < 0) {
-        TLOGE("Failed (%d) to create port '%s'\n", rc, HWRNG_SRV_NAME);
-        goto err_port_create;
-    }
+    static struct tipc_port_acl acl = {
+            .flags = IPC_PORT_ALLOW_TA_CONNECT,
+            .uuid_num = 0,
+            .uuids = NULL,
+    };
 
-    hwrng_port = (handle_t)rc;
-    set_cookie(hwrng_port, &hwrng_port_evt_handler);
+    static struct tipc_port port = {
+            .name = HWRNG_SRV_NAME,
+            .msg_max_size = MAX_HWRNG_MSG_SIZE,
+            .msg_queue_len = 1,
+            .acl = &acl,
+    };
+
+    static struct tipc_srv_ops ops = {
+            .on_message = hwrng_chan_handle_msg,
+            .on_connect = hwrng_chan_ctx_create,
+            .on_channel_cleanup = hwrng_chan_ctx_close,
+            .on_send_unblocked = hwrng_handle_send_unblocked,
+    };
 
     rc = hwrng_dev_init();
     if (rc != NO_ERROR) {
         TLOGE("Failed (%d) to initialize HWRNG device\n", rc);
-        goto err_hwrng_dev_init;
+        return rc;
     }
 
-    return NO_ERROR;
-
-err_hwrng_dev_init:
-    close(hwrng_port);
-err_port_create:
-    return rc;
+    return tipc_add_service(hset, &port, 1, HWRNG_MAX_NUM_CHANNELS, &ops);
 }
diff --git a/hwcrypto/hwrng_srv_fake_provider.c b/hwcrypto/hwrng_srv_fake_provider.c
index cf360a9..9417e5e 100644
--- a/hwcrypto/hwrng_srv_fake_provider.c
+++ b/hwcrypto/hwrng_srv_fake_provider.c
@@ -35,7 +35,7 @@
 static size_t counter = 1;
 
 __attribute__((no_sanitize("unsigned-integer-overflow"))) int
-hwrng_dev_get_rng_data(uint8_t* buf, size_t buf_len) {
+trusty_rng_hw_rand(uint8_t* buf, size_t buf_len) {
     for (uint8_t* end = buf + buf_len; buf < end; ++buf) {
         *buf = counter++ & 0xff;
     }
diff --git a/hwcrypto/hwrng_srv_priv.h b/hwcrypto/hwrng_srv_priv.h
index 1b7c1d8..0f7ddf1 100644
--- a/hwcrypto/hwrng_srv_priv.h
+++ b/hwcrypto/hwrng_srv_priv.h
@@ -15,10 +15,11 @@
  */
 #pragma once
 
+#include <lib/tipc/tipc_srv.h>
 #include <lk/compiler.h>
 
 __BEGIN_CDECLS
 
-int hwrng_start_service(void);
+int hwrng_start_service(struct tipc_hset* hset);
 
 __END_CDECLS
diff --git a/hwcrypto/include/hwcrypto/hwrng_dev.h b/hwcrypto/include/hwcrypto/hwrng_dev.h
index ef9823a..a5a2e61 100644
--- a/hwcrypto/include/hwcrypto/hwrng_dev.h
+++ b/hwcrypto/include/hwcrypto/hwrng_dev.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include <lib/rng/trusty_rng.h>
 #include <lk/compiler.h>
 #include <stddef.h>
 #include <stdint.h>
@@ -35,12 +36,14 @@
 int hwrng_dev_init(void);
 
 /*
- * hwrng_dev_get_rng_data() - get hardware-generated random data
+ * trusty_rng_hw_rand() - get hardware-generated random data. Function
+ * definition located in trusty_rng.h.
  * @buf: buffer to be filled up
  * @buf_len: requested amount of random data
  *
  * Return: NO_ERROR on success, a negative error code otherwise.
+ *
+ * int trusty_rng_hw_rand(uint8_t* data, size_t len);
  */
-int hwrng_dev_get_rng_data(uint8_t* buf, size_t buf_len);
 
 __END_CDECLS
diff --git a/hwcrypto/keybox/srv.c b/hwcrypto/keybox/srv.c
index a43efc8..d7a5ad3 100644
--- a/hwcrypto/keybox/srv.c
+++ b/hwcrypto/keybox/srv.c
@@ -32,25 +32,14 @@
 #include "keybox.h"
 #include "srv.h"
 
+/* 0 means unlimited number of connections */
+#define KEYBOX_MAX_NUM_CHANNELS 0
+
 struct keybox_chan_ctx {
     struct tipc_event_handler evt_handler;
     handle_t chan;
 };
 
-static void keybox_port_handler(const uevent_t* ev, void* priv);
-static void keybox_chan_handler(const uevent_t* ev, void* priv);
-
-static handle_t keybox_port = INVALID_IPC_HANDLE;
-
-static struct tipc_event_handler keybox_port_evt_handler = {
-        .proc = keybox_port_handler,
-};
-
-static void keybox_shutdown(struct keybox_chan_ctx* ctx) {
-    close(ctx->chan);
-    free(ctx);
-}
-
 struct full_keybox_unwrap_req {
     struct keybox_unwrap_req unwrap_header;
     uint8_t wrapped_keybox[KEYBOX_MAX_SIZE];
@@ -106,11 +95,13 @@
     } cmd_header;
 };
 
-static int keybox_handle_msg(struct keybox_chan_ctx* ctx) {
+static int keybox_chan_handle_msg(const struct tipc_port* port,
+                                  handle_t chan,
+                                  void* ctx) {
     int rc;
     struct full_keybox_req req;
     enum keybox_status status = KEYBOX_STATUS_SUCCESS;
-    rc = tipc_recv1(ctx->chan, sizeof(req.header), &req, sizeof(req));
+    rc = tipc_recv1(chan, sizeof(req.header), &req, sizeof(req));
     if (rc < 0) {
         TLOGE("Failed (%d) to receive Keybox message\n", rc);
         return KEYBOX_STATUS_INTERNAL_ERROR;
@@ -119,7 +110,7 @@
     size_t cmd_specific_size = (size_t)rc - sizeof(req.header);
     switch (req.header.cmd) {
     case KEYBOX_CMD_UNWRAP:
-        rc = keybox_handle_unwrap(ctx->chan, &req.cmd_header.unwrap,
+        rc = keybox_handle_unwrap(chan, &req.cmd_header.unwrap,
                                   cmd_specific_size);
         break;
     default:
@@ -127,7 +118,7 @@
         struct keybox_resp rsp;
         rsp.cmd = req.header.cmd | KEYBOX_CMD_RSP_BIT;
         rsp.status = KEYBOX_STATUS_INVALID_REQUEST;
-        rc = tipc_send1(ctx->chan, &rsp, sizeof(rsp));
+        rc = tipc_send1(chan, &rsp, sizeof(rsp));
     }
 
     if (rc < 0) {
@@ -137,86 +128,27 @@
     return status;
 }
 
-static void keybox_chan_handler(const uevent_t* ev, void* priv) {
-    struct keybox_chan_ctx* ctx = (struct keybox_chan_ctx*)priv;
-    assert(ctx);
-    assert(ev->handle == ctx->chan);
-
-    tipc_handle_chan_errors(ev);
-    int rc = 0;
-    if (ev->event & IPC_HANDLE_POLL_MSG) {
-        rc = keybox_handle_msg(ctx);
-    }
-    if (ev->event & IPC_HANDLE_POLL_HUP) {
-        keybox_shutdown(ctx);
-    }
-    if (rc) {
-        keybox_shutdown(ctx);
-    }
-}
-
-static void keybox_port_handler(const uevent_t* ev, void* priv) {
-    uuid_t peer_uuid;
-
-    tipc_handle_port_errors(ev);
-
-    if (ev->event & IPC_HANDLE_POLL_READY) {
-        handle_t chan;
-
-        /* incoming connection: accept it */
-        int rc = accept(ev->handle, &peer_uuid);
-        if (rc < 0) {
-            TLOGE("failed (%d) to accept on port %d\n", rc, ev->handle);
-            return;
-        }
-        chan = (handle_t)rc;
-
-        struct keybox_chan_ctx* ctx = calloc(1, sizeof(struct keybox_chan_ctx));
-
-        if (!ctx) {
-            TLOGE("failed to alloc state for chan %d\n", chan);
-            close(chan);
-            return;
-        }
-
-        /* init channel state */
-        ctx->evt_handler.priv = ctx;
-        ctx->evt_handler.proc = keybox_chan_handler;
-        ctx->chan = chan;
-
-        /* attach channel handler */
-        rc = set_cookie(chan, &ctx->evt_handler);
-        if (rc) {
-            TLOGE("failed (%d) to set_cookie on chan %d\n", rc, chan);
-            free(ctx);
-            close(chan);
-            return;
-        }
-    }
-}
-
 /*
  *  Initialize Keybox service
  */
-int keybox_start_service(void) {
-    int rc;
-
+int keybox_start_service(struct tipc_hset* hset) {
     TLOGD("Start Keybox service\n");
 
-    /* create Keybox port */
-    rc = port_create(KEYBOX_PORT, 1, sizeof(struct full_keybox_req),
-                     IPC_PORT_ALLOW_TA_CONNECT);
-    if (rc < 0) {
-        TLOGE("Failed (%d) to create port '%s'\n", rc, KEYBOX_PORT);
-        goto cleanup;
-    }
+    // TODO: check why we are not restricting connections by uuid
+    static struct tipc_port_acl acl = {
+            .flags = IPC_PORT_ALLOW_TA_CONNECT,
+            .uuid_num = 0,
+            .uuids = NULL,
+    };
 
-    keybox_port = (handle_t)rc;
-    set_cookie(keybox_port, &keybox_port_evt_handler);
-
-    return NO_ERROR;
-
-cleanup:
-    close(keybox_port);
-    return rc;
+    static struct tipc_port port = {
+            .name = KEYBOX_PORT,
+            .msg_max_size = sizeof(struct full_keybox_req),
+            .msg_queue_len = 1,
+            .acl = &acl,
+    };
+    static struct tipc_srv_ops ops = {
+            .on_message = keybox_chan_handle_msg,
+    };
+    return tipc_add_service(hset, &port, 1, KEYBOX_MAX_NUM_CHANNELS, &ops);
 }
diff --git a/hwcrypto/keybox/srv.h b/hwcrypto/keybox/srv.h
index 74e2a2d..2c65108 100644
--- a/hwcrypto/keybox/srv.h
+++ b/hwcrypto/keybox/srv.h
@@ -16,10 +16,12 @@
 
 #pragma once
 
+#include <lib/tipc/tipc.h>
+#include <lib/tipc/tipc_srv.h>
 #include <lk/compiler.h>
 
 __BEGIN_CDECLS
 
-int keybox_start_service(void);
+int keybox_start_service(struct tipc_hset*);
 
 __END_CDECLS
diff --git a/hwcrypto/main.c b/hwcrypto/main.c
index 0e0f76c..3bd3713 100644
--- a/hwcrypto/main.c
+++ b/hwcrypto/main.c
@@ -24,6 +24,7 @@
 
 #include <hwcrypto/hwrng_dev.h>
 #include <lib/tipc/tipc.h>
+#include <lk/err_ptr.h>
 #include <trusty_log.h>
 
 #include "hwkey_srv_priv.h"
@@ -32,53 +33,38 @@
 #include "keybox/srv.h"
 
 /*
- *  Dispatch event
- */
-static void dispatch_event(const uevent_t* ev) {
-    assert(ev);
-
-    if (ev->event == IPC_HANDLE_POLL_NONE) {
-        /* not really an event, do nothing */
-        TLOGI("got an empty event\n");
-        return;
-    }
-
-    /* check if we have handler */
-    struct tipc_event_handler* handler = ev->cookie;
-    if (handler && handler->proc) {
-        /* invoke it */
-        handler->proc(ev, handler->priv);
-        return;
-    }
-
-    /* no handler? close it */
-    TLOGE("no handler for event (0x%x) with handle %d\n", ev->event,
-          ev->handle);
-
-    close(ev->handle);
-
-    return;
-}
-
-/*
  *  Main application event loop
  */
 int main(void) {
     int rc;
-    uevent_t event;
+    struct tipc_hset* hset;
 
     TLOGD("Initializing\n");
 
+    hset = tipc_hset_create();
+    if (IS_ERR(hset)) {
+        rc = PTR_ERR(hset);
+        TLOGE("tipc_hset_create failed (%d)\n", rc);
+        goto out;
+    }
+
     /* initialize service providers */
-    rc = hwrng_start_service();
+#if WITH_HWCRYPTO_HWRNG
+    rc = hwrng_start_service(hset);
     if (rc != NO_ERROR) {
         TLOGE("Failed (%d) to initialize HWRNG service\n", rc);
         goto out;
     }
-    hwkey_init_srv_provider();
+#endif
+
+    rc = hwkey_init_srv_provider(hset);
+    if (rc != NO_ERROR) {
+        TLOGE("Failed (%d) to initialize HwKey service\n", rc);
+        goto out;
+    }
 
 #if defined(WITH_FAKE_KEYBOX)
-    rc = keybox_start_service();
+    rc = keybox_start_service(hset);
     if (rc != NO_ERROR) {
         TLOGE("Failed (%d) to initialize Keybox service\n", rc);
         goto out;
@@ -88,21 +74,7 @@
     TLOGD("enter main event loop\n");
 
     /* enter main event loop */
-    while (1) {
-        event.handle = INVALID_IPC_HANDLE;
-        event.event = 0;
-        event.cookie = NULL;
-
-        rc = wait_any(&event, INFINITE_TIME);
-        if (rc < 0) {
-            TLOGE("wait_any failed (%d)\n", rc);
-            break;
-        }
-
-        if (rc == NO_ERROR) { /* got an event */
-            dispatch_event(&event);
-        }
-    }
+    rc = tipc_run_event_loop(hset);
 
 out:
     return rc;
diff --git a/hwcrypto/rules.mk b/hwcrypto/rules.mk
index df15e65..0ae2908 100644
--- a/hwcrypto/rules.mk
+++ b/hwcrypto/rules.mk
@@ -26,7 +26,6 @@
 
 MODULE_SRCS := \
 	$(LOCAL_DIR)/main.c \
-	$(LOCAL_DIR)/hwrng_srv.c \
 	$(LOCAL_DIR)/hwkey_srv.c \
 
 ifeq (true,$(call TOBOOL,$(WITH_FAKE_HWRNG)))
@@ -35,6 +34,8 @@
 
 ifeq (true,$(call TOBOOL,$(WITH_FAKE_HWKEY)))
 MODULE_SRCS += $(LOCAL_DIR)/hwkey_srv_fake_provider.c
+MODULE_SRCS += $(LOCAL_DIR)/hwrng_srv.c
+MODULE_DEFINES += WITH_HWCRYPTO_HWRNG=1
 endif
 
 MODULE_LIBRARY_DEPS := \
diff --git a/hwrng-unittest/main.c b/hwrng-unittest/main.c
index 3b2f115..6845ff5 100644
--- a/hwrng-unittest/main.c
+++ b/hwrng-unittest/main.c
@@ -27,7 +27,7 @@
 #include <uapi/err.h>
 
 static uint32_t _hist[256];
-static uint8_t _rng_buf[1024];
+static uint8_t _rng_buf[16384];
 
 static void hwrng_update_hist(uint8_t* data, unsigned int cnt) {
     for (unsigned int i = 0; i < cnt; i++) {
@@ -58,13 +58,19 @@
     }
 }
 
+TEST(hwrng, large_buffer) {
+    int rc;
+    rc = trusty_rng_hw_rand(_rng_buf, sizeof(_rng_buf));
+    EXPECT_EQ(NO_ERROR, rc, "hwrng test");
+}
+
 TEST(hwrng, var_rng_req_test) {
     int rc;
     unsigned int i;
     size_t req_cnt;
     /* Issue 100 hwrng requests of variable sizes */
     for (i = 0; i < 100; i++) {
-        req_cnt = ((size_t)rand() % sizeof(_rng_buf)) + 1;
+        req_cnt = ((size_t)rand() % MIN(1024, sizeof(_rng_buf))) + 1;
         rc = trusty_rng_hw_rand(_rng_buf, req_cnt);
         EXPECT_EQ(NO_ERROR, rc, "hwrng test");
         if (rc != NO_ERROR) {