diff --git a/docs/implementation-coverage.md b/docs/implementation-coverage.md
index 9a187544..1070126f 100644
--- a/docs/implementation-coverage.md
+++ b/docs/implementation-coverage.md
@@ -47,9 +47,9 @@ This document attempts to describe the implementation status of Crypto APIs/Inte
   * ✅ `hash.copy([options])`
   * ✅ `hash.digest([encoding])`
   * ✅ `hash.update(data[, inputEncoding])`
-* ❌ Class: `Hmac`
-  * ❌ `hmac.digest([encoding])`
-  * ❌ `hmac.update(data[, inputEncoding])`
+* ✅ Class: `Hmac`
+  * ✅ `hmac.digest([encoding])`
+  * ✅ `hmac.update(data[, inputEncoding])`
 * ❌ Class: `KeyObject`
   * ❌ `Static method: KeyObject.from(key)`
   * ❌ `keyObject.asymmetricKeyDetails`
@@ -102,7 +102,7 @@ This document attempts to describe the implementation status of Crypto APIs/Inte
   * ❌ `crypto.createDiffieHellmanGroup(name)`
   * ❌ `crypto.createECDH(curveName)`
   * ✅ `crypto.createHash(algorithm[, options])`
-  * ❌ `crypto.createHmac(algorithm, key[, options])`
+  * ✅ `crypto.createHmac(algorithm, key[, options])`
   * ❌ `crypto.createPrivateKey(key)`
   * ❌ `crypto.createPublicKey(key)`
   * ❌ `crypto.createSecretKey(key[, encoding])`
diff --git a/example/src/hooks/useTestsList.ts b/example/src/hooks/useTestsList.ts
index 73b09c77..02af821c 100644
--- a/example/src/hooks/useTestsList.ts
+++ b/example/src/hooks/useTestsList.ts
@@ -2,6 +2,7 @@ import { useState, useCallback } from 'react';
 import type { TestSuites } from '../types/tests';
 import { TestsContext } from '../tests/util';
 
+import '../tests/hmac/hmac_tests';
 import '../tests/hash/hash_tests';
 import '../tests/ed25519/ed25519_tests';
 import '../tests/pbkdf2/pbkdf2_tests';
