Unix (all-caps UNIX for the trademark) is a family of multitasking, multiuser computer operating systems that derive from the original AT&T Unix, developed in the 1970s at the Bell Labs research center by Ken Thompson, Dennis Ritchie, and others.

Rbcafe » Unix



netinfod – NetInfo daemon


netinfod domain-tag


The netinfod daemon serves the information in the given domain-tag to
the network. It is normally executed automatically by nibindd(8) and
should not be run manually.


/etc/netinfo/domain-tag.nidb – where the actual information served is


Rbcafe » Unix



memberd — group membership resolution daemon


memberd [options]


memberd is a daemon process used by the system to resolve group member-
ships. It should always be running and responds to messages from the
kernel or other processes using membership API calls. All resolution is
done using Open Directory calls for both legacy and new group formats,
including support for nested group resolution.

A list of flags and their descriptions:

-h Lists the options for calling memberd
-v Prints the build version
-x Prevents memberd from daemonizing
-d Same as -x but enables output to terminal
-s Prints usage statistics for the running daemon
-c Clears existing statistics for running daemon
-t Runs a self test against the running daemon
-r Resets the memberd cache
-u Ar name Determines the UUID for the provided username
-g Ar group Determins the UUID for the provided group name
-l Dumps log to a file in /Library/Logs/memberd_dump.log
-L Dumps log and cache to log file in /Library/Logs/memberd_dump.log


Rbcafe » Unix



mDNSResponder — Multicast DNS daemon




mDNSResponder (also known as mdnsd on some systems) is a daemon invoked
at boot time to implement Multicast DNS and DNS Service Discovery.

mDNSResponder listens UDP port 5353 for Multicast DNS Query packets.
When it receives a query for which it knows an answer, mDNSResponder
issues the appropriate Multicast DNS Reply packet.

mDNSResponder also performs Multicast DNS Queries on behalf of client
processes, and maintains a cache of the replies.

mDNSResponder has no user-specifiable command-line argument, and users
should not run mDNSResponder manually.

To examine mDNSResponder’s internal state, for debugging and disagnostic
purposes, send it a SIGINFO signal, and it will then dump a snapshot sum-
mary of its internal state to /var/log/system.log, e.g.

sudo killall -INFO mDNSResponder





For information on Multicast DNS, see http://www.multicastdns.org/
For information on DNS Service Discovery, see http://www.dns-sd.org/
For information on how to use the Multicast DNS and the DNS Service Dis-
covery APIs on Mac OS X and other platforms, see
For the source code to mDNSResponder, see


mDNSResponder bugs are tracked in Apple Radar component « mDNSResponder ».


The mDNSResponder daemon first appeared in Mac OS X 10.2 (Jaguar).

Also available from the Darwin open source repository (though not offi-
cially supported by Apple) are mDNSResponder daemons for other platforms,
including Mac OS 9, Microsoft Windows, Linux, FreeBSD, NetBSD, Solaris,
and other POSIX systems.


Rbcafe » Unix



MD2, MD4, MD5, MD2_Init, MD2_Update, MD2_Final, MD4_Init, MD4_Update,
MD4_Final, MD5_Init, MD5_Update, MD5_Final – MD2, MD4, and MD5 hash


#include (openssl/md2.h)

unsigned char *MD2(const unsigned char *d, unsigned long n,
unsigned char *md);

void MD2_Init(MD2_CTX *c);
void MD2_Update(MD2_CTX *c, const unsigned char *data,
unsigned long len);
void MD2_Final(unsigned char *md, MD2_CTX *c);

#include (openssl/md4.h)

unsigned char *MD4(const unsigned char *d, unsigned long n,
unsigned char *md);

void MD4_Init(MD4_CTX *c);
void MD4_Update(MD4_CTX *c, const void *data,
unsigned long len);
void MD4_Final(unsigned char *md, MD4_CTX *c);

#include (openssl/md5.h)

unsigned char *MD5(const unsigned char *d, unsigned long n,
unsigned char *md);

void MD5_Init(MD5_CTX *c);
void MD5_Update(MD5_CTX *c, const void *data,
unsigned long len);
void MD5_Final(unsigned char *md, MD5_CTX *c);


MD2, MD4, and MD5 are cryptographic hash functions with a 128 bit out-

