RMD160INIT(3) | Library Functions Manual | RMD160INIT(3)

# NAME

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

# SYNOPSIS

`#include <sys/types.h>`
`#include <rmd160.h>`

void
`RMD160Init`(RMD160_CTX *context);

void
`RMD160Update`(RMD160_CTX *context, const u_int8_t *data, size_t nbytes);

void
`RMD160Pad`(RMD160_CTX *context);

void
`RMD160Final`(u_int8_t digest[RMD160_DIGEST_LENGTH], RMD160_CTX *context);

void
`RMD160Transform`(u_int32_t state[5], const u_int8_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 u_int8_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 MD5 functions and at least as secure as the SHA1 function. 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) and should be freed using free(3) 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;
    u_int8_t results[RMD160_DIGEST_LENGTH];
    char *buf;
    int n;

    buf = "abc";
    n = strlen(buf);
    RMD160Init(&rmd);
    RMD160Update(&rmd, (u_int8_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;
    u_int8_t output[RMD160_DIGEST_STRING_LENGTH];
    char *buf = "abc";

    printf("0x%s\n", RMD160Data(buf, strlen(buf), output));

# SEE ALSO

cksum(1), MD5Init(3), SHA1Init(3), SHA256Init(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

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.

June 13, 2025 | Debian