diff --git a/example/src/tests/hmac/hmac_tests.ts b/example/src/tests/hmac/hmac_tests.ts
new file mode 100644
index 00000000..256c821e
--- /dev/null
+++ b/example/src/tests/hmac/hmac_tests.ts
@@ -0,0 +1,517 @@
+/**
+ * Tests are based on Node.js tests
+ * https://github.com/nodejs/node/blob/main/test/parallel/test-crypto-hmac.js
+ */
+
+import { Buffer } from '@craftzdog/react-native-buffer';
+import crypto, { createHmac, type Encoding } from 'react-native-quick-crypto';
+import { assert, expect } from 'chai';
+import { test } from '../util';
+
+const SUITE = 'hmac';
+
+test(SUITE, 'createHmac with valid algorithm', () => {
+  expect(() => {
+    createHmac('sha256', 'key');
+  }).to.not.throw();
+});
+
+test(SUITE, 'createHmac with invalid algorithm', () => {
+  expect(() => {
+    createHmac('sha123', 'key');
+  }).to.throw(/Unknown HMAC algorithm: sha123/);
+});
+
+test(SUITE, 'createHmac with null algorithm', () => {
+  // @ts-expect-error bad algorithm
+  expect(() => createHmac(null)).to.throw(
+    /Algorithm must be a non-empty string/,
+  );
+});
+
+test(SUITE, 'createHmac with null key', () => {
+  // @ts-expect-error bad key
+  expect(() => createHmac('sha1', null)).to.throw(
+    /Key must not be null or undefined/,
+  );
+});
+
+test(SUITE, 'createHmac with empty key', () => {
+  expect(() => {
+    crypto.createHmac('sha1', '');
+  }).to.not.throw();
+});
+
+test(SUITE, 'digest as hex', () => {
+  const hmac = createHmac('sha256', 'key');
+  hmac.update('some data');
+  const digest = hmac.digest('hex');
+  expect(digest).to.equal(
+    '01add3f98ce4d49403d98362a046c6cca2c79d778426282c53e4f628f648c12b',
+  );
+});
+
+test(SUITE, 'digest as base64', () => {
+  const hmac = createHmac('sha256', 'key');
+  hmac.update('some data');
+  const digest = hmac.digest('base64');
+  expect(digest).to.equal('Aa3T+Yzk1JQD2YNioEbGzKLHnXeEJigsU+T2KPZIwSs=');
+});
+
+test(SUITE, 'multiple updates', () => {
+  const hmac = createHmac('sha256', 'key');
+  hmac.update('some');
+  hmac.update(' data');
+  const digest = hmac.digest('hex');
+  expect(digest).to.equal(
+    '01add3f98ce4d49403d98362a046c6cca2c79d778426282c53e4f628f648c12b',
+  );
+});
+
+test(SUITE, 'Buffer key', () => {
+  const key = Buffer.from('key');
+  const hmac = createHmac('sha256', key);
+  hmac.update('some data');
+  const digest = hmac.digest('hex');
+  expect(digest).to.equal(
+    '01add3f98ce4d49403d98362a046c6cca2c79d778426282c53e4f628f648c12b',
+  );
+});
+
+test(SUITE, 'ArrayBuffer key', () => {
+  const key = new ArrayBuffer(3);
+  const view = new Uint8Array(key);
+  view[0] = 'k'.charCodeAt(0);
+  view[1] = 'e'.charCodeAt(0);
+  view[2] = 'y'.charCodeAt(0);
+  const hmac = createHmac('sha256', key);
+  hmac.update('some data');
+  const digest = hmac.digest('hex');
+  expect(digest).to.equal(
+    '01add3f98ce4d49403d98362a046c6cca2c79d778426282c53e4f628f648c12b',
+  );
+});
+
+test(SUITE, 'digest - segfault', () => {
+  const hmac = createHmac('sha256', 'key');
+  expect(() => {
+    hmac.digest({
+      toString: () => {
+        throw new Error('segfault');
+      },
+    } as unknown as Encoding);
+  }).to.throw();
+});
+
+function testHmac(
+  title: string,
+  algo: string,
+  key: string | Buffer,
+  data: string | Buffer,
+  expected: string,
+) {
+  test(SUITE, title, () => {
+    const hmac = createHmac(algo, key);
+    hmac.update(data);
+    const digest = hmac.digest('hex');
+    expect(digest).to.equal(expected);
+  });
+}
+
+const wikipedia = [
+  {
+    key: 'key',
+    data: 'The quick brown fox jumps over the lazy dog',
+    hmac: {
+      md5: '80070713463e7749b90c2dc24911e275',
+      sha1: 'de7c9b85b8b78aa6bc8a7a36f70a90701c9db4d9',
+      sha256:
+        'f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8',
+    },
+  },
+  {
+    key: 'key',
+    data: '',
+    hmac: {
+      md5: '63530468a04e386459855da0063b6596',
+      sha1: 'f42bb0eeb018ebbd4597ae7213711ec60760843f',
+      sha256:
+        '5d5d139563c95b5967b9bd9a8c9b233a9dedb45072794cd232dc1b74832607d0',
+    },
+  },
+  {
+    key: '',
+    data: 'The quick brown fox jumps over the lazy dog',
+    hmac: {
+      md5: 'ad262969c53bc16032f160081c4a07a0',
+      sha1: '2ba7f707ad5f187c412de3106583c3111d668de8',
+      sha256:
+        'fb011e6154a19b9a4c767373c305275a5a69e8b68b0b4c9200c383dced19a416',
+    },
+  },
+  {
+    key: '',
+    data: '',
+    hmac: {
+      md5: '74e6f7298a9c2d168935f58c001bad88',
+      sha1: 'fbdb1d1b18aa6c08324b7d64b71fb76370690e1d',
+      sha256:
+        'b613679a0814d9ec772f95d778c35fc5ff1697c493715653c6c712144292c5ad',
+    },
+  },
+];
+
+for (const { key, data, hmac } of wikipedia) {
+  for (const algo in hmac)
+    testHmac(
+      `Wikipedia case - algo:'${algo}' key:'${key}' data:'${data}'`,
+      algo,
+      key,
+      data,
+      hmac[algo as keyof typeof hmac],
+    );
+}
+
+/**
+ * Test HMAC-SHA-* (RFC-4231 Test Cases)
+ * @see https://datatracker.ietf.org/doc/html/rfc4231
+ */
+const rfc4231 = [
+  {
+    key: Buffer.from('0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b', 'hex'),
+    data: Buffer.from('4869205468657265', 'hex'), // 'Hi There'
+    hmac: {
+      sha224: '896fb1128abbdf196832107cd49df33f47b4b1169912ba4f53684b22',
+      sha256:
+        'b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c' + '2e32cff7',
+      sha384:
+        'afd03944d84895626b0825f4ab46907f15f9dadbe4101ec682aa034c' +
+        '7cebc59cfaea9ea9076ede7f4af152e8b2fa9cb6',
+      sha512:
+        '87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b305' +
+        '45e17cdedaa833b7d6b8a702038b274eaea3f4e4be9d914eeb61f170' +
+        '2e696c203a126854',
+    },
+  },
+  {
+    key: Buffer.from('4a656665', 'hex'), // 'Jefe'
+    data: Buffer.from(
+      '7768617420646f2079612077616e7420666f72206e6f74686' + '96e673f',
+      'hex',
+    ), // 'what do ya want for nothing?'
+    hmac: {
+      sha224: 'a30e01098bc6dbbf45690f3a7e9e6d0f8bbea2a39e6148008fd05e44',
+      sha256:
+        '5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b9' + '64ec3843',
+      sha384:
+        'af45d2e376484031617f78d2b58a6b1b9c7ef464f5a01b47e42ec373' +
+        '6322445e8e2240ca5e69e2c78b3239ecfab21649',
+      sha512:
+        '164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7' +
+        'ea2505549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b' +
+        '636e070a38bce737',
+    },
+  },
+  {
+    key: Buffer.from('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', 'hex'),
+    data: Buffer.from(
+      'ddddddddddddddddddddddddddddddddddddddddddddddddd' +
+        'ddddddddddddddddddddddddddddddddddddddddddddddddddd',
+      'hex',
+    ),
+    hmac: {
+      sha224: '7fb3cb3588c6c1f6ffa9694d7d6ad2649365b0c1f65d69d1ec8333ea',
+      sha256:
+        '773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514' + 'ced565fe',
+      sha384:
+        '88062608d3e6ad8a0aa2ace014c8a86f0aa635d947ac9febe83ef4e5' +
+        '5966144b2a5ab39dc13814b94e3ab6e101a34f27',
+      sha512:
+        'fa73b0089d56a284efb0f0756c890be9b1b5dbdd8ee81a3655f83e33' +
+        'b2279d39bf3e848279a722c806b485a47e67c807b946a337bee89426' +
+        '74278859e13292fb',
+    },
+  },
+  {
+    key: Buffer.from(
+      '0102030405060708090a0b0c0d0e0f10111213141516171819',
+      'hex',
+    ),
+    data: Buffer.from(
+      'cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc' +
+        'dcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd',
+      'hex',
+    ),
+    hmac: {
+      sha224: '6c11506874013cac6a2abc1bb382627cec6a90d86efc012de7afec5a',
+      sha256:
+        '82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff4' + '6729665b',
+      sha384:
+        '3e8a69b7783c25851933ab6290af6ca77a9981480850009cc5577c6e' +
+        '1f573b4e6801dd23c4a7d679ccf8a386c674cffb',
+      sha512:
+        'b0ba465637458c6990e5a8c5f61d4af7e576d97ff94b872de76f8050' +
+        '361ee3dba91ca5c11aa25eb4d679275cc5788063a5f19741120c4f2d' +
+        'e2adebeb10a298dd',
+    },
+  },
+  {
+    key: Buffer.from('0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c', 'hex'),
+    // 'Test With Truncation'
+    data: Buffer.from('546573742057697468205472756e636174696f6e', 'hex'),
+    hmac: {
+      sha224: '0e2aea68a90c8d37c988bcdb9fca6fa8',
+      sha256: 'a3b6167473100ee06e0c796c2955552b',
+      sha384: '3abf34c3503b2a23a46efc619baef897',
+      sha512: '415fad6271580a531d4179bc891d87a6',
+    },
+    truncate: true,
+  },
+  {
+    key: Buffer.from(
+      'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaa',
+      'hex',
+    ),
+    // 'Test Using Larger Than Block-Size Key - Hash Key First'
+    data: Buffer.from(
+      '54657374205573696e67204c6172676572205468616e20426' +
+        'c6f636b2d53697a65204b6579202d2048617368204b657920' +
+        '4669727374',
+      'hex',
+    ),
+    hmac: {
+      sha224: '95e9a0db962095adaebe9b2d6f0dbce2d499f112f2d2b7273fa6870e',
+      sha256:
+        '60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f' + '0ee37f54',
+      sha384:
+        '4ece084485813e9088d2c63a041bc5b44f9ef1012a2b588f3cd11f05' +
+        '033ac4c60c2ef6ab4030fe8296248df163f44952',
+      sha512:
+        '80b24263c7c1a3ebb71493c1dd7be8b49b46d1f41b4aeec1121b0137' +
+        '83f8f3526b56d037e05f2598bd0fd2215d6a1e5295e64f73f63f0aec' +
+        '8b915a985d786598',
+    },
+  },
+  {
+    key: Buffer.from(
+      'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaa',
+      'hex',
+    ),
+    // 'This is a test using a larger than block-size key and a larger ' +
+    // 'than block-size data. The key needs to be hashed before being ' +
+    // 'used by the HMAC algorithm.'
+    data: Buffer.from(
+      '5468697320697320612074657374207573696e672061206c6' +
+        '172676572207468616e20626c6f636b2d73697a65206b6579' +
+        '20616e642061206c6172676572207468616e20626c6f636b2' +
+        'd73697a6520646174612e20546865206b6579206e65656473' +
+        '20746f20626520686173686564206265666f7265206265696' +
+        'e6720757365642062792074686520484d414320616c676f72' +
+        '6974686d2e',
+      'hex',
+    ),
+    hmac: {
+      sha224: '3a854166ac5d9f023f54d517d0b39dbd946770db9c2b95c9f6f565d1',
+      sha256:
+        '9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f5153' + '5c3a35e2',
+      sha384:
+        '6617178e941f020d351e2f254e8fd32c602420feb0b8fb9adccebb82' +
+        '461e99c5a678cc31e799176d3860e6110c46523e',
+      sha512:
+        'e37b6a775dc87dbaa4dfa9f96e5e3ffddebd71f8867289865df5a32d' +
+        '20cdc944b6022cac3c4982b10d5eeb55c3e4de15134676fb6de04460' +
+        '65c97440fa8c6a58',
+    },
+  },
+];
+
+for (let i = 0, l = rfc4231.length; i < l; i++) {
+  for (const hash in rfc4231[i]!.hmac) {
+    test(SUITE, `HMAC-${hash} RFC-4231 case ${i + 1}`, () => {
+      const str = crypto.createHmac(hash, rfc4231[i]!.key);
+      str.end(rfc4231[i]!.data);
+      let strRes = str.read().toString('hex');
+      let actual = crypto
+        .createHmac(hash, rfc4231[i]!.key)
+        .update(rfc4231[i]!.data)
+        .digest('hex');
+      if (rfc4231[i]!.truncate) {
+        actual = actual.substr(0, 32); // first 128 bits == 32 hex chars
+        strRes = strRes.substr(0, 32);
+      }
+      const expected = (rfc4231[i]!.hmac as Record<string, string>)[hash];
+      expect(actual).to.be.eql(expected);
+      expect(actual).to.be.eql(strRes);
+    });
+  }
+}
+
+/**
+ * Test HMAC-MD5/SHA1 (RFC-2202 Test Cases)
+ * @see https://datatracker.ietf.org/doc/html/rfc2202
+ */
+const rfc2202_md5 = [
+  {
+    key: Buffer.from('0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b', 'hex'),
+    data: 'Hi There',
+    hmac: '9294727a3638bb1c13f48ef8158bfc9d',
+  },
+  {
+    key: 'Jefe',
+    data: 'what do ya want for nothing?',
+    hmac: '750c783e6ab0b503eaa86e310a5db738',
+  },
+  {
+    key: Buffer.from('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', 'hex'),
+    data: Buffer.from(
+      'ddddddddddddddddddddddddddddddddddddddddddddddddd' +
+        'ddddddddddddddddddddddddddddddddddddddddddddddddddd',
+      'hex',
+    ),
+    hmac: '56be34521d144c88dbb8c733f0e8b3f6',
+  },
+  {
+    key: Buffer.from(
+      '0102030405060708090a0b0c0d0e0f10111213141516171819',
+      'hex',
+    ),
+    data: Buffer.from(
+      'cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc' +
+        'dcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd' +
+        'cdcdcdcdcd',
+      'hex',
+    ),
+    hmac: '697eaf0aca3a3aea3a75164746ffaa79',
+  },
+  {
+    key: Buffer.from('0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c', 'hex'),
+    data: 'Test With Truncation',
+    hmac: '56461ef2342edc00f9bab995690efd4c',
+  },
+  {
+    key: Buffer.from(
+      'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaa',
+      'hex',
+    ),
+    data: 'Test Using Larger Than Block-Size Key - Hash Key First',
+    hmac: '6b1ab7fe4bd7bf8f0b62e6ce61b9d0cd',
+  },
+  {
+    key: Buffer.from(
+      'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaa',
+      'hex',
+    ),
+    data:
+      'Test Using Larger Than Block-Size Key and Larger Than One ' +
+      'Block-Size Data',
+    hmac: '6f630fad67cda0ee1fb1f562db3aa53e',
+  },
+];
+
+for (let i = 0, l = rfc2202_md5.length; i < l; i++) {
+  const { key, data, hmac } = rfc2202_md5[i]!;
+  testHmac(`HMAC-MD5 RFC-2202 MD5 test case ${i + 1}`, 'md5', key, data, hmac);
+}
+
+/**
+ * Test HMAC-SHA1 (RFC-2202 Test Cases)
+ * @see https://datatracker.ietf.org/doc/html/rfc2202
+ */
+const rfc2202_sha1 = [
+  {
+    key: Buffer.from('0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b', 'hex'),
+    data: 'Hi There',
+    hmac: 'b617318655057264e28bc0b6fb378c8ef146be00',
+  },
+  {
+    key: 'Jefe',
+    data: 'what do ya want for nothing?',
+    hmac: 'effcdf6ae5eb2fa2d27416d5f184df9c259a7c79',
+  },
+  {
+    key: Buffer.from('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', 'hex'),
+    data: Buffer.from(
+      'ddddddddddddddddddddddddddddddddddddddddddddd' +
+        'ddddddddddddddddddddddddddddddddddddddddddddd' +
+        'dddddddddd',
+      'hex',
+    ),
+    hmac: '125d7342b9ac11cd91a39af48aa17b4f63f175d3',
+  },
+  {
+    key: Buffer.from(
+      '0102030405060708090a0b0c0d0e0f10111213141516171819',
+      'hex',
+    ),
+    data: Buffer.from(
+      'cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc' +
+        'dcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd' +
+        'cdcdcdcdcd',
+      'hex',
+    ),
+    hmac: '4c9007f4026250c6bc8414f9bf50c86c2d7235da',
+  },
+  {
+    key: Buffer.from('0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c', 'hex'),
+    data: 'Test With Truncation',
+    hmac: '4c1a03424b55e07fe7f27be1d58bb9324a9a5a04',
+  },
+  {
+    key: Buffer.from(
+      'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaa',
+      'hex',
+    ),
+    data: 'Test Using Larger Than Block-Size Key - Hash Key First',
+    hmac: 'aa4ae5e15272d00e95705637ce8a3b55ed402112',
+  },
+  {
+    key: Buffer.from(
+      'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaa',
+      'hex',
+    ),
+    data:
+      'Test Using Larger Than Block-Size Key and Larger Than One ' +
+      'Block-Size Data',
+    hmac: 'e8e99d0f45237d786d6bbaa7965c7808bbff1a91',
+  },
+];
+
+for (let i = 0, l = rfc2202_sha1.length; i < l; i++) {
+  const { key, data, hmac } = rfc2202_sha1[i]!;
+  testHmac(
+    `HMAC-SHA1 RFC-2202 SHA1 test case ${i + 1}`,
+    'sha1',
+    key,
+    data,
+    hmac,
+  );
+}
+
+test(SUITE, 'digest with ucs2 encoding', () => {
+  assert.strictEqual(
+    crypto.createHmac('sha256', 'w00t').digest('ucs2'),
+    crypto.createHmac('sha256', 'w00t').digest().toString('ucs2'),
+  );
+});
diff --git a/packages/react-native-quick-crypto/android/CMakeLists.txt b/packages/react-native-quick-crypto/android/CMakeLists.txt
index 489c1d58..dd764141 100644
--- a/packages/react-native-quick-crypto/android/CMakeLists.txt
+++ b/packages/react-native-quick-crypto/android/CMakeLists.txt
@@ -9,6 +9,7 @@ set(CMAKE_CXX_STANDARD 20)
 add_library(
   ${PACKAGE_NAME} SHARED
   src/main/cpp/cpp-adapter.cpp
+  ../cpp/hmac/HybridHmac.cpp
   ../cpp/hash/HybridHash.cpp
   ../cpp/ed25519/HybridEdKeyPair.cpp
   ../cpp/pbkdf2/HybridPbkdf2.cpp
@@ -22,6 +23,7 @@ include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/QuickCrypto+autolinkin
 # local includes
 include_directories(
   "src/main/cpp"
+  "../cpp/hmac"
   "../cpp/hash"
   "../cpp/ed25519"
   "../cpp/pbkdf2"
diff --git a/packages/react-native-quick-crypto/cpp/hmac/HybridHmac.cpp b/packages/react-native-quick-crypto/cpp/hmac/HybridHmac.cpp
new file mode 100644
index 00000000..2f0e8be6
--- /dev/null
+++ b/packages/react-native-quick-crypto/cpp/hmac/HybridHmac.cpp
@@ -0,0 +1,95 @@
+#include <NitroModules/ArrayBuffer.hpp>
+#include <memory>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "HybridHmac.hpp"
+
+namespace margelo::nitro::crypto {
+
+HybridHmac::~HybridHmac() {
+  if (ctx) {
+    EVP_MAC_CTX_free(ctx);
+    ctx = nullptr;
+  }
+}
+
+void HybridHmac::createHmac(const std::string& hmacAlgorithm, const std::shared_ptr<ArrayBuffer>& secretKey) {
+  algorithm = hmacAlgorithm;
+
+  // Create and use EVP_MAC locally
+  EVP_MAC* mac = EVP_MAC_fetch(nullptr, "HMAC", nullptr);
+  if (!mac) {
+    throw std::runtime_error("Failed to fetch HMAC implementation: " + std::to_string(ERR_get_error()));
+  }
+
+  // Create HMAC context
+  ctx = EVP_MAC_CTX_new(mac);
+  EVP_MAC_free(mac); // Free immediately after creating the context
+  if (!ctx) {
+    throw std::runtime_error("Failed to create HMAC context: " + std::to_string(ERR_get_error()));
+  }
+
+  // Validate algorithm
+  const EVP_MD* md = EVP_get_digestbyname(algorithm.c_str());
+  if (!md) {
+    throw std::runtime_error("Unknown HMAC algorithm: " + algorithm);
+  }
+
+  // Set up parameters for HMAC
+  OSSL_PARAM params[2];
+  params[0] = OSSL_PARAM_construct_utf8_string("digest", const_cast<char*>(algorithm.c_str()), 0);
+  params[1] = OSSL_PARAM_construct_end();
+
+  const uint8_t* keyData = reinterpret_cast<const uint8_t*>(secretKey->data());
+  size_t keySize = secretKey->size();
+
+  // Handle empty key case by providing a dummy key
+  static const uint8_t dummyKey = 0;
+  if (keySize == 0) {
+    keyData = &dummyKey;
+    keySize = 1;
+  }
+
+  // Initialize HMAC
+  if (EVP_MAC_init(ctx, keyData, keySize, params) != 1) {
+    throw std::runtime_error("Failed to initialize HMAC: " + std::to_string(ERR_get_error()));
+  }
+}
+
+void HybridHmac::update(const std::shared_ptr<ArrayBuffer>& data) {
+  if (!ctx) {
+    throw std::runtime_error("HMAC context not initialized");
+  }
+
+  // Update HMAC with new data
+  if (EVP_MAC_update(ctx, reinterpret_cast<const uint8_t*>(data->data()), data->size()) != 1) {
+    throw std::runtime_error("Failed to update HMAC: " + std::to_string(ERR_get_error()));
+  }
+}
+
+std::shared_ptr<ArrayBuffer> HybridHmac::digest() {
+  if (!ctx) {
+    throw std::runtime_error("HMAC context not initialized");
+  }
+
+  // Determine the maximum possible size of the HMAC output
+  const EVP_MD* md = EVP_get_digestbyname(algorithm.c_str());
+  const size_t hmacLength = EVP_MD_get_size(md);
+
+  // Allocate buffer with the exact required size
+  uint8_t* hmacBuffer = new uint8_t[hmacLength];
+
+  // Finalize the HMAC computation directly into the final buffer
+  if (EVP_MAC_final(ctx, hmacBuffer, nullptr, hmacLength) != 1) {
+    delete[] hmacBuffer;
+    throw std::runtime_error("Failed to finalize HMAC digest: " + std::to_string(ERR_get_error()));
+  }
+
+  return std::make_shared<NativeArrayBuffer>(hmacBuffer, hmacLength, [=]() { delete[] hmacBuffer; });
+}
+
+} // namespace margelo::nitro::crypto
diff --git a/packages/react-native-quick-crypto/cpp/hmac/HybridHmac.hpp b/packages/react-native-quick-crypto/cpp/hmac/HybridHmac.hpp
new file mode 100644
index 00000000..eaf08b6b
--- /dev/null
+++ b/packages/react-native-quick-crypto/cpp/hmac/HybridHmac.hpp
@@ -0,0 +1,31 @@
+#include <NitroModules/ArrayBuffer.hpp>
+#include <memory>
+#include <openssl/evp.h>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "HybridHmacSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+using namespace facebook;
+
+class HybridHmac : public HybridHmacSpec {
+ public:
+  HybridHmac() : HybridObject(TAG) {}
+  ~HybridHmac();
+
+ public:
+  // Methods
+  void createHmac(const std::string& algorithm, const std::shared_ptr<ArrayBuffer>& key) override;
+  void update(const std::shared_ptr<ArrayBuffer>& data) override;
+  std::shared_ptr<ArrayBuffer> digest() override;
+
+ private:
+  // Properties
+  EVP_MAC_CTX* ctx = nullptr;
+  std::string algorithm = "";
+};
+
+} // namespace margelo::nitro::crypto
diff --git a/packages/react-native-quick-crypto/nitro.json b/packages/react-native-quick-crypto/nitro.json
index a205a7e0..90aefe25 100644
--- a/packages/react-native-quick-crypto/nitro.json
+++ b/packages/react-native-quick-crypto/nitro.json
@@ -8,6 +8,7 @@
     "androidCxxLibName": "QuickCrypto"
   },
   "autolinking": {
+    "Hmac": { "cpp": "HybridHmac" },
     "Hash": { "cpp": "HybridHash" },
     "EdKeyPair": { "cpp": "HybridEdKeyPair" },
     "Pbkdf2": { "cpp": "HybridPbkdf2" },
diff --git a/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCrypto+autolinking.cmake b/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCrypto+autolinking.cmake
index a779838e..1c3ffd01 100644
--- a/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCrypto+autolinking.cmake
+++ b/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCrypto+autolinking.cmake
@@ -29,6 +29,7 @@ target_sources(
   # Shared Nitrogen C++ sources
   ../nitrogen/generated/shared/c++/HybridEdKeyPairSpec.cpp
   ../nitrogen/generated/shared/c++/HybridHashSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridHmacSpec.cpp
   ../nitrogen/generated/shared/c++/HybridKeyObjectHandleSpec.cpp
   ../nitrogen/generated/shared/c++/HybridPbkdf2Spec.cpp
   ../nitrogen/generated/shared/c++/HybridRandomSpec.cpp
diff --git a/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCryptoOnLoad.cpp b/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCryptoOnLoad.cpp
index e163fb62..6103dc90 100644
--- a/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCryptoOnLoad.cpp
+++ b/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCryptoOnLoad.cpp
@@ -15,6 +15,7 @@
 #include <fbjni/fbjni.h>
 #include <NitroModules/HybridObjectRegistry.hpp>
 
+#include "HybridHmac.hpp"
 #include "HybridHash.hpp"
 #include "HybridEdKeyPair.hpp"
 #include "HybridPbkdf2.hpp"
@@ -32,6 +33,15 @@ int initialize(JavaVM* vm) {
     
 
     // Register Nitro Hybrid Objects
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "Hmac",
+      []() -> std::shared_ptr<HybridObject> {
+        static_assert(std::is_default_constructible_v<HybridHmac>,
+                      "The HybridObject \"HybridHmac\" is not default-constructible! "
+                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+        return std::make_shared<HybridHmac>();
+      }
+    );
     HybridObjectRegistry::registerHybridObjectConstructor(
       "Hash",
       []() -> std::shared_ptr<HybridObject> {
diff --git a/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCryptoAutolinking.mm b/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCryptoAutolinking.mm
index 4bb042fe..82355cc7 100644
--- a/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCryptoAutolinking.mm
+++ b/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCryptoAutolinking.mm
@@ -10,6 +10,7 @@
 
 #import <type_traits>
 
+#include "HybridHmac.hpp"
 #include "HybridHash.hpp"
 #include "HybridEdKeyPair.hpp"
 #include "HybridPbkdf2.hpp"
@@ -24,6 +25,15 @@ + (void) load {
   using namespace margelo::nitro;
   using namespace margelo::nitro::crypto;
 
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Hmac",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridHmac>,
+                    "The HybridObject \"HybridHmac\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridHmac>();
+    }
+  );
   HybridObjectRegistry::registerHybridObjectConstructor(
     "Hash",
     []() -> std::shared_ptr<HybridObject> {
diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHmacSpec.cpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHmacSpec.cpp
new file mode 100644
index 00000000..502ab3d9
--- /dev/null
+++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHmacSpec.cpp
@@ -0,0 +1,23 @@
+///
+/// HybridHmacSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridHmacSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+  void HybridHmacSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("createHmac", &HybridHmacSpec::createHmac);
+      prototype.registerHybridMethod("update", &HybridHmacSpec::update);
+      prototype.registerHybridMethod("digest", &HybridHmacSpec::digest);
+    });
+  }
+
+} // namespace margelo::nitro::crypto
diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHmacSpec.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHmacSpec.hpp
new file mode 100644
index 00000000..f8be73eb
--- /dev/null
+++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHmacSpec.hpp
@@ -0,0 +1,66 @@
+///
+/// HybridHmacSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `ArrayBuffer` to properly resolve imports.
+namespace NitroModules { class ArrayBuffer; }
+
+#include <string>
+#include <NitroModules/ArrayBuffer.hpp>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Hmac`
+   * Inherit this class to create instances of `HybridHmacSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridHmac: public HybridHmacSpec {
+   * public:
+   *   HybridHmac(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridHmacSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridHmacSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      virtual ~HybridHmacSpec() { }
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual void createHmac(const std::string& algorithm, const std::shared_ptr<ArrayBuffer>& key) = 0;
+      virtual void update(const std::shared_ptr<ArrayBuffer>& data) = 0;
+      virtual std::shared_ptr<ArrayBuffer> digest() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Hmac";
+  };
+
+} // namespace margelo::nitro::crypto
diff --git a/packages/react-native-quick-crypto/src/hmac.ts b/packages/react-native-quick-crypto/src/hmac.ts
new file mode 100644
index 00000000..bbc9a5f9
--- /dev/null
+++ b/packages/react-native-quick-crypto/src/hmac.ts
@@ -0,0 +1,135 @@
+import { Buffer } from '@craftzdog/react-native-buffer';
+import { Stream } from 'readable-stream';
+import { NitroModules } from 'react-native-nitro-modules';
+import type { TransformOptions } from 'readable-stream';
+import type { Hmac as NativeHmac } from './specs/hmac.nitro';
+import type { BinaryLike, Encoding } from './utils/types';
+import { ab2str, binaryLikeToArrayBuffer } from './utils/conversion';
+
+interface HmacArgs {
+  algorithm: string;
+  key: BinaryLike;
+  options?: TransformOptions;
+}
+
+class Hmac extends Stream.Transform {
+  private algorithm: string;
+  private key: BinaryLike;
+  private native: NativeHmac;
+
+  private validate(args: HmacArgs) {
+    if (typeof args.algorithm !== 'string' || args.algorithm.length === 0)
+      throw new Error('Algorithm must be a non-empty string');
+    if (args.key === null || args.key === undefined)
+      throw new Error('Key must not be null or undefined');
+  }
+
+  /**
+   * @internal use `createHmac()` instead
+   */
+  private constructor(args: HmacArgs) {
+    super(args.options);
+
+    this.validate(args);
+
+    this.algorithm = args.algorithm;
+    this.key = args.key;
+
+    this.native = NitroModules.createHybridObject<NativeHmac>('Hmac');
+    this.native.createHmac(this.algorithm, binaryLikeToArrayBuffer(this.key));
+  }
+
+  /**
+   * Updates the `Hmac` content with the given `data`, the encoding of which is given in `inputEncoding`.
+   * If `encoding` is not provided, and the `data` is a string, an encoding of `'utf8'` is enforced.
+   * If `data` is a `Buffer`, `TypedArray`, or`DataView`, then `inputEncoding` is ignored.
+   *
+   * This can be called many times with new data as it is streamed.
+   * @since v1.0.0
+   * @param inputEncoding The `encoding` of the `data` string.
+   */
+  update(data: BinaryLike): Hmac;
+  update(data: BinaryLike, inputEncoding: Encoding): Hmac;
+  update(data: BinaryLike, inputEncoding?: Encoding): Hmac {
+    const defaultEncoding: Encoding = 'utf8';
+    inputEncoding = inputEncoding ?? defaultEncoding;
+
+    this.native.update(binaryLikeToArrayBuffer(data, inputEncoding));
+
+    return this; // to support chaining syntax createHmac().update().digest()
+  }
+
+  /**
+   * Calculates the HMAC digest of all of the data passed using `hmac.update()`.
+   * If `encoding` is provided a string is returned; otherwise a `Buffer` is returned;
+   *
+   * The `Hmac` object can not be used again after `hmac.digest()` has been
+   * called. Multiple calls to `hmac.digest()` will result in an error being thrown.
+   * @since v1.0.0
+   * @param encoding The `encoding` of the return value.
+   */
+  digest(): Buffer;
+  digest(encoding: Encoding): string;
+  digest(encoding?: Encoding): Buffer | string {
+    const nativeDigest = this.native.digest();
+
+    if (encoding && encoding !== 'buffer') {
+      return ab2str(nativeDigest, encoding);
+    }
+
+    return Buffer.from(nativeDigest);
+  }
+
+  // stream interface
+  _transform(
+    chunk: BinaryLike,
+    encoding: BufferEncoding,
+    callback: () => void,
+  ) {
+    this.update(chunk, encoding as Encoding);
+    callback();
+  }
+  _flush(callback: () => void) {
+    this.push(this.digest());
+    callback();
+  }
+}
+
+/**
+ * Creates and returns an `Hmac` object that uses the given `algorithm` and `key`.
+ * Optional `options` argument controls stream behavior.
+ *
+ * The `algorithm` is dependent on the available algorithms supported by the
+ * version of OpenSSL on the platform. Examples are `'sha256'`, `'sha512'`, etc.
+ * On recent releases of OpenSSL, `openssl list -digest-algorithms` will
+ * display the available digest algorithms.
+ *
+ * Example: generating the sha256 HMAC of a file
+ *
+ * ```js
+ * import crypto from 'react-native-quick-crypto';
+ *
+ * const hmac = crypto.createHmac('sha256', 'secret-key');
+ * hmac.update('message to hash');
+ * const digest = hmac.digest('hex');
+ * console.log(digest); // prints HMAC digest in hexadecimal format
+ * ```
+ * @since v1.0.0
+ * @param options `stream.transform` options
+ */
+export function createHmac(
+  algorithm: string,
+  key: BinaryLike,
+  options?: TransformOptions,
+): Hmac {
+  // @ts-expect-error private constructor
+  return new Hmac({
+    algorithm,
+    key,
+    options,
+  });
+}
+
+export const hmacExports = {
+  createHmac,
+};
diff --git a/packages/react-native-quick-crypto/src/index.ts b/packages/react-native-quick-crypto/src/index.ts
index ac99438b..f6dae5c6 100644
--- a/packages/react-native-quick-crypto/src/index.ts
+++ b/packages/react-native-quick-crypto/src/index.ts
@@ -4,6 +4,7 @@ import { Buffer } from '@craftzdog/react-native-buffer';
 // API imports
 import * as keys from './keys';
 import { hashExports as hash } from './hash';
+import { hmacExports as hmac } from './hmac';
 import * as ed from './ed';
 import * as pbkdf2 from './pbkdf2';
 import * as random from './random';
@@ -35,6 +36,7 @@ const QuickCrypto = {
   // constants,
   ...keys,
   ...hash,
+  ...hmac,
   ...ed,
   ...pbkdf2,
   ...random,
@@ -62,6 +64,7 @@ global.process.nextTick = setImmediate;
 // exports
 export default QuickCrypto;
 export * from './hash';
+export * from './hmac';
 export * from './ed';
 export * from './pbkdf2';
 export * from './random';
diff --git a/packages/react-native-quick-crypto/src/specs/hmac.nitro.ts b/packages/react-native-quick-crypto/src/specs/hmac.nitro.ts
new file mode 100644
index 00000000..25a88f62
--- /dev/null
+++ b/packages/react-native-quick-crypto/src/specs/hmac.nitro.ts
@@ -0,0 +1,7 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+export interface Hmac extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  createHmac(algorithm: string, key: ArrayBuffer): void;
+  update(data: ArrayBuffer): void;
+  digest(): ArrayBuffer;
+}