MD2(), MD4(), and MD5() compute the MD2, MD4, and MD5 message digest of
the n bytes at d and place it in md (which must have space for
of output). If md is NULL, the digest is placed in a static array.

The following functions may be used if the message is not completely
stored in memory:

MD2_Init() initializes a MD2_CTX structure.

MD2_Update() can be called repeatedly with chunks of the message to be
hashed (len bytes at data).

MD2_Final() places the message digest in md, which must have space for
MD2_DIGEST_LENGTH == 16 bytes of output, and erases the MD2_CTX.

MD4_Init(), MD4_Update(), MD4_Final(), MD5_Init(), MD5_Update(), and
MD5_Final() are analogous using an MD4_CTX and MD5_CTX structure.

Applications should use the higher level functions EVP_DigestInit(3)
etc. instead of calling the hash functions directly.


MD2, MD4, and MD5 are recommended only for compatibility with existing
applications. In new applications, SHA-1 or RIPEMD-160 should be pre-


MD2(), MD4(), and MD5() return pointers to the hash value.

MD2_Init(), MD2_Update(), MD2_Final(), MD4_Init(), MD4_Update(),
MD4_Final(), MD5_Init(), MD5_Update(), and MD5_Final() do not return


RFC 1319, RFC 1320, RFC 1321


Rbcafe » Unix



whois – Internet domain name and network number directory service


whois [-adgprR] [-h host] name …


Whois looks up records in the databases maintained by several Network In-
formation Centers (NICs).

The options are as follows:

-a Use the American Registry for Internet Numbers (ARIN) database.
It contains network numbers used in those parts of the world cov-
ered neither by APNIC nor by RIPE.

-d Use the US Department of Defense database. It contains points of
contact for subdomains of .MIL.

-g Use the US non-military federal government database, which con-
tains points of contact for subdomains of .GOV.

-h host
Use the specified host instead of the default NIC (whois.inter-
nic.net). Either a host name or an IP address may be specified.

-p Use the Asia/Pacific Network Information Center (APNIC) database.
It contains network numbers used in East Asia, Australia, New
Zealand, and the Pacific islands.

-r Use the R’eseaux IP Europ’eens (RIPE) database. It contains net-
work numbers and domain contact information for Europe.

-R Use the Russia Network Information Center (RIPN) database. It
contains network numbers and domain contact information for sub-
domains of .RU.

The operands specified to whois are concatenated together (separated by
white-space) and presented to the whois server.

The default action, unless directed otherwise with a special name, is to
do a very broad search, looking for matches to name in all types of
records and most fields (name, nicknames, hostname, net address, etc.) in
the database. For more information as to what name operands have special
meaning, and how to guide the search, use the special name « help ».


Ken Harrenstien, and Vic White, NICNAME/WHOIS, 1 March 1982, RFC 812.


The whois command appeared in 4.3BSD.


Rbcafe » Unix



xinetd – the extended Internet services daemon


xinetd [options]


xinetd performs the same function as inetd: it starts programs that
provide Internet services. Instead of having such servers started at
system initialization time, and be dormant until a connection request
arrives, xinetd is the only daemon process started and it listens on
all service ports for the services listed in its configuration file.
When a request comes in, xinetd starts the appropriate server. Because
of the way it operates, xinetd (as well as inetd) is also referred to
as a super-server.

The services listed in xinetd’s configuration file can be separated
into two groups. Services in the first group are called multi-threaded
and they require the forking of a new server process for each new con-
nection request. The new server then handles that connection. For
such services, xinetd keeps listening for new requests so that it can
spawn new servers. On the other hand, the second group includes ser-
vices for which the service daemon is responsible for handling all new
connection requests. Such services are called single-threaded and
xinetd will stop handling new requests for them until the server dies.
Services in this group are usually datagram-based.

So far, the only reason for the existence of a super-server was to con-
serve system resources by avoiding to fork a lot of processes which
might be dormant for most of their lifetime. While fulfilling this
function, xinetd takes advantage of the idea of a super-server to pro-
vide features such as access control and logging. Furthermore, xinetd
is not limited to services listed in /etc/services. Therefore, anybody
can use xinetd to start special-purpose servers.


-d Enables debug mode. This produces a lot of debugging output, and
it makes it possible to use a debugger on xinetd.

