Cryptography (or cryptology; from Greek κρυπτός kryptós, „hidden, secret“; and γράφειν graphein, „writing“, or -λογία -logia, „study“, respectively) is the practice and study of techniques for secure communication in the presence of third parties (called adversaries). More generally, it is about constructing and analyzing protocols that block adversaries; various aspects in information security such as data confidentiality, data integrity, authentication, and non-repudiation are central to modern cryptography. Modern cryptography exists at the intersection of the disciplines of mathematics, computer science, and electrical engineering. Applications of cryptography include ATM cards, computer passwords, and electronic commerce.

Rbcafe » Cryptography


Wassenaar Arrangement / COCOM

1. Export/ import controls


COCOM (Coordinating Committee for Multilateral Export Controls) was an international organization for the mutual control of the export of strategic products and technical data from country members to proscribed destinations. It maintained, among others, the International Industrial List and the International Munitions List. In 1991, COCOM decided to allow export of mass-market cryptographic software (including public domain software). Most member countries of COCOM followed its regulations, but the United States maintained separate regulations.

Its 17 members were Australia, Belgium, Canada, Denmark, France, Germany, Greece, Italy, Japan, Luxemburg, The Netherlands, Norway, Portugal, Spain, Turkey, United Kingdom, and the United States. Cooperating members included Austria, Finland, Hungary, Ireland, New Zealand, Poland, Singapore, Slovakia, South Korea, Sweden, Switzerland, and Taiwan.

The main goal of the COCOM regulations was to prevent cryptography from being exported to „dangerous“ countries – usually, the countries thought to maintain friendly ties with terrorist organizations, such as Libya, Iraq, Iran, and North Korea. Exporting to other countries is usually allowed, although states often require a license to be granted.

COCOM was dissolved in March 1994. Pending the signing of a new treaty, most members of COCOM agreed in principle to maintain the status quo, and cryptography remained on export control lists.
Wassenaar Arrangement

The Wassenaar Arrangement controls the export of weapons and of dual-use goods, that is, goods that can be used both for a military and for a civil purpose; cryptography is such a dual-use good.

In 1995, 28 countries decided to establish a follow-up to COCOM, the Wassenaar Arrangement on Export Controls for Conventional Arms and Dual-Use Goods and Technologies. The negotiations on the Arrangement were finished in July 1996, and the agreement was signed by 31 countries (Argentina, Australia, Austria, Belgium, Canada, the Czech Republic, Denmark, Finland, France, Germany, Greece, Hungary, Ireland, Italy, Japan, Luxembourg, the Netherlands, New Zealand, Norway, Poland, Portugal, the Republic of Korea, Romania, the Russian Federation, the Slovak Republic, Spain, Sweden, Switzerland, Turkey, the United Kingdom and the United States). Later, Bulgaria and Ukraine also became a participating state to the Arrangement.

The initial provisions were largely the same as old COCOM regulations. The General Software Note (applicable until the December 1998 revision) excepted mass-market and public-domain crypto software from the controls. Australia, France, New Zealand, Russia, and the US deviated from the GSN and controlled the export of mass-market and public-domain crypto software. Export via the Internet did not seem to be covered by the regulations.

There is a personal-use exemption, allowing export of products „accompanying their user for the user’s personal use“ (e.g., on a laptop).

In September 1998, Wassenaar negotiations in Vienna did not lead to changes in the crypto controls, although it was apparently considered to restrict the GSN (see an article in German) and possibly also to ease controls for key-recovery crypto. (Compare an article in Swedish of March 1998.)

The Wassenaar Arrangement was revised in December 1998. Negotiations were held on 2 and 3 December 1998 in Vienna, which resulted in restrictions on the General Software Note and in some relexations:

free for export are: all symmetric crypto products of up to 56 bits, all asymmetric crypto products of up to 512 bits, and all subgroup-based crypto products (including elliptic curve) of up to 112 bits;
mass-market symmetric crypto software and hardware of up to 64 bits are free for export (the 64-bit limit was deleted on 1 December 2000, see below);
the export of products that use encryption to protect intellectual property (such as DVDs) is relaxed;
export of all other crypto still requires a license.
There was no change in the provisions on public-domain crypto, so that all public-domain crypto software is still free for export. Nothing was said about electronic exports (e.g., via the Internet), which consequently remain unclear.

In its meeting of 30 November-1 December 2000, the Wassenaar states lifted the 64-bit limit for export controls on mass-market crypto software and hardware (in the Cryptography Note, clause d. (the 64-bit limit) was deleted in its reference to category 5A2, as well as the related Validity Note, see the summary). The public statement of the meeting mentioned that „Participating States recognised that it is important to continue deepening Wassenaar Arrangement understanding of how and how much to control“ intangible transfers.

The Wassenaar provisions are not directly applicable: each member state has to implement them in national legislation for them to have effect. (In the entries below, I have included mention of the pre-December 1998 regulations, which will stay into effect until the government enacts new legislation to implement the Wassenaar changes.)

See the Wassenaar List (crypto is in category 5 part 2). See further the Wassenaar Arrangement page (includes contact information for various national export control authorities), a Wassenaar FAQ (by US BIS), Greg Broiles‘ page on the Wassenaar Arrangement, which includes links to John Young’s pages on the Wassenaar Arrangement and comments on the December 1998 changes, and the GILC Wassenaar page. See also Chapter 3 of Simo-Pekka Parviainen’s thesis on Cryptographic Software Export Controls in the EU. Cf. an April 1996 article on the Wassenaar Arrangement.


Rbcafe » Cryptography


OECD (Organisation for Economic Co-operation and Development)

The OECD released its Recommendation of the Council concerning Guidelines for Cryptography Policy on 27 March 1997. The guidelines are non-binding recommendations to Member governments, meaning that they will not be part of international law. The Guidelines provide principles which states should take into account and balance in developing a national crypto policy.

The principles are:

1) Trust in cryptographic methods
2) Choice of cryptographic methods
3) Market driven development of cryptographic methods
4) Standards for cryptographic methods
5) Protection of privacy and personal data
6) Lawful access
7) Liability
8) International co-operation

The principles should be seen as „interdependent and should be implemented as a whole so as to balance the various interests at stake. No principle should be implemented in isolation from the rest.“

Some have welcomed the OECD principles as a victory for privacy over US-pushed key recovery, while others object to certain points as being too inflexible or too vague. Although the guidelines do not endorse key recovery, they do not prohibit it either. In fact, the guidelines are vague enough to allow a broad range of interpretation, and states will be able to choose a privacy-oriented or a law-enforcement-driven policy line as they see fit. While the guidelines recommend states to cooperate to coordinate their crypto policies, one may be skeptical about the chances of governments coming to an agreement; after all, within the OECD, states have not been able to agree, and they have left the task of finding a balance between, roughly speaking, information security/ privacy and law-enforcement/ national security to individual states.

The process of discussing and drafting policy guidelines started with an Ad-hoc Meeting of Experts on Cryptography Policy on 18-19 December 1995, organized by the OECD Committee for Information, Computer and Communications Policy (ICCP). They proposed to make a study upon current Member Countries encryption policies, market for encryption, key escrow encryption, and to develop a cryptography policy guideline based on the following principles, among others: provides security with confidence, voluntary use, international perspective, recognise national responsibilities, legally effective. The Group of Experts on Security, Privacy and Intellectual Property Protection in the Global Information Infrastructure held subsequent meetings on 7-8 February 1996 in Canberra, on 8 May 1996 in Washington, DC, on 26-28 June in Paris, and on 26-27 September 1996, again in Paris. At the June 1996 meeting, according to one report, no agreement was established; the OECD was said to be split into two parties, one with countries favouring mandatory key escrow (notably the US, UK, and France), and one with countries opposing this approach (mainly Japan and the Scandinavian countries). See a 1 October 1996 press release.

