RMD160(3) Library Functions Manual RMD160(3)

# [NAME](#NAME)

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

# [LIBRARY](#LIBRARY)

Message Digest (MD4, MD5, etc.) Support Library (libmd, -lmd)

# [SYNOPSIS](#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](#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)](/man/os/libmd/md4.3), [md5(3)](/man/os/libmd/md5.3) and [sha1(3)](/man/os/libmd/sha1.3) functions. All share a similar interface.

The [`RMD160Init`](#RMD160Init)() function initializes a RMD160\_CTX `context` for use with [`RMD160Update`](#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`](#RMD160Pad)() function can be used to apply padding to the message digest as in [`RMD160Final`](#RMD160Final)(), but the current context can still be used with `RMD160Update`().

The [`RMD160Transform`](#RMD160Transform)() function is used by [`RMD160Update`](#RMD160Update~2)() 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`](#RMD160End)() function is a front end for [`RMD160Final`](#RMD160Final~2)() which converts the digest into an ASCII representation of the 160 bit digest in hexadecimal.

The [`RMD160File`](#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`](#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`](#RMD160Data)() function calculates the digest of an arbitrary string and returns the result via `RMD160End`().

For each of the [`RMD160End`](#RMD160End~2)(), `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)](/man/os/libmd/malloc.3) and should be freed using [free(3)](/man/os/libmd/free.3) when it is no longer needed.

# [EXAMPLES](#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](#SEE_ALSO)

[cksum(1)](/man/os/libmd/cksum.1), [md4(3)](/man/os/libmd/md4.3), [md5(3)](/man/os/libmd/md5.3), [sha1(3)](/man/os/libmd/sha1.3), [sha2(3)](/man/os/libmd/sha2.3)

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](#HISTORY)

The RMD-160 functions appeared in OpenBSD 2.1.

# [AUTHORS](#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](#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.

July 13, 2010 Linux 4.19.0-gvisor

---

Document: RMD160File(3) from libmd 1.3.0-r2 (Chainguard OS)
Source: https://gitlab.freedesktop.org/libbsd/libmd.git