-syslog syslog_facility
This option enables syslog logging of xinetd-produced messages
using the specified syslog facility. The following facility
names are supported: daemon, auth, user, local[0-7] (check sys-
log.conf(5) for their meanings). This option is ineffective in
debug mode since all relevant messages are sent to the terminal.

-filelog logfile
xinetd-produced messages will be placed in the specified file.
Messages are always appended to the file. If the file does not
exist, it will be created. This option is ineffective in debug
mode since all relevant messages are sent to the terminal.

-f config_file
Determines the file that xinetd uses for configuration. The
default is /etc/xinetd.conf.

-pidfile pid_file
The process ID is written to the file. This option is ineffec-
tive in debug mode.

Tells xinetd to stay in the foreground rather than detaching
itself, to support being run from init or daemontools. This
option automatically sets -stayalive (see below).

Tells xinetd to stay running even if no services are specified.

-limit proc_limit
This option places a limit on the number of concurrently running
processes that can be started by xinetd. Its purpose is to pre-
vent process table overflows.

-logprocs limit
This option places a limit on the number of concurrently running
servers for remote userid acquisition.

This option causes xinetd to print out its version information.

This option causes xinetd to read /etc/inetd.conf in addition to
the standard xinetd config files. /etc/inetd.conf is read after
the standard xinetd config files.

-cc interval
This option instructs xinetd to perform periodic consistency
checks on its internal state every interval seconds.

The syslog and filelog options are mutually exclusive. If none is
specified, the default is syslog using the daemon facility. You should
not confuse xinetd messages with messages related to service logging.
The latter are logged only if this is specified via the configuration


xinetd performs certain actions when it receives certain signals. The
actions associated with the specific signals can be redefined by edit-
ing config.h and recompiling.

SIGHUP causes a hard reconfiguration, which means that xinetd
re-reads the configuration file and terminates the
servers for services that are no longer available.
Access control is performed again on running servers by
checking the remote location, access times and server
instances. If the number of server instances is lowered,
some arbitrarily picked servers will be killed to sat-
isfy the limit; this will happen after any servers are
terminated because of failing the remote location or
access time checks. Also, if the INTERCEPT flag was
clear and is set, any running servers for that service
will be terminated; the purpose of this is to ensure
that after a hard reconfiguration there will be no run-
ning servers that can accept packets from addresses that
do not meet the access control criteria.

SIGQUIT causes program termination.

SIGTERM terminates all running servers before terminating

SIGUSR1 causes an internal state dump (the default dump file is
/var/run/xinetd.dump; to change the filename, edit con-
fig.h and recompile).

SIGIOT causes an internal consistency check to verify that the
data structures used by the program have not been cor-
rupted. When the check is completed xinetd will gener-
ate a message that says if the check was successful or

On reconfiguration the log files are closed and reopened. This allows
removal of old log files.


/etc/xinetd.conf default configuration file
/var/run/xinetd.dump default dump file




Panos Tsirigotis, CS Dept, University of Colorado, Boulder Rob Braun




Rbcafe » Unix



zlib – compression/decompression library


[see zlib.h for full description]


The zlib library is a general purpose data compression
library. The code is thread safe. It provides in-memory
compression and decompression functions, including
integrity checks of the uncompressed data. This version
of the library supports only one compression method
(deflation) but other algorithms will be added later and
will have the same stream interface.

Compression can be done in a single step if the buffers
are large enough (for example if an input file is
mmap’ed), or can be done by repeated calls of the compres-
sion function. In the latter case, the application must
provide more input and/or consume the output (providing
more output space) before each call.

The library also supports reading and writing files in
gzip (.gz) format with an interface similar to that of

The library does not install any signal handler. The
decoder checks the consistency of the compressed data, so
the library should never crash even in case of corrupted

All functions of the compression library are documented in
the file zlib.h. The distribution source includes exam-
ples of use of the library the files example.c and

A Java implementation of zlib is available in the Java
Development Kit 1.1


A Perl interface to zlib, written by Paul Marquess (pmar-
quess@bfsec.bt.co.uk) is available at CPAN (Comprehensive
Perl Archive Network) sites, such as:


A Python interface to zlib written by A.M. Kuchling
is available from the Python Software
Association sites, such as:



Questions about zlib should be sent to:

zlib@quest.jpl.nasa.gov or, if this fails, to the
author addresses given below. The zlib home page

The data format used by the zlib library is described by
RFC (Request for Comments) 1950 to 1952 in the files:

ftp://ds.internic.net/rfc/rfc1950.txt (zlib format)
rfc1951.txt (deflate format)
rfc1952.txt (gzip format)

These documents are also available in other formats from:



Version 1.1.3 Copyright (C) 1995-1998 Jean-loup Gailly
(jloup@gzip.org) and Mark Adler (madler@alumni.cal-

This software is provided « as-is, » without any express or
implied warranty. In no event will the authors be held
liable for any damages arising from the use of this soft-
ware. See the distribution directory with respect to
requirements governing redistribution. The deflate format
used by zlib was defined by Phil Katz. The deflate and
zlib specifications were written by L. Peter Deutsch.
Thanks to all the people who reported problems and sug-
gested various improvements in zlib; who are too numerous
to cite here.

UNIX manual page by R. P. C. Rodgers, U.S. National
Library of Medicine (rodgers@nlm.nih.gov).


Rbcafe » Unix



HMAC, HMAC_Init, HMAC_Update, HMAC_Final, HMAC_cleanup – HMAC message
authentication code


#include (openssl/hmac.h)

unsigned char *HMAC(const EVP_MD *evp_md, const void *key,
int key_len, const unsigned char *d, int n,
unsigned char *md, unsigned int *md_len);

void HMAC_CTX_init(HMAC_CTX *ctx);

void HMAC_Init(HMAC_CTX *ctx, const void *key, int key_len,
const EVP_MD *md);
void HMAC_Init_ex(HMAC_CTX *ctx, const void *key, int key_len,
const EVP_MD *md);
void HMAC_Update(HMAC_CTX *ctx, const unsigned char *data, int len);
void HMAC_Final(HMAC_CTX *ctx, unsigned char *md, unsigned int *len);

void HMAC_CTX_cleanup(HMAC_CTX *ctx);
void HMAC_cleanup(HMAC_CTX *ctx);


HMAC is a MAC (message authentication code), i.e. a keyed hash function
used for message authentication, which is based on a hash function.

HMAC() computes the message authentication code of the n bytes at d
using the hash function evp_md and the key key which is key_len bytes

It places the result in md (which must have space for the output of the
hash function, which is no more than EVP_MAX_MD_SIZE bytes). If md is
NULL, the digest is placed in a static array. The size of the output
is placed in md_len, unless it is NULL.

evp_md can be EVP_sha1(), EVP_ripemd160() etc. key and evp_md may be
NULL if a key and hash function have been set in a previous call to
HMAC_Init() for that HMAC_CTX.

HMAC_CTX_init() initialises a HMAC_CTX before first use. It must be

HMAC_CTX_cleanup() erases the key and other data from the HMAC_CTX and
releases any associated resources. It must be called when an HMAC_CTX
is no longer required.

HMAC_cleanup() is an alias for HMAC_CTX_cleanup() included for back
compatibility with 0.9.6b, it is deprecated.

The following functions may be used if the message is not completely
stored in memory:

HMAC_Init() initializes a HMAC_CTX structure to use the hash function
evp_md and the key key which is key_len bytes long. It is deprecated
and only included for backward compatibility with OpenSSL 0.9.6b.

HMAC_Init_ex() initializes or reuses a HMAC_CTX structure to use the
function evp_md and key key. Either can be NULL, in which case the
existing one will be reused. HMAC_CTX_init() must have been called
before the first use of an HMAC_CTX in this function. N.B. HHMMAACC_IInniitt(())
had this undocumented behaviour in previous versions of OpenSSL – fail-
ure to switch to HHMMAACC_IInniitt_eexx(()) in programs that expect it will cause
them to stop working.

HMAC_Update() can be called repeatedly with chunks of the message to be
authenticated (len bytes at data).

HMAC_Final() places the message authentication code in md, which must
have space for the hash function output.


HMAC() returns a pointer to the message authentication code.
HMAC_CTX_init(), HMAC_Init_ex(), HMAC_Update(), HMAC_Final() and
HMAC_CTX_cleanup() do not return values.


Rbcafe » Unix



fdisk – Partition table manipulator for Linux


fdisk [-u] [device]
fdisk -l [-u] [device …]
fdisk -s partition …
fdisk -v


Hard disks can be divided into one or more logical disks
called partitions. This division is described in the par-
tition table found in sector 0 of the disk.

In the BSD world one talks about `disk slices’ and a

Linux needs at least one partition, namely for its root
file system. It can use swap files and/or swap parti-
tions, but the latter are more efficient. So, usually one
will want a second Linux partition dedicated as swap par-
tition. On Intel compatible hardware, the BIOS that boots
the system can often only access the first 1024 cylinders
of the disk. For this reason people with large disks
often create a third partition, just a few MB large, typi-
cally mounted on /boot, to store the kernel image and a
few auxiliary files needed at boot time, so as to make
sure that this stuff is accessible to the BIOS. There may
be reasons of security, ease of administration and backup,
or testing, to use more than the minimum number of parti-

fdisk (in the first form of invocation) is a menu driven
program for creation and manipulation of partition tables.
It understands DOS type partition tables and BSD or SUN
type disklabels.

The device is usually one of the following:


(/dev/hd[a-h] for IDE disks, /dev/sd[a-p] for SCSI disks,
/dev/ed[a-d] for ESDI disks, /dev/xd[ab] for XT disks). A
device name refers to the entire disk.

The partition is a device name followed by a partition
number. For example, /dev/hda1 is the first partition on
the first IDE hard disk in the system. IDE disks can have
up to 63 partitions, SCSI disks up to 15. See also

A BSD/SUN type disklabel can describe 8 partitions, the
third of which should be a `whole disk’ partition. Do not
start a partition that actually uses its first sector
(like a swap partition) at cylinder 0, since that will
destroy the disklabel.

An IRIX/SGI type disklabel can describe 16 partitions, the
eleventh of which should be an entire `volume’ partition,
while the ninth should be labeled `volume header’. The
volume header will also cover the partition table, i.e.,
it starts at block zero and extends by default over five
cylinders. The remaining space in the volume header may
be used by header directory entries. No partitions may
overlap with the volume header. Also do not change its
type and make some file system on it, since you will lose
the partition table. Use this type of label only when
working with Linux on IRIX/SGI machines or IRIX/SGI disks
under Linux.

A DOS type partition table can describe an unlimited num-
ber of partitions. In sector 0 there is room for the
description of 4 partitions (called `primary’). One of
these may be an extended partition; this is a box holding
logical partitions, with descriptors found in a linked
list of sectors, each preceding the corresponding logical
partitions. The four primary partitions, present or not,
get numbers 1-4. Logical partitions start numbering from

In a DOS type partition table the starting offset and the
size of each partition is stored in two ways: as an abso-
lute number of sectors (given in 32 bits) and as a Cylin-
ders/Heads/Sectors triple (given in 10+8+6 bits). The for-
mer is OK – with 512-byte sectors this will work up to 2
TB. The latter has two different problems. First of all,
these C/H/S fields can be filled only when the number of
heads and the number of sectors per track are known. Sec-
ondly, even if we know what these numbers should be, the
24 bits that are available do not suffice. DOS uses C/H/S
only, Windows uses both, Linux never uses C/H/S.

If possible, fdisk will obtain the disk geometry automati-
cally. This is not necessarily the physical disk geometry
(indeed, modern disks do not really have anything like a
physical geometry, certainly not something that can be
described in simplistic Cylinders/Heads/Sectors form), but
is the disk geometry that MS-DOS uses for the partition

Usually all goes well by default, and there are no prob-
lems if Linux is the only system on the disk. However, if
the disk has to be shared with other operating systems, it
is often a good idea to let an fdisk from another operat-
ing system make at least one partition. When Linux boots
it looks at the partition table, and tries to deduce what
(fake) geometry is required for good cooperation with
other systems.

Whenever a partition table is printed out, a consistency
check is performed on the partition table entries. This
check verifies that the physical and logical start and end
points are identical, and that the partition starts and
ends on a cylinder boundary (except for the first parti-

Some versions of MS-DOS create a first partition which
does not begin on a cylinder boundary, but on sector 2 of
the first cylinder. Partitions beginning in cylinder 1
cannot begin on a cylinder boundary, but this is unlikely
to cause difficulty unless you have OS/2 on your machine.

A sync() and a BLKRRPART ioctl() (reread partition table
from disk) are performed before exiting when the partition
table has been updated. Long ago it used to be necessary
to reboot after the use of fdisk. I do not think this is
the case anymore – indeed, rebooting too quickly might
cause loss of not-yet-written data. Note that both the
kernel and the disk hardware may buffer data.


The DOS 6.x FORMAT command looks for some information in
the first sector of the data area of the partition, and
treats this information as more reliable than the informa-
tion in the partition table. DOS FORMAT expects DOS FDISK
to clear the first 512 bytes of the data area of a parti-
tion whenever a size change occurs. DOS FORMAT will look
at this extra information even if the /U flag is given —
we consider this a bug in DOS FORMAT and DOS FDISK.

The bottom line is that if you use cfdisk or fdisk to
change the size of a DOS partition table entry, then you
must also use dd to zero the first 512 bytes of that par-
tition before using DOS FORMAT to format the partition.
For example, if you were using cfdisk to make a DOS parti-
tion table entry for /dev/hda1, then (after exiting fdisk
or cfdisk and rebooting Linux so that the partition table
information is valid) you would use the command « dd
if=/dev/zero of=/dev/hda1 bs=512 count=1 » to zero the
first 512 bytes of the partition.

BE EXTREMELY CAREFUL if you use the dd command, since a
small typo can make all of the data on your disk useless.

For best results, you should always use an OS-specific
partition table program. For example, you should make DOS
partitions with the DOS FDISK program and Linux partitions
with the Linux fdisk or Linux cfdisk program.


-v Print version number of fdisk program and exit.

-l List the partition tables for /dev/hd[a-d],
/dev/sd[a-h], /dev/ed[a-d], and then exit.

-u When listing partition tables, give sizes in sec-
tors instead of cylinders.

-s partition
The size of the partition (in blocks) is printed on
the standard output. This value is normally used
as an argument to the mkfs(8) program to specify
the size of the partition which will be formatted.
(Older versions of fdisk would do this only if the
partition id is greater than 10, in an attempt to
refuse DOS partitions; this test has been deleted.)
Note that sfdisk -s gives different (namely, cor-
rect) answers. Reasons for the difference are that
the kernel and fdisk need not have the same idea
about partition numbering (e.g., in case you have
BSD slices), and have different ideas about the
size of an extended partition.


There are several *fdisk programs around. Each has its
problems and strengths. Try them in the order cfdisk,
fdisk, sfdisk.

The IRIX/SGI type disklabel is currently not supported by
the kernel. Moreover, IRIX/SGI header directories are not
fully supported yet.

The option `dump partition table to file’ is missing.


Rbcafe » Unix

EVP digest


EVP_MD_CTX_init, EVP_MD_CTX_create, EVP_DigestInit_ex, EVP_DigestUp-
date, EVP_DigestFinal_ex, EVP_MD_CTX_cleanup, EVP_MD_CTX_destroy,
EVP_MD_pkey_type, EVP_MD_size, EVP_MD_block_size, EVP_MD_CTX_md,
EVP_MD_CTX_size, EVP_MD_CTX_block_size, EVP_MD_CTX_type, EVP_md_null,
EVP_md2, EVP_md5, EVP_sha, EVP_sha1, EVP_dss, EVP_dss1, EVP_mdc2,
EVP_ripemd160, EVP_get_digestbyname, EVP_get_digestbynid,
EVP_get_digestbyobj – EVP digest routines


#include (openssl/evp.h)

void EVP_MD_CTX_init(EVP_MD_CTX *ctx);
EVP_MD_CTX *EVP_MD_CTX_create(void);

int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl);
int EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *d, unsigned int cnt);
int EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md,
unsigned int *s);