One can compare the final version to an earlier draft of the Guidelines that was discussed at the December 1996 meeting (with rather optimistic personal comments by Robin Whittle). (Text between [square brackets] remained to be decided upon.) In January 1997, the OECD Group of Experts on Security. Privacy, and Intellectual Property Protection in the GII concluded the guidelines. The Guidelines were finally turned into a Council of the OECD resolution in March 1997.


Rbcafe » Cryptography



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 » Cryptography

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

Rbcafe » Cryptography



evp – high-level cryptographic functions


#include (openssl/evp.h)


The EVP library provides a high-level interface to cryptographic func-

EVP_Seal… and EVP_Open… provide public key encryption and decryp-
tion to implement digital „envelopes“.

The EVP_Sign… and EVP_Verify… functions implement digital signa-

Symmetric encryption is available with the EVP_Encrypt… functions.
The EVP_Digest… functions provide message digests.

Algorithms are loaded with OpenSSL_add_all_algorithms(3).

All the symmetric algorithms (ciphers) and digests can be replaced by
ENGINE modules providing alternative implementations. If ENGINE imple-
mentations of ciphers or digests are registered as defaults, then the
various EVP functions will automatically use those implementations
automatically in preference to built in software implementations. For
more information, consult the engine(3) man page.


Rbcafe » Cryptography

Geschichte von Cryptext

Geschichte von Cryptext.


Version 1.0.0

– Initial release.

Version 1.0.1

– Addition of documentation.
– Correction of graphics.

Version 1.0.2

– Correction of the french documentation.

Version 1.0.3

– Correction of the documentation.
– Correction during mail sending.
– Code correction.

Version 1.0.4

– Addition of the printing.
– Addition of the Twitter link.
– Correction of the menubar.

Version 1.0.5

– Correction of the translations.
– Correction of the AES key.
– Correction of the logs.
– Code correction.

Version 1.0.6

– Correction of the save process.
– Correction of cryptography.
– Correction of width and height.
– Correction of code.

Version 1.0.7

– Correction of the minimum system requirement.

Version 1.0.8

– Correction of colors.
– Correction of compatibility.
– Correction of drag and drop.
– Correction of the localizations.
– Correction of the documentation.
– Addition of transparency.

Version 1.0.9

– Minimum system requirements required. (10.8)
– Addition of a comprehensive help.
– Addition of the „Keychains“ support for passwords and keys.
– Addition of „Block preferences“ to block preference in a state.
– Addition of a checkbox to disable check spelling.
– Addition of new Retina icons.
– Correction of the encryption / decryption.
– Correction of the „About“ Window.
– Correction of the help menu.
– Correction of the logs.
– Correction of the menubar.
– Correction of the translations.
– Correction of the toolbar.
– Correction of the code.

Updated: Donnerstag, 11UTCThu, 11 Aug 2016 12:39:48 +0000 11. August 2016 — 12:39

Rbcafe » Cryptography

Geschichte von Crypt

Geschichte von Crypt.


Version 1.0.0

– Initial release.

Version 1.0.1

– Addition of a Twitter link.
– Correction of code.

Version 1.0.2

– Addition of a keychain button for handling passwords.
– Correction of code.

Version 1.0.3

– The password can be 8 characters.
– Support of the Retina display.
– Support of the notification center.
– Code optimization.

Version 1.0.4

– Addition of Crypt cleaner. (Clean references, etc…)
– Addition of preferences.
– Addition of references. (List of references to files or encrypted files)
– Addition of a toolbar.
– Correction of the background.
– Correction of the interface.
– Correction of numerous bugs. (Thanks to critics)
– Correction of password storage.
– Correction of translations.

Updated: Donnerstag, 11UTCThu, 11 Aug 2016 12:36:04 +0000 11. August 2016 — 12:36
Seite 4 von 512345
Rbcafe © 2004- | Rb Cafe 1.3 | Kontakt Rbcafe | Rbcafe auf Twitter | Rbcafe auf Facebook | Datenschutz