<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE erlref SYSTEM "erlref.dtd">
<erlref>
<header>
<copyright>
<year>2008</year>
<year>2018</year>
<holder>Ericsson AB, All Rights Reserved</holder>
</copyright>
<legalnotice>
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
The Initial Developer of the Original Code is Ericsson AB.
</legalnotice>
<title>public_key</title>
<prepared>Ingela Anderton Andin</prepared>
<responsible></responsible>
<docno></docno>
<date></date>
<rev></rev>
</header>
<module>public_key</module>
<modulesummary>API module for public-key infrastructure.</modulesummary>
<description>
<p>Provides functions to handle public-key infrastructure,
for details see
<seealso marker="public_key_app">public_key(6)</seealso>.
</p>
</description>
<section>
<title>DATA TYPES</title>
<note><p>All records used in this Reference Manual
<!-- except #policy_tree_node{} -->
are generated from ASN.1 specifications
and are documented in the User's Guide. See <seealso
marker="public_key_records">Public-key Records</seealso>.
</p></note>
<p>Use the following include directive to get access to the
records and constant macros described here and in the User's Guide:</p>
<code> -include_lib("public_key/include/public_key.hrl").</code>
<p>The following data types are used in the functions for <c>public_key</c>:</p>
<taglist>
<tag><c>oid()</c></tag>
<item><p>Object identifier, a tuple of integers as generated by the <c>ASN.1</c> compiler.</p></item>
<tag><c>boolean() =</c></tag>
<item><p><c>true | false</c></p></item>
<tag><c>string() =</c></tag>
<item><p><c>[bytes()]</c></p></item>
<tag><c>der_encoded() =</c></tag>
<item><p><c>binary()</c></p></item>
<tag><c>pki_asn1_type() =</c></tag>
<item>
<p><c>'Certificate'</c></p>
<p><c>| 'RSAPrivateKey'</c></p>
<p><c>| 'RSAPublicKey'</c></p>
<p><c>| 'DSAPrivateKey'</c></p>
<p><c>| 'DSAPublicKey'</c></p>
<p><c>| 'DHParameter'</c></p>
<p><c>| 'SubjectPublicKeyInfo'</c></p>
<p><c>| 'PrivateKeyInfo'</c></p>
<p><c>| 'CertificationRequest'</c></p>
<p><c>| 'CertificateList'</c></p>
<p><c>| 'ECPrivateKey'</c></p>
<p><c>| 'EcpkParameters'</c></p>
</item>
<tag><c>pem_entry () =</c></tag>
<item><p><c>{pki_asn1_type(), binary(), %% DER or encrypted DER</c></p>
<p><c> not_encrypted | cipher_info()}</c></p></item>
<tag><c>cipher_info() = </c></tag>
<item><p><c>{"RC2-CBC" | "DES-CBC" | "DES-EDE3-CBC", crypto:strong_rand_bytes(8)</c></p>
<p><c>| {#'PBEParameter{}, digest_type()} | #'PBES2-params'{}}</c></p>
</item>
<tag><marker id="type-public_key"/>
<c>public_key() =</c></tag>
<item><p><c>rsa_public_key() | dsa_public_key() | ec_public_key()</c></p></item>
<tag><marker id="type-private_key"/>
<c>private_key() =</c></tag>
<item><p><c>rsa_private_key() | dsa_private_key() | ec_private_key()</c></p></item>
<tag><c>rsa_public_key() =</c></tag>
<item><p><c>#'RSAPublicKey'{}</c></p></item>
<tag><c>rsa_private_key() =</c></tag>
<item><p><c>#'RSAPrivateKey'{}</c></p></item>
<tag><c>dsa_public_key() =</c></tag>
<item><p><c>{integer(), #'Dss-Parms'{}}</c></p></item>
<tag><c>dsa_private_key() =</c></tag>
<item><p><c>#'DSAPrivateKey'{}</c></p></item>
<tag><c>ec_public_key()</c></tag>
<item><p>= <c>{#'ECPoint'{}, #'ECParameters'{} | {namedCurve, oid()}}</c></p></item>
<tag><c>ec_private_key() =</c></tag>
<item><p><c>#'ECPrivateKey'{}</c></p></item>
<tag><c>key_params() =</c></tag>
<item><p> #'DHParameter'{} | {namedCurve, oid()} | #'ECParameters'{}
| {rsa, Size::integer(), PubExp::integer()} </p></item>
<tag><c>public_crypt_options() =</c></tag>
<item><p><c>[{rsa_pad, rsa_padding()}]</c></p></item>
<tag><c>rsa_padding() =</c></tag>
<item>
<p><c>'rsa_pkcs1_padding'</c></p>
<p><c>| 'rsa_pkcs1_oaep_padding'</c></p>
<p><c>| 'rsa_no_padding'</c></p>
</item>
<tag><c>public_sign_options() =</c></tag>
<item><p><c>[{rsa_pad, rsa_sign_padding()} | {rsa_pss_saltlen, integer()}]</c></p></item>
<tag><c>rsa_sign_padding() =</c></tag>
<item>
<p><c>'rsa_pkcs1_padding'</c></p>
<p><c>| 'rsa_pkcs1_pss_padding'</c></p>
</item>
<tag><c>digest_type() = </c></tag>
<item><p>Union of <c>rsa_digest_type()</c>, <c>dss_digest_type()</c>,
and <c>ecdsa_digest_type()</c>.</p></item>
<tag><c>rsa_digest_type() = </c></tag>
<item><p><c>'md5' | 'ripemd160' | 'sha' | 'sha224' | 'sha256' | 'sha384' | 'sha512'</c></p></item>
<tag><c>dss_digest_type() = </c></tag>
<item><p><c>'sha' | 'sha224' | 'sha256' | 'sha384' | 'sha512'</c></p>
<p>Note that the actual supported dss_digest_type depends on the underlying crypto library.
In OpenSSL version >= 1.0.1 the listed digest are supported, while in 1.0.0 only
sha, sha224 and sha256 are supported. In version 0.9.8 only sha is supported.</p>
</item>
<tag><c>ecdsa_digest_type() = </c></tag>
<item><p><c>'sha' | 'sha224' | 'sha256' | 'sha384' | 'sha512'</c></p></item>
<tag><c>crl_reason() = </c></tag>
<item>
<p><c>unspecified</c></p>
<p><c>| keyCompromise</c></p>
<p><c>| cACompromise</c></p>
<p><c>| affiliationChanged</c></p>
<p><c>| superseded</c></p>
<p><c>| cessationOfOperation</c></p>
<p><c>| certificateHold</c></p>
<p><c>| privilegeWithdrawn</c></p>
<p><c>| aACompromise</c></p>
</item>
<tag><c>issuer_name() =</c></tag>
<item><p><c>{rdnSequence,[#'AttributeTypeAndValue'{}]}</c></p>
</item>
<tag><c>ssh_file() =</c></tag>
<item>
<p><c>openssh_public_key</c></p>
<p><c>| rfc4716_public_key</c></p>
<p><c>| known_hosts</c></p>
<p><c>| auth_keys</c></p>
</item>
</taglist>
<!-- <p><code>policy_tree() = [Root, Children]</code></p> -->
<!-- <p><code>Root = #policy_tree_node{}</code></p> -->
<!-- <p><code>Children = [] | policy_tree()</code></p> -->
<!-- <p>The <c>policy_tree_node</c> record has the following fields:</p> -->
<!-- <taglist> -->
<!-- <tag>valid_policy</tag> -->
<!-- <item>A single policy OID representing a -->
<!-- valid policy for the path of length x.</item> -->
<!-- <tag>qualifier_set</tag> -->
<!-- <item>A set of policy qualifiers associated -->
<!-- with the valid policy in certificate x.</item> -->
<!-- <tag>critically_indicator</tag> -->
<!-- <item>Indicates whether the -->
<!-- certificate policy extension in certificate x was marked as -->
<!-- critical.</item> -->
<!-- <tag>expected_policy_set</tag> -->
<!-- <item>Contains one or more policy OIDs -->
<!-- that would satisfy this policy in the certificate x+1.</item> -->
<!-- </taglist> -->
</section>
<funcs>
<func>
<name>compute_key(OthersKey, MyKey)-></name>
<name>compute_key(OthersKey, MyKey, Params)-></name>
<fsummary>Computes shared secret.</fsummary>
<type>
<v>OthersKey = #'ECPoint'{} | binary(), MyKey = #'ECPrivateKey'{} | binary()</v>
<v>Params = #'DHParameter'{}</v>
</type>
<desc>
<p>Computes shared secret.</p>
</desc>
</func>
<func>
<name>decrypt_private(CipherText, Key) -> binary()</name>
<name>decrypt_private(CipherText, Key, Options) -> binary()</name>
<fsummary>Public-key decryption.</fsummary>
<type>
<v>CipherText = binary()</v>
<v>Key = rsa_private_key()</v>
<v>Options = public_crypt_options()</v>
</type>
<desc>
<p>Public-key decryption using the private key. See also <seealso
marker="crypto:crypto#private_decrypt/4">crypto:private_decrypt/4</seealso></p>
</desc>
</func>
<func>
<name>decrypt_public(CipherText, Key) - > binary()</name>
<name>decrypt_public(CipherText, Key, Options) - > binary()</name>
<fsummary>Public-key decryption.</fsummary>
<type>
<v>CipherText = binary()</v>
<v>Key = rsa_public_key()</v>
<v>Options = public_crypt_options()</v>
</type>
<desc>
<p>Public-key decryption using the public key. See also <seealso
marker="crypto:crypto#public_decrypt/4">crypto:public_decrypt/4</seealso></p>
</desc>
</func>
<func>
<name>der_decode(Asn1type, Der) -> term()</name>
<fsummary>Decodes a public-key ASN.1 DER encoded entity.</fsummary>
<type>
<v>Asn1Type = atom()</v>
<d>ASN.1 type present in the Public Key applications
ASN.1 specifications.</d>
<v>Der = der_encoded()</v>
</type>
<desc>
<p>Decodes a public-key ASN.1 DER encoded entity.</p>
</desc>
</func>
<func>
<name>der_encode(Asn1Type, Entity) -> der_encoded()</name>
<fsummary>Encodes a public-key entity with ASN.1 DER encoding.</fsummary>
<type>
<v>Asn1Type = atom()</v>
<d>ASN.1 type present in the Public Key applications
ASN.1 specifications.</d>
<v>Entity = term()</v>
<d>Erlang representation of <c>Asn1Type</c></d>
</type>
<desc>
<p>Encodes a public-key entity with ASN.1 DER encoding.</p>
</desc>
</func>
<func>
<name>dh_gex_group(MinSize, SuggestedSize, MaxSize, Groups) -> {ok, {Size,Group}} | {error,Error}</name>
<fsummary>Selects a group for Diffie-Hellman key exchange</fsummary>
<type>
<v>MinSize = positive_integer()</v>
<v>SuggestedSize = positive_integer()</v>
<v>MaxSize = positive_integer()</v>
<v>Groups = undefined | [{Size,[{G,P}]}]</v>
<v>Size = positive_integer()</v>
<v>Group = {G,P}</v>
<v>G = positive_integer()</v>
<v>P = positive_integer()</v>
</type>
<desc>
<p>Selects a group for Diffie-Hellman key exchange with the key size in the range <c>MinSize...MaxSize</c>
and as close to <c>SuggestedSize</c> as possible. If <c>Groups == undefined</c> a default set will be
used, otherwise the group is selected from <c>Groups</c>.</p>
<p>First a size, as close as possible to SuggestedSize, is selected. Then one group with that key size
is randomly selected from the specified set of groups. If no size within the limits of <c>MinSize</c>
and <c>MaxSize</c> is available, <c>{error,no_group_found}</c> is returned.</p>
<p>The default set of groups is listed in <c>lib/public_key/priv/moduli</c>. This file may be regenerated like this:</p>
<pre>
$> cd $ERL_TOP/lib/public_key/priv/
$> generate
---- wait until all background jobs has finished. It may take several days !
$> cat moduli-* > moduli
$> cd ..; make
</pre>
</desc>
</func>
<func>
<name>encrypt_private(PlainText, Key) -> binary()</name>
<fsummary>Public-key encryption using the private key.</fsummary>
<type>
<v>PlainText = binary()</v>
<v>Key = rsa_private_key()</v>
</type>
<desc>
<p>Public-key encryption using the private key.
See also <seealso
marker="crypto:crypto#private_encrypt/4">crypto:private_encrypt/4</seealso>.</p>
</desc>
</func>
<func>
<name>encrypt_public(PlainText, Key) -> binary()</name>
<fsummary>Public-key encryption using the public key.</fsummary>
<type>
<v>PlainText = binary()</v>
<v>Key = rsa_public_key()</v>
</type>
<desc>
<p>Public-key encryption using the public key. See also <seealso
marker="crypto:crypto#public_encrypt/4">crypto:public_encrypt/4</seealso>.</p>
</desc>
</func>
<func>
<name>generate_key(Params) -> {Public::binary(), Private::binary()} | #'ECPrivateKey'{} | #'RSAPrivateKey'{}</name>
<fsummary>Generates a new keypair.</fsummary>
<type>
<v>Params = key_params()</v>
</type>
<desc>
<p>Generates a new keypair. Note that except for Diffie-Hellman
the public key is included in the private key structure. See also
<seealso marker="crypto:crypto#generate_key/2">crypto:generate_key/2</seealso>
</p>
</desc>
</func>
<func>
<name>pem_decode(PemBin) -> [pem_entry()]</name>
<fsummary>Decodes PEM binary data and returns
entries as ASN.1 DER encoded entities.</fsummary>
<type>
<v>PemBin = binary()</v>
<d>Example {ok, PemBin} = file:read_file("cert.pem").</d>
</type>
<desc>
<p>Decodes PEM binary data and returns
entries as ASN.1 DER encoded entities.</p>
</desc>
</func>
<func>
<name>pem_encode(PemEntries) -> binary()</name>
<fsummary>Creates a PEM binary.</fsummary>
<type>
<v> PemEntries = [pem_entry()] </v>
</type>
<desc>
<p>Creates a PEM binary.</p>
</desc>
</func>
<func>
<name>pem_entry_decode(PemEntry) -> term()</name>
<name>pem_entry_decode(PemEntry, Password) -> term()</name>
<fsummary>Decodes a PEM entry.</fsummary>
<type>
<v>PemEntry = pem_entry()</v>
<v>Password = string()</v>
</type>
<desc>
<p>Decodes a PEM entry. <c>pem_decode/1</c> returns a list of PEM
entries. Notice that if the PEM entry is of type
'SubjectPublickeyInfo', it is further decoded to an
<c>rsa_public_key()</c> or <c>dsa_public_key()</c>.</p>
</desc>
</func>
<func>
<name>pem_entry_encode(Asn1Type, Entity) -> pem_entry()</name>
<name>pem_entry_encode(Asn1Type, Entity, {CipherInfo, Password}) -> pem_entry()</name>
<fsummary>Creates a PEM entry that can be fed to <c>pem_encode/1</c>.</fsummary>
<type>
<v>Asn1Type = pki_asn1_type()</v>
<v>Entity = term()</v>
<d>Erlang representation of
<c>Asn1Type</c>. If <c>Asn1Type</c> is 'SubjectPublicKeyInfo',
<c>Entity</c> must be either an <c>rsa_public_key()</c>,
<c>dsa_public_key()</c> or an <c>ec_public_key()</c>
and this function creates the appropriate
'SubjectPublicKeyInfo' entry.
</d>
<v>CipherInfo = cipher_info()</v>
<v>Password = string()</v>
</type>
<desc>
<p>Creates a PEM entry that can be feed to <c>pem_encode/1</c>.</p>
</desc>
</func>
<func>
<name>pkix_decode_cert(Cert, otp|plain) -> #'Certificate'{} | #'OTPCertificate'{}</name>
<fsummary>Decodes an ASN.1 DER-encoded PKIX x509 certificate.</fsummary>
<type>
<v>Cert = der_encoded()</v>
</type>
<desc>
<p>Decodes an ASN.1 DER-encoded PKIX certificate. Option <c>otp</c>
uses the customized ASN.1 specification OTP-PKIX.asn1 for
decoding and also recursively decode most of the standard
parts.</p>
</desc>
</func>
<func>
<name>pkix_encode(Asn1Type, Entity, otp | plain) -> der_encoded()</name>
<fsummary>DER encodes a PKIX x509 certificate or part of such a
certificate.</fsummary>
<type>
<v>Asn1Type = atom()</v>
<d>The ASN.1 type can be 'Certificate', 'OTPCertificate' or a subtype of either.</d>
<v>Entity = #'Certificate'{} | #'OTPCertificate'{} | a valid subtype</v>
</type>
<desc>
<p>DER encodes a PKIX x509 certificate or part of such a
certificate. This function must be used for encoding certificates or parts of certificates
that are decoded/created in the <c>otp</c> format, whereas for the plain format this
function directly calls <c>der_encode/2</c>.</p>
</desc>
</func>
<func>
<name>pkix_is_issuer(Cert, IssuerCert) -> boolean()</name>
<fsummary>Checks if <c>IssuerCert</c> issued <c>Cert</c>.</fsummary>
<type>
<v>Cert = der_encoded() | #'OTPCertificate'{} | #'CertificateList'{}</v>
<v>IssuerCert = der_encoded() | #'OTPCertificate'{}</v>
</type>
<desc>
<p>Checks if <c>IssuerCert</c> issued <c>Cert</c>.</p>
</desc>
</func>
<func>
<name>pkix_is_fixed_dh_cert(Cert) -> boolean()</name>
<fsummary>Checks if a certificate is a fixed Diffie-Hellman certificate.</fsummary>
<type>
<v>Cert = der_encoded() | #'OTPCertificate'{}</v>
</type>
<desc>
<p>Checks if a certificate is a fixed Diffie-Hellman certificate.</p>
</desc>
</func>
<func>
<name>pkix_is_self_signed(Cert) -> boolean()</name>
<fsummary>Checks if a certificate is self-signed.</fsummary>
<type>
<v>Cert = der_encoded() | #'OTPCertificate'{}</v>
</type>
<desc>
<p>Checks if a certificate is self-signed.</p>
</desc>
</func>
<func>
<name>pkix_issuer_id(Cert, IssuedBy) -> {ok, IssuerID} | {error, Reason}</name>
<fsummary>Returns the issuer id.</fsummary>
<type>
<v>Cert = der_encoded() | #'OTPCertificate'{}</v>
<v>IssuedBy = self | other</v>
<v>IssuerID = {integer(), issuer_name()}</v>
<d>The issuer id consists of the serial number and the issuers name.</d>
<v>Reason = term()</v>
</type>
<desc>
<p>Returns the issuer id.</p>
</desc>
</func>
<func>
<name>pkix_normalize_name(Issuer) -> Normalized</name>
<fsummary>Normalizes an issuer name so that it can be easily
compared to another issuer name.</fsummary>
<type>
<v>Issuer = issuer_name()</v>
<v>Normalized = issuer_name()</v>
</type>
<desc>
<p>Normalizes an issuer name so that it can be easily
compared to another issuer name.</p>
</desc>
</func>
<func>
<name>pkix_path_validation(TrustedCert, CertChain, Options) -> {ok, {PublicKeyInfo, PolicyTree}} | {error, {bad_cert, Reason}} </name>
<fsummary>Performs a basic path validation according to RFC 5280.</fsummary>
<type>
<v>TrustedCert = #'OTPCertificate'{} | der_encoded() | atom()</v>
<d>Normally a trusted certificate, but it can also be a path-validation
error that can be discovered while
constructing the input to this function and that is to be run through the <c>verify_fun</c>.
Examples are <c>unknown_ca</c> and <c>selfsigned_peer.</c>
</d>
<v>CertChain = [der_encoded()]</v>
<d>A list of DER-encoded certificates in trust order ending with the peer certificate.</d>
<v>Options = proplists:proplist()</v>
<v>PublicKeyInfo = {?'rsaEncryption' | ?'id-dsa',
rsa_public_key() | integer(), 'NULL' | 'Dss-Parms'{}}</v>
<v>PolicyTree = term()</v>
<d>At the moment this is always an empty list as policies are not currently supported.</d>
<v>Reason = cert_expired | invalid_issuer | invalid_signature | name_not_permitted |
missing_basic_constraint | invalid_key_usage | {revoked, crl_reason()} | atom()
</v>
</type>
<desc>
<p>
Performs a basic path validation according to
<url href="http://www.ietf.org/rfc/rfc5280.txt">RFC 5280.</url>
However, CRL validation is done separately by <seealso
marker="#pkix_crls_validate-3">pkix_crls_validate/3 </seealso> and is to be called
from the supplied <c>verify_fun</c>.
</p>
<p>Available options:</p>
<taglist>
<tag>{verify_fun, fun()}</tag>
<item>
<p>The fun must be defined as:</p>
<code>
fun(OtpCert :: #'OTPCertificate'{},
Event :: {bad_cert, Reason :: atom() | {revoked, atom()}} |
{extension, #'Extension'{}},
InitialUserState :: term()) ->
{valid, UserState :: term()} |
{valid_peer, UserState :: term()} |
{fail, Reason :: term()} |
{unknown, UserState :: term()}.
</code>
<p>If the verify callback fun returns <c>{fail, Reason}</c>, the
verification process is immediately stopped. If the verify
callback fun returns <c>{valid, UserState}</c>, the verification
process is continued. This can be used to accept specific path
validation errors, such as <c>selfsigned_peer</c>, as well as
verifying application-specific extensions. If called with an
extension unknown to the user application, the return value
<c>{unknown, UserState}</c> is to be used.</p>
</item>
<tag>{max_path_length, integer()}</tag>
<item>
The <c>max_path_length</c> is the maximum number of non-self-issued
intermediate certificates that can follow the peer certificate
in a valid certification path. So, if <c>max_path_length</c> is 0, the PEER must
be signed by the trusted ROOT-CA directly, if it is 1, the path can
be PEER, CA, ROOT-CA, if it is 2, the path can
be PEER, CA, CA, ROOT-CA, and so on.
</item>
</taglist>
<p>Possible reasons for a bad certificate: </p>
<taglist>
<tag>cert_expired</tag>
<item><p>Certificate is no longer valid as its expiration date has passed.</p></item>
<tag>invalid_issuer</tag>
<item><p>Certificate issuer name does not match the name of the issuer certificate in the chain.</p></item>
<tag>invalid_signature</tag>
<item><p>Certificate was not signed by its issuer certificate in the chain.</p></item>
<tag>name_not_permitted</tag>
<item><p>Invalid Subject Alternative Name extension.</p></item>
<tag>missing_basic_constraint</tag>
<item><p>Certificate, required to have the basic constraints extension, does not have
a basic constraints extension.</p></item>
<tag>invalid_key_usage</tag>
<item><p>Certificate key is used in an invalid way according to the key-usage extension.</p></item>
<tag>{revoked, crl_reason()}</tag>
<item><p>Certificate has been revoked.</p></item>
<tag>atom()</tag>
<item><p>Application-specific error reason that is to be checked by the <c>verify_fun</c>.</p></item>
</taglist>
</desc>
</func>
<func>
<name>pkix_crl_issuer(CRL) -> issuer_name()</name>
<fsummary>Returns the issuer of the <c>CRL</c>.</fsummary>
<type>
<v>CRL = der_encoded() | #'CertificateList'{} </v>
</type>
<desc>
<p>Returns the issuer of the <c>CRL</c>.</p>
</desc>
</func>
<func>
<name>pkix_crls_validate(OTPCertificate, DPAndCRLs, Options) -> CRLStatus()</name>
<fsummary>Performs CRL validation.</fsummary>
<type>
<v>OTPCertificate = #'OTPCertificate'{}</v>
<v>DPAndCRLs = [{DP::#'DistributionPoint'{}, {DerCRL::der_encoded(), CRL::#'CertificateList'{}}}] </v>
<v>Options = proplists:proplist()</v>
<v>CRLStatus() = valid | {bad_cert, revocation_status_undetermined} | {bad_cert, {revocation_status_undetermined,
{bad_crls, Details::term()}}} | {bad_cert, {revoked, crl_reason()}}</v>
</type>
<desc>
<p>Performs CRL validation. It is intended to be called from
the verify fun of <seealso marker="#pkix_path_validation-3"> pkix_path_validation/3
</seealso>.</p>
<p>Available options:</p>
<taglist>
<tag>{update_crl, fun()}</tag>
<item>
<p>The fun has the following type specification:</p>
<code> fun(#'DistributionPoint'{}, #'CertificateList'{}) ->
#'CertificateList'{}</code>
<p>The fun uses the information in the distribution point to access
the latest possible version of the CRL. If this fun is not specified,
Public Key uses the default implementation:
</p>
<code> fun(_DP, CRL) -> CRL end</code>
</item>
<tag>{issuer_fun, fun()}</tag>
<item>
<p>The fun has the following type specification:</p>
<code>
fun(#'DistributionPoint'{}, #'CertificateList'{},
{rdnSequence,[#'AttributeTypeAndValue'{}]}, term()) ->
{ok, #'OTPCertificate'{}, [der_encoded]}</code>
<p>The fun returns the root certificate and certificate chain
that has signed the CRL.
</p>
<code> fun(DP, CRL, Issuer, UserState) -> {ok, RootCert, CertChain}</code>
</item>
<tag>{undetermined_details, boolean()}</tag>
<item>
<p>Defaults to false. When revocation status cannot be
determined, and this option is set to true, details of why no
CRLs where accepted are included in the return value.</p>
</item>
</taglist>
</desc>
</func>
<func>
<name>pkix_crl_verify(CRL, Cert) -> boolean()</name>
<fsummary> Verify that <c>Cert</c> is the <c> CRL</c> signer. </fsummary>
<type>
<v>CRL = der_encoded() | #'CertificateList'{} </v>
<v>Cert = der_encoded() | #'OTPCertificate'{} </v>
</type>
<desc>
<p>Verify that <c>Cert</c> is the <c>CRL</c> signer.</p>
</desc>
</func>
<func>
<name>pkix_dist_point(Cert) -> DistPoint</name>
<fsummary>Creates a distribution point for CRLs issued by the same issuer as <c>Cert</c>.</fsummary>
<type>
<v> Cert = der_encoded() | #'OTPCertificate'{} </v>
<v> DistPoint = #'DistributionPoint'{}</v>
</type>
<desc>
<p>Creates a distribution point for CRLs issued by the same issuer as <c>Cert</c>.
Can be used as input to <seealso
marker="#pkix_crls_validate-3">pkix_crls_validate/3 </seealso>
</p>
</desc>
</func>
<func>
<name>pkix_dist_points(Cert) -> DistPoints</name>
<fsummary> Extracts distribution points from the certificates extensions.</fsummary>
<type>
<v> Cert = der_encoded() | #'OTPCertificate'{} </v>
<v> DistPoints = [#'DistributionPoint'{}]</v>
</type>
<desc>
<p> Extracts distribution points from the certificates extensions.</p>
</desc>
</func>
<func>
<name>pkix_match_dist_point(CRL, DistPoint) -> boolean()</name>
<fsummary>Checks whether the given distribution point matches the
Issuing Distribution Point of the CRL.</fsummary>
<type>
<v>CRL = der_encoded() | #'CertificateList'{} </v>
<v>DistPoint = #'DistributionPoint'{}</v>
</type>
<desc>
<p>Checks whether the given distribution point matches the
Issuing Distribution Point of the CRL, as described in RFC 5280.
If the CRL doesn't have an Issuing Distribution Point extension,
the distribution point always matches.</p>
</desc>
</func>
<func>
<name>pkix_sign(#'OTPTBSCertificate'{}, Key) -> der_encoded()</name>
<fsummary>Signs certificate.</fsummary>
<type>
<v>Key = rsa_private_key() | dsa_private_key()</v>
</type>
<desc>
<p>Signs an 'OTPTBSCertificate'. Returns the corresponding
DER-encoded certificate.</p>
</desc>
</func>
<func>
<name>pkix_sign_types(AlgorithmId) -> {DigestType, SignatureType}</name>
<fsummary>Translates signature algorithm OID to Erlang digest and signature algorithm types.</fsummary>
<type>
<v>AlgorithmId = oid()</v>
<d>Signature OID from a certificate or a certificate revocation list.</d>
<v>DigestType = rsa_digest_type() | dss_digest_type()</v>
<v>SignatureType = rsa | dsa | ecdsa</v>
</type>
<desc>
<p>Translates signature algorithm OID to Erlang digest and signature types.
</p>
</desc>
</func>
<func>
<name>pkix_test_data(Options) -> Config </name>
<name>pkix_test_data([chain_opts()]) -> [conf_opt()]</name>
<fsummary>Creates certificate test data.</fsummary>
<type>
<v>Options = #{chain_type() := chain_opts()} </v>
<d>Options for ROOT, Intermediate and Peer certs</d>
<v>chain_type() = server_chain | client_chain </v>
<v>chain_opts() = #{root := [cert_opt()] | root_cert(),
peer := [cert_opt()],
intermediates => [[cert_opt()]]}</v>
<d>
A valid chain must have at least a ROOT and a peer cert.
The root cert can be given either as a cert pre-generated by
<seealso marker="#pkix_test_root_cert-2">
pkix_test_root_cert/2
</seealso>, or as root cert generation options.
</d>
<v>root_cert() = #{cert := der_encoded(), key := Key}</v>
<d>
A root certificate generated by
<seealso marker="#pkix_test_root_cert-2">
pkix_test_root_cert/2
</seealso>.
</d>
<v>cert_opt() = {Key, Value}</v>
<d>For available options see <seealso marker="#cert_opt"> cert_opt()</seealso> below.</d>
<v>Config = #{server_config := [conf_opt()],
client_config := [conf_opt()]}</v>
<v>conf_opt() = {cert, der_encoded()} | {key, PrivateKey} |{cacerts, [der_encoded()]}</v>
<d>
This is a subset of the type
<seealso marker="ssl:ssl#type-ssloption"> ssl:ssl_option()</seealso>.
<c>PrivateKey</c> is what
<seealso marker="#generate_key-1">generate_key/1</seealso>
returns.
</d>
</type>
<desc>
<p>
Creates certificate configuration(s) consisting of certificate
and its private key plus CA certificate bundle, for a client
and a server, intended to facilitate automated testing
of applications using X509-certificates,
often through SSL/TLS. The test data can be used
when you have control over both the client and the server
in a test scenario.
</p>
<p>
When this function is called with a map containing
client and server chain specifications;
it generates both a client and a server certificate chain
where the <c>cacerts</c>
returned for the server contains the root cert the server
should trust and the intermediate certificates the server
should present to connecting clients.
The root cert the server should trust is the one used
as root of the client certificate chain.
Vice versa applies to the <c>cacerts</c> returned for the client.
The root cert(s) can either be pre-generated with
<seealso marker="#pkix_test_root_cert-2">
pkix_test_root_cert/2
</seealso>, or if options are specified; it is (they are)
generated.
</p>
<p>
When this function is called with a list of certificate options;
it generates a configuration with just one node certificate
where <c>cacerts</c> contains the root cert
and the intermediate certs that should be presented to a peer.
In this case the same root cert must be used for all peers.
This is useful in for example an Erlang distributed cluster
where any node, towards another node, acts either
as a server or as a client depending on who connects to whom.
The generated certificate contains a subject altname,
which is not needed in a client certificate,
but makes the certificate useful for both roles.
</p>
<p>
The <marker id="cert_opt"/><c>cert_opt()</c>
type consists of the following options:
</p>
<taglist>
<tag> {digest, digest_type()}</tag>
<item><p>Hash algorithm to be used for
signing the certificate together with the key option. Defaults to sha that is sha1.
</p></item>
<tag> {key, key_params() | private_key()}</tag>
<item><p>Parameters to be used to call public_key:generate_key/1, to generate a key, or an existing
key. Defaults to generating an ECDSA key. Note this could fail if Erlang/OTP is compiled with a very old
cryptolib.</p></item>
<tag> {validity, {From::erlang:timestamp(), To::erlang:timestamp()}} </tag>
<item><p>The validity period of the certificate.</p></item>
<tag> {extensions, [#'Extension'{}]}</tag>
<item><p> Extensions to include in the certificate.</p>
<p>Default extensions included in CA certificates if not
otherwise specified are: </p>
<code>[#'Extension'{extnID = ?'id-ce-keyUsage',
extnValue = [keyCertSign, cRLSign],
critical = false},
#'Extension'{extnID = ?'id-ce-basicConstraints',
extnValue = #'BasicConstraints'{cA = true},
critical = true}]
</code>
<p>Default extensions included in the server peer cert if not
otherwise specified are: </p>
<code>[#'Extension'{extnID = ?'id-ce-keyUsage',
extnValue = [digitalSignature, keyAgreement],
critical = false},
#'Extension'{extnID = ?'id-ce-subjectAltName',
extnValue = [{dNSName, Hostname}],
critical = false}]
</code>
<p>Hostname is the result of calling net_adm:localhost() in the Erlang node
where this funcion is called.
</p></item>
</taglist>
<note><p>
Note that the generated certificates and keys does not provide a formally correct PKIX-trust-chain
and they cannot be used to achieve real security. This function is provided for testing purposes only.
</p></note>
</desc>
</func>
<func>
<name>pkix_test_root_cert(Name, Options) -> RootCert</name>
<fsummary>Generates a test data root cert.</fsummary>
<type>
<v>Name = string()</v>
<d>The root certificate name.</d>
<v>Options = [cert_opt()]</v>
<d>
For available options see
<seealso marker="#cert_opt">cert_opt()</seealso>
under
<seealso marker="#pkix_test_data-1">pkix_test_data/1</seealso>.
</d>
<v>RootCert = #{cert := der_encoded(), key := Key}</v>
<d>
A root certificate and key. The <c>Key</c> is generated by
<seealso marker="#generate_key-1">generate_key/1</seealso>.
</d>
</type>
<desc>
<p>
Generates a root certificate that can be used
in multiple calls to
<seealso marker="#pkix_test_data-1">pkix_test_data/1</seealso>
when you want the same root certificate for
several generated certificates.
</p>
</desc>
</func>
<func>
<name>pkix_verify(Cert, Key) -> boolean()</name>
<fsummary>Verifies PKIX x.509 certificate signature.</fsummary>
<type>
<v>Cert = der_encoded()</v>
<v>Key = rsa_public_key() | dsa_public_key() | ec_public_key()</v>
</type>
<desc>
<p>Verifies PKIX x.509 certificate signature.</p>
</desc>
</func>
<func>
<name>pkix_verify_hostname(Cert, ReferenceIDs) -> boolean()</name>
<name>pkix_verify_hostname(Cert, ReferenceIDs, Opts) -> boolean()</name>
<fsummary>Verifies that a PKIX x.509 certificate <i>presented identifier</i> (e.g hostname) is
an expected one.</fsummary>
<type>
<v>Cert = der_encoded() | #'OTPCertificate'{} </v>
<v>ReferenceIDs = [ RefID ]</v>
<v>RefID = {dns_id,string()} | {srv_id,string()} | {uri_id,string()} | {ip,inet:ip_address()|string()} | {OtherRefID,term()}}</v>
<v>OtherRefID = atom()</v>
<v>Opts = [ PvhOpt() ]</v>
<v>PvhOpt = [MatchOpt | FailCallBackOpt | FqdnExtractOpt]</v>
<v>MatchOpt = {match_fun, fun(RefId | FQDN::string(), PresentedID) -> boolean() | default}</v>
<v>PresentedID = {dNSName,string()} | {uniformResourceIdentifier,string() | {iPAddress,list(byte())} | {OtherPresId,term()}}</v>
<v>OtherPresID = atom()</v>
<v>FailCallBackOpt = {fail_callback, fun(#'OTPCertificate'{}) -> boolean()}</v>
<v>FqdnExtractOpt = {fqdn_fun, fun(RefID) -> FQDN::string() | default | undefined}</v>
</type>
<desc>
<p>This function checks that the <i>Presented Identifier</i> (e.g hostname) in a peer certificate
is in agreement with at least one of the <i>Reference Identifier</i> that the client expects to be connected to.
The function is intended to be added as an extra client check of the peer certificate when performing
<seealso marker="public_key:public_key#pkix_path_validation-3">public_key:pkix_path_validation/3</seealso>
</p>
<p>See <url href="https://tools.ietf.org/html/rfc6125">RFC 6125</url>
for detailed information about hostname verification.
The <seealso marker="using_public_key#verify_hostname">User's Guide</seealso>
and
<seealso marker="using_public_key#verify_hostname_examples">code examples</seealso>
describes this function more detailed.
</p>
<p>The <c>{OtherRefId,term()}</c> is defined by the user and is passed to the <c>match_fun</c>, if defined.
If the term in <c>OtherRefId</c> is a binary, it will be converted to a string.
</p>
<p>The <c>ip</c> Reference ID takes an <seealso marker="inet:inet#type-ip_address">inet:ip_address()</seealso>
or an ip address in string format (E.g "10.0.1.1" or "1234::5678:9012") as second element.
</p>
<p>The options are:</p>
<taglist>
<tag><c>match_fun</c></tag>
<item>
The <c>fun/2</c> in this option replaces the default host name matching rules. The fun should return a
boolean to tell if the Reference ID and Presented ID matches or not. The fun can also return a third
value, the atom <c>default</c>, if the default matching rules shall apply.
This makes it possible to augment the tests with a special case:
<code>
fun(....) -> true; % My special case
(_, _) -> default % all others falls back to the inherit tests
end
</code>
<br/>See <seealso marker="#pkix_verify_hostname_match_fun-1">pkix_verify_hostname_match_fun/1</seealso> for a
function that takes a protocol name as argument and returns a <c>fun/2</c> suitable for this option and
<seealso marker="using_public_key#redefining_match_op">Re-defining the match operation</seealso>
in the User's Guide for an example.
</item>
<tag><c>fail_callback</c></tag>
<item>If a matching fails, there could be circumstances when the certificate should be accepted anyway. Think for
example of a web browser where you choose to accept an outdated certificate. This option enables implementation
of such a function. This <c>fun/1</c> is called when no <c>ReferenceID</c> matches. The return value of the fun
(a <c>boolean()</c>) decides the outcome. If <c>true</c> the the certificate is accepted otherwise
it is rejected. See
<seealso marker="using_public_key#-pinning--a-certificate">"Pinning" a Certificate</seealso>
in the User's Guide.
</item>
<tag><c>fqdn_fun</c></tag>
<item>This option augments the host name extraction from URIs and other Reference IDs. It could for example be
a very special URI that is not standardised. The fun takes a Reference ID as argument and returns one of:
<list>
<item>the hostname</item>
<item>the atom <c>default</c>: the default host name extract function will be used</item>
<item>the atom <c>undefined</c>: a host name could not be extracted. The pkix_verify_hostname/3
will return <c>false</c>.</item>
</list>
<br/>For an example, see
<seealso marker="using_public_key#hostname_extraction">Hostname extraction</seealso>
in the User's Guide.
</item>
</taglist>
</desc>
</func>
<func>
<name>pkix_verify_hostname_match_fun(Protcol) -> fun(RefId | FQDN::string(), PresentedID) -> boolean() | default</name>
<fsummary>Returns a fun that is intendended as argument to the match_fun option in pkix_verify_hostname/3.
</fsummary>
<type>
<v>Protocol = https</v>
<d>The algorithm for wich the fun should implement the special matching rules</d>
<v>RefId</v>
<d>See <seealso marker="#pkix_verify_hostname-3">pkix_verify_hostname/3</seealso>.</d>
<v>FQDN</v>
<d>See <seealso marker="#pkix_verify_hostname-3">pkix_verify_hostname/3</seealso>.</d>
<v>PresentedID</v>
<d>See <seealso marker="#pkix_verify_hostname-3">pkix_verify_hostname/3</seealso>.</d>
</type>
<desc>
<p>The return value of calling this function is intended to be used in the <c>match_fun</c> option in
<seealso marker="#pkix_verify_hostname-3">pkix_verify_hostname/3</seealso>.
</p>
<p>The returned fun augments the verify hostname matching according to the specific rules for
the protocol in the argument.
</p>
</desc>
</func>
<func>
<name>sign(Msg, DigestType, Key) -> binary()</name>
<name>sign(Msg, DigestType, Key, Options) -> binary()</name>
<fsummary>Creates a digital signature.</fsummary>
<type>
<v>Msg = binary() | {digest,binary()}</v>
<d>The <c>Msg</c> is either the binary "plain text" data to be
signed or it is the hashed value of "plain text", that is, the
digest.</d>
<v>DigestType = rsa_digest_type() | dss_digest_type() | ecdsa_digest_type()</v>
<v>Key = rsa_private_key() | dsa_private_key() | ec_private_key()</v>
<v>Options = public_sign_options()</v>
</type>
<desc>
<p>Creates a digital signature.</p>
</desc>
</func>
<func>
<name>ssh_decode(SshBin, Type) -> [{public_key(), Attributes::list()}]</name>
<fsummary>Decodes an SSH file-binary.</fsummary>
<type>
<v>SshBin = binary()</v>
<d>Example <c>{ok, SshBin} = file:read_file("known_hosts")</c>.</d>
<v>Type = public_key | ssh_file()</v>
<d>If <c>Type</c> is <c>public_key</c> the binary can be either
an RFC4716 public key or an OpenSSH public key.</d>
</type>
<desc>
<p>Decodes an SSH file-binary. In the case of <c>known_hosts</c> or
<c>auth_keys</c>, the binary can include one or more lines of the
file. Returns a list of public keys and their attributes, possible
attribute values depends on the file type represented by the
binary.
</p>
<taglist>
<tag>RFC4716 attributes - see RFC 4716.</tag>
<item><p>{headers, [{string(), utf8_string()}]}</p></item>
<tag>auth_key attributes - see manual page for sshd.</tag>
<item>{comment, string()}</item>
<item>{options, [string()]}</item>
<item><p>{bits, integer()} - In SSH version 1 files.</p></item>
<tag>known_host attributes - see manual page for sshd.</tag>
<item>{hostnames, [string()]}</item>
<item>{comment, string()}</item>
<item><p>{bits, integer()} - In SSH version 1 files.</p></item>
</taglist>
</desc>
</func>
<func>
<name>ssh_encode([{Key, Attributes}], Type) -> binary()</name>
<fsummary>Encodes a list of SSH file entries to a binary.</fsummary>
<type>
<v>Key = public_key()</v>
<v>Attributes = list()</v>
<v>Type = ssh_file()</v>
</type>
<desc>
<p>Encodes a list of SSH file entries (public keys and attributes) to a binary. Possible
attributes depend on the file type, see <seealso
marker="#ssh_decode-2"> ssh_decode/2 </seealso>.</p>
</desc>
</func>
<func>
<name>ssh_hostkey_fingerprint(HostKey) -> string()</name>
<name>ssh_hostkey_fingerprint(DigestType, HostKey) -> string()</name>
<name>ssh_hostkey_fingerprint([DigestType], HostKey) -> [string()]</name>
<fsummary>Calculates a ssh fingerprint for a hostkey.</fsummary>
<type>
<v>Key = public_key()</v>
<v>DigestType = digest_type()</v>
</type>
<desc>
<p>Calculates a ssh fingerprint from a public host key as openssh does.</p>
<p>The algorithm in <c>ssh_hostkey_fingerprint/1</c> is md5 to be compatible with older
ssh-keygen commands. The string from the second variant is prepended by the algorithm name
in uppercase as in newer ssh-keygen commands.</p>
<p>Examples:</p>
<code>
2> public_key:ssh_hostkey_fingerprint(Key).
"f5:64:a6:c1:5a:cb:9f:0a:10:46:a2:5c:3e:2f:57:84"
3> public_key:ssh_hostkey_fingerprint(md5,Key).
"MD5:f5:64:a6:c1:5a:cb:9f:0a:10:46:a2:5c:3e:2f:57:84"
4> public_key:ssh_hostkey_fingerprint(sha,Key).
"SHA1:bSLY/C4QXLDL/Iwmhyg0PGW9UbY"
5> public_key:ssh_hostkey_fingerprint(sha256,Key).
"SHA256:aZGXhabfbf4oxglxltItWeHU7ub3Dc31NcNw2cMJePQ"
6> public_key:ssh_hostkey_fingerprint([sha,sha256],Key).
["SHA1:bSLY/C4QXLDL/Iwmhyg0PGW9UbY",
"SHA256:aZGXhabfbf4oxglxltItWeHU7ub3Dc31NcNw2cMJePQ"]
</code>
</desc>
</func>
<func>
<name>verify(Msg, DigestType, Signature, Key) -> boolean()</name>
<name>verify(Msg, DigestType, Signature, Key, Options) -> boolean()</name>
<fsummary>Verifies a digital signature.</fsummary>
<type>
<v>Msg = binary() | {digest,binary()}</v>
<d>The <c>Msg</c> is either the binary "plain text" data
or it is the hashed value of "plain text", that is, the digest.</d>
<v>DigestType = rsa_digest_type() | dss_digest_type() | ecdsa_digest_type()</v>
<v>Signature = binary()</v>
<v>Key = rsa_public_key() | dsa_public_key() | ec_public_key()</v>
<v>Options = public_sign_options()</v>
</type>
<desc>
<p>Verifies a digital signature.</p>
</desc>
</func>
<func>
<name>short_name_hash(Name) -> string()</name>
<fsummary>Generates a short hash of an issuer name.</fsummary>
<type>
<v>Name = issuer_name()</v>
</type>
<desc>
<p>Generates a short hash of an issuer name. The hash is
returned as a string containing eight hexadecimal digits.</p>
<p>The return value of this function is the same as the result
of the commands <c>openssl crl -hash</c> and
<c>openssl x509 -issuer_hash</c>, when passed the issuer name of
a CRL or a certificate, respectively. This hash is used by the
<c>c_rehash</c> tool to maintain a directory of symlinks to CRL
files, in order to facilitate looking up a CRL by its issuer
name.</p>
</desc>
</func>
</funcs>
</erlref>