int EVP_MD_CTX_cleanup(EVP_MD_CTX *ctx);
void EVP_MD_CTX_destroy(EVP_MD_CTX *ctx);

int EVP_MD_CTX_copy_ex(EVP_MD_CTX *out,const EVP_MD_CTX *in);

int EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type);
int EVP_DigestFinal(EVP_MD_CTX *ctx, unsigned char *md,
unsigned int *s);

int EVP_MD_CTX_copy(EVP_MD_CTX *out,EVP_MD_CTX *in);

#define EVP_MAX_MD_SIZE (16+20) /* The SSLv3 md5+sha1 type */

#define EVP_MD_type(e) ((e)->type)
#define EVP_MD_pkey_type(e) ((e)->pkey_type)
#define EVP_MD_size(e) ((e)->md_size)
#define EVP_MD_block_size(e) ((e)->block_size)

#define EVP_MD_CTX_md(e) (e)->digest)
#define EVP_MD_CTX_size(e) EVP_MD_size((e)->digest)
#define EVP_MD_CTX_block_size(e) EVP_MD_block_size((e)->digest)
#define EVP_MD_CTX_type(e) EVP_MD_type((e)->digest)

const EVP_MD *EVP_md_null(void);
const EVP_MD *EVP_md2(void);
const EVP_MD *EVP_md5(void);
const EVP_MD *EVP_sha(void);
const EVP_MD *EVP_sha1(void);
const EVP_MD *EVP_dss(void);
const EVP_MD *EVP_dss1(void);
const EVP_MD *EVP_mdc2(void);
const EVP_MD *EVP_ripemd160(void);

