---
name: "RMD160Init"
section: "3"
platform: "linux"
package: "libmd"
version: "1.3.0-1"
release: "Arch Linux 2026-11-01"
platforms: ["linux"]
url: "https://new.carta.tech/rmd160/3"
---

# RMD160Init(3)

calculate the \`\`RIPEMD-160'' message digest

Part of [rmd160(3)](/rmd160/3.md).

## NAME

**RMD160Init**, **RMD160Update**, **RMD160Pad**, **RMD160Final**, **RMD160Transform**, **RMD160End**, **RMD160File**, **RMD160FileChunk**, **RMD160Data** – calculate the \`\`RIPEMD-160'' message digest

## LIBRARY

library “libmd”

## SYNOPSIS

**#include \<sys/types.h\>**

**#include \<rmd160.h\>**

*void*\

**RMD160Init**(*RMD160\_CTX \*context*);

*void*\

**RMD160Update**(*RMD160\_CTX \*context*, *const uint8\_t \*data*, *uint32\_t nbytes*);

*void*\

**RMD160Pad**(*RMD160\_CTX \*context*);

*void*\

**RMD160Final**(*uint8\_t digest\[RMD160\_DIGEST\_LENGTH\]*, *RMD160\_CTX \*context*);

*void*\

**RMD160Transform**(*uint32\_t state\[5\]*, *const uint8\_t block\[RMD160\_BLOCK\_LENGTH\]*);

*char \**\

**RMD160End**(*RMD160\_CTX \*context*, *char \*buf*);

*char \**\

**RMD160File**(*const char \*filename*, *char \*buf*);

*char \**\

**RMD160FileChunk**(*const char \*filename*, *char \*buf*, *off\_t offset*, *off\_t length*);

*char \**\

**RMD160Data**(*const uint8\_t \*data*, *size\_t len*, *char \*buf*);

## DESCRIPTION

The RMD160 functions implement the 160-bit RIPE message digest hash algorithm (RMD-160). RMD-160 is used to generate a condensed representation of a message called a message digest. The algorithm takes a message less than 2^64 bits as input and produces a 160-bit digest suitable for use as a digital signature.

The RMD160 functions are considered to be more secure than the [md4(3)](/md4/3.md), [md5(3)](/md5/3.md) and [sha1(3)](/sha1/3.md) functions. All share a similar interface.

The **RMD160Init**() function initializes a RMD160\_CTX *context* for use with **RMD160Update**(), and **RMD160Final**(). The **RMD160Update**() function adds *data* of length *nbytes* to the RMD160\_CTX specified by *context*. **RMD160Final**() is called when all data has been added via **RMD160Update**() and stores a message digest in the *digest* parameter.

The **RMD160Pad**() function can be used to apply padding to the message digest as in **RMD160Final**(), but the current context can still be used with **RMD160Update**().

The **RMD160Transform**() function is used by **RMD160Update**() to hash 512-bit blocks and forms the core of the algorithm. Most programs should use the interface provided by **RMD160Init**(), **RMD160Update**() and **RMD160Final**() instead of calling **RMD160Transform**() directly.

The **RMD160End**() function is a front end for **RMD160Final**() which converts the digest into an ASCII representation of the 160 bit digest in hexadecimal.

The **RMD160File**() function calculates the digest for a file and returns the result via **RMD160End**(). If **RMD160File**() is unable to open the file a NULL pointer is returned.

**RMD160FileChunk**() behaves like **RMD160File**() but calculates the digest only for that portion of the file starting at *offset* and continuing for *length* bytes or until end of file is reached, whichever comes first. A zero *length* can be specified to read until end of file. A negative *length* or *offset* will be ignored.

The **RMD160Data**() function calculates the digest of an arbitrary string and returns the result via **RMD160End**().

For each of the **RMD160End**(), **RMD160File**(), and **RMD160Data**() functions the *buf* parameter should either be a string of at least 41 characters in size or a NULL pointer. In the latter case, space will be dynamically allocated via [malloc(3)](/malloc/3.md) and should be freed using [free(3)](/free/3.md) when it is no longer needed.

## EXAMPLES

The follow code fragment will calculate the digest for the string "abc" which is \`\`0x8eb208f7e05d987a9b044a8e98c6b087f15a0bfc''.

```
RMD160_CTX rmd;
uint8_t results[RMD160_DIGEST_LENGTH];
char *buf;
int n;
buf = "abc";
n = strlen(buf);
RMD160Init(&rmd);
RMD160Update(&rmd, (uint8_t *)buf, n);
RMD160Final(results, &rmd);
/* Print the digest as one long hex value */
printf("0x");
for (n = 0; n < RMD160_DIGEST_LENGTH; n++)
	printf("%02x", results[n]);
putchar('\n');
```

Alternately, the helper functions could be used in the following way:

```
RMD160_CTX rmd;
uint8_t output[RMD160_DIGEST_STRING_LENGTH];
char *buf = "abc";
printf("0x%s\n", RMD160Data(buf, strlen(buf), output));
```

## SEE ALSO

[cksum(1)](/cksum/1.md), [md4(3)](/md4/3.md), [md5(3)](/md5/3.md), [sha1(3)](/sha1/3.md), [sha2(3)](/sha2/3.md) H. Dobbertin, A. Bosselaers, B. Preneel, *RIPEMD-160, a strengthened version of RIPEMD*. *Information technology - Security techniques - Hash-functions - Part 3: Dedicated hash-functions*, ISO/IEC 10118-3. H. Dobbertin, A. Bosselaers, B. Preneel, “The RIPEMD-160 cryptographic hash function”, *Dr. Dobb's Journal*, Vol. 22, No. 1, pp. 24-28, January 1997.

## HISTORY

The RMD-160 functions appeared in OpenBSD 2.1.

## AUTHORS

This implementation of RMD-160 was written by Markus Friedl.

The **RMD160End**(), **RMD160File**(), **RMD160FileChunk**(), and **RMD160Data**() helper functions are derived from code written by Poul-Henning Kamp.

## CAVEATS

If a message digest is to be copied to a multi-byte type (ie: an array of five 32-bit integers) it will be necessary to perform byte swapping on little endian machines such as the i386, alpha, and vax.