const EVP_MD *EVP_get_digestbyname(const char *name);
#define EVP_get_digestbynid(a) EVP_get_digestbyname(OBJ_nid2sn(a))
#define EVP_get_digestbyobj(a) EVP_get_digestbynid(OBJ_obj2nid(a))


The EVP digest routines are a high level interface to message digests.

EVP_MD_CTX_init() initializes digest contet ctx.

EVP_MD_CTX_create() allocates, initializes and returns a digest contet.

EVP_DigestInit_ex() sets up digest context ctx to use a digest type
from ENGINE impl. ctx must be initialized before calling this function.
type will typically be supplied by a functionsuch as EVP_sha1(). If
impl is NULL then the default implementation of digest type is used.

EVP_DigestUpdate() hashes cnt bytes of data at d into the digest con-
text ctx. This function can be called several times on the same ctx to
hash additional data.

EVP_DigestFinal_ex() retrieves the digest value from ctx and places it
in md. If the s parameter is not NULL then the number of bytes of data
written (i.e. the length of the digest) will be written to the integer
at s, at most EVP_MAX_MD_SIZE bytes will be written. After calling
EVP_DigestFinal_ex() no additional calls to EVP_DigestUpdate() can be
made, but EVP_DigestInit_ex() can be called to initialize a new digest

EVP_MD_CTX_cleanup() cleans up digest context ctx, it should be called
after a digest context is no longer needed.

EVP_MD_CTX_destroy() cleans up digest context ctx and frees up the
space allocated to it, it should be called only on a context created
using EVP_MD_CTX_create().

EVP_MD_CTX_copy_ex() can be used to copy the message digest state from
in to out. This is useful if large amounts of data are to be hashed
which only differ in the last few bytes. out must be initialized before
calling this function.

EVP_DigestInit() behaves in the same way as EVP_DigestInit_ex() except
the passed context ctx does not have to be initialized, and it always
uses the default digest implementation.

EVP_DigestFinal() is similar to EVP_DigestFinal_ex() except the digest
contet ctx is automatically cleaned up.

EVP_MD_CTX_copy() is similar to EVP_MD_CTX_copy_ex() except the desti-
nation out does not have to be initialized.

EVP_MD_size() and EVP_MD_CTX_size() return the size of the message
digest when passed an EVP_MD or an EVP_MD_CTX structure, i.e. the size
of the hash.

EVP_MD_block_size() and EVP_MD_CTX_block_size() return the block size
of the message digest when passed an EVP_MD or an EVP_MD_CTX structure.

EVP_MD_type() and EVP_MD_CTX_type() return the NID of the OBJECT IDEN-
TIFIER representing the given message digest when passed an EVP_MD
structure. For example EVP_MD_type(EVP_sha1()) returns NID_sha1. This
function is normally used when setting ASN1 OIDs.

EVP_MD_CTX_md() returns the EVP_MD structure corresponding to the
passed EVP_MD_CTX.

EVP_MD_pkey_type() returns the NID of the public key signing algorithm
associated with this digest. For example EVP_sha1() is associated with
RSA so this will return NID_sha1WithRSAEncryption. This « link » between
digests and signature algorithms may not be retained in future versions
of OpenSSL.

EVP_md2(), EVP_md5(), EVP_sha(), EVP_sha1(), EVP_mdc2() and
EVP_ripemd160() return EVP_MD structures for the MD2, MD5, SHA, SHA1,
MDC2 and RIPEMD160 digest algorithms respectively. The associated sig-
nature algorithm is RSA in each case.

EVP_dss() and EVP_dss1() return EVP_MD structures for SHA and SHA1
digest algorithms but using DSS (DSA) for the signature algorithm.

EVP_md_null() is a « null » message digest that does nothing: i.e. the
hash it returns is of zero length.

EVP_get_digestbyname(), EVP_get_digestbynid() and EVP_get_digestbyobj()
return an EVP_MD structure when passed a digest name, a digest NID or
an ASN1_OBJECT structure respectively. The digest table must be ini-
tialized using, for example, OpenSSL_add_all_digests() for these func-
tions to work.


EVP_DigestInit_ex(), EVP_DigestUpdate() and EVP_DigestFinal_ex() return
1 for success and 0 for failure.

EVP_MD_CTX_copy_ex() returns 1 if successful or 0 for failure.

EVP_MD_type(), EVP_MD_pkey_type() and EVP_MD_type() return the NID of
the corresponding OBJECT IDENTIFIER or NID_undef if none exists.

EVP_MD_size(), EVP_MD_block_size(), EVP_MD_CTX_size(e), EVP_MD_size(),
EVP_MD_CTX_block_size() and EVP_MD_block_size() return the digest or
block size in bytes.

EVP_md_null(), EVP_md2(), EVP_md5(), EVP_sha(), EVP_sha1(), EVP_dss(),
EVP_dss1(), EVP_mdc2() and EVP_ripemd160() return pointers to the cor-
responding EVP_MD structures.

EVP_get_digestbyname(), EVP_get_digestbynid() and EVP_get_digestbyobj()
return either an EVP_MD structure or NULL if an error occurs.


The EVP interface to message digests should almost always be used in
preference to the low level interfaces. This is because the code then
becomes transparent to the digest used and much more flexible.

SHA1 is the digest of choice for new applications. The other digest
algorithms are still in common use.

For most applications the impl parameter to EVP_DigestInit_ex() will be
set to NULL to use the default digest implementation.

The functions EVP_DigestInit(), EVP_DigestFinal() and EVP_MD_CTX_copy()
are obsolete but are retained to maintain compatibility with existing
code. New applications should use EVP_DigestInit_ex(), EVP_DigestFi-
nal_ex() and EVP_MD_CTX_copy_ex() because they can efficiently reuse a
digest context instead of initializing and cleaning it up on each call
and allow non default implementations of digests to be specified.

In OpenSSL 0.9.7 and later if digest contexts are not cleaned up after
use memory leaks will occur.


This example digests the data « Test Message\n » and « Hello World\n »,
using the digest name passed on the command line.

#include (stdio .h)
#include (openssl/evp.h)

main(int argc, char *argv[])
EVP_MD_CTX mdctx;
const EVP_MD *md;
char mess1[] = « Test Message\n »;
char mess2[] = « Hello World\n »;
unsigned char md_value[EVP_MAX_MD_SIZE];
int md_len, i;


if(!argv[1]) {
printf(« Usage: mdtest digestname\n »);

md = EVP_get_digestbyname(argv[1]);

if(!md) {
printf(« Unknown message digest %s\n », argv[1]);

EVP_DigestInit_ex(&mdctx, md, NULL);
EVP_DigestUpdate(&mdctx, mess1, strlen(mess1));
EVP_DigestUpdate(&mdctx, mess2, strlen(mess2));
EVP_DigestFinal_ex(&mdctx, md_value, &md_len);

printf(« Digest is: « );
for(i = 0; i < md_len; i++) printf("%02x", md_value[i]); printf("\n"); } BUGS The link between digests and signing algorithms results in a situation where EVP_sha1() must be used with RSA and EVP_dss1() must be used with DSS even though they are identical digests. EOF

Page 2 sur 41234
Rbcafe © 2004- | Rb Cafe 1.3 | Contacter Rbcafe | Rbcafe sur Twitter | Rbcafe sur Facebook | Politique de confidentialité