Update API documentation to beta3 rc4
The PDF documentation is now a single PDF file generated with Sphinx.
The HTML documentation is now generated with Sphinx. The sole entry
point is index.html. modules.html no longer exists.
diff --git a/docs/html/.buildinfo b/docs/html/.buildinfo
new file mode 100644
index 0000000..379f371
--- /dev/null
+++ b/docs/html/.buildinfo
@@ -0,0 +1,4 @@
+# Sphinx build info version 1
+# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
+config: 3c0fcdd2bdf4eedd64fc44c41889daf2
+tags: 645f666f9bcd5a90fca523b33c5a78b7
diff --git a/docs/html/_static/ajax-loader.gif b/docs/html/_static/ajax-loader.gif
new file mode 100644
index 0000000..61faf8c
--- /dev/null
+++ b/docs/html/_static/ajax-loader.gif
Binary files differ
diff --git a/docs/html/_static/alabaster.css b/docs/html/_static/alabaster.css
new file mode 100644
index 0000000..0eddaeb
--- /dev/null
+++ b/docs/html/_static/alabaster.css
@@ -0,0 +1,701 @@
+@import url("basic.css");
+
+/* -- page layout ----------------------------------------------------------- */
+
+body {
+ font-family: Georgia, serif;
+ font-size: 17px;
+ background-color: #fff;
+ color: #000;
+ margin: 0;
+ padding: 0;
+}
+
+
+div.document {
+ width: 940px;
+ margin: 30px auto 0 auto;
+}
+
+div.documentwrapper {
+ float: left;
+ width: 100%;
+}
+
+div.bodywrapper {
+ margin: 0 0 0 220px;
+}
+
+div.sphinxsidebar {
+ width: 220px;
+ font-size: 14px;
+ line-height: 1.5;
+}
+
+hr {
+ border: 1px solid #B1B4B6;
+}
+
+div.body {
+ background-color: #fff;
+ color: #3E4349;
+ padding: 0 30px 0 30px;
+}
+
+div.body > .section {
+ text-align: left;
+}
+
+div.footer {
+ width: 940px;
+ margin: 20px auto 30px auto;
+ font-size: 14px;
+ color: #888;
+ text-align: right;
+}
+
+div.footer a {
+ color: #888;
+}
+
+p.caption {
+ font-family: inherit;
+ font-size: inherit;
+}
+
+
+div.relations {
+ display: none;
+}
+
+
+div.sphinxsidebar a {
+ color: #444;
+ text-decoration: none;
+ border-bottom: 1px dotted #999;
+}
+
+div.sphinxsidebar a:hover {
+ border-bottom: 1px solid #999;
+}
+
+div.sphinxsidebarwrapper {
+ padding: 18px 10px;
+}
+
+div.sphinxsidebarwrapper p.logo {
+ padding: 0;
+ margin: -10px 0 0 0px;
+ text-align: center;
+}
+
+div.sphinxsidebarwrapper h1.logo {
+ margin-top: -10px;
+ text-align: center;
+ margin-bottom: 5px;
+ text-align: left;
+}
+
+div.sphinxsidebarwrapper h1.logo-name {
+ margin-top: 0px;
+}
+
+div.sphinxsidebarwrapper p.blurb {
+ margin-top: 0;
+ font-style: normal;
+}
+
+div.sphinxsidebar h3,
+div.sphinxsidebar h4 {
+ font-family: Georgia, serif;
+ color: #444;
+ font-size: 24px;
+ font-weight: normal;
+ margin: 0 0 5px 0;
+ padding: 0;
+}
+
+div.sphinxsidebar h4 {
+ font-size: 20px;
+}
+
+div.sphinxsidebar h3 a {
+ color: #444;
+}
+
+div.sphinxsidebar p.logo a,
+div.sphinxsidebar h3 a,
+div.sphinxsidebar p.logo a:hover,
+div.sphinxsidebar h3 a:hover {
+ border: none;
+}
+
+div.sphinxsidebar p {
+ color: #555;
+ margin: 10px 0;
+}
+
+div.sphinxsidebar ul {
+ margin: 10px 0;
+ padding: 0;
+ color: #000;
+}
+
+div.sphinxsidebar ul li.toctree-l1 > a {
+ font-size: 120%;
+}
+
+div.sphinxsidebar ul li.toctree-l2 > a {
+ font-size: 110%;
+}
+
+div.sphinxsidebar input {
+ border: 1px solid #CCC;
+ font-family: Georgia, serif;
+ font-size: 1em;
+}
+
+div.sphinxsidebar hr {
+ border: none;
+ height: 1px;
+ color: #AAA;
+ background: #AAA;
+
+ text-align: left;
+ margin-left: 0;
+ width: 50%;
+}
+
+div.sphinxsidebar .badge {
+ border-bottom: none;
+}
+
+div.sphinxsidebar .badge:hover {
+ border-bottom: none;
+}
+
+/* To address an issue with donation coming after search */
+div.sphinxsidebar h3.donation {
+ margin-top: 10px;
+}
+
+/* -- body styles ----------------------------------------------------------- */
+
+a {
+ color: #004B6B;
+ text-decoration: underline;
+}
+
+a:hover {
+ color: #6D4100;
+ text-decoration: underline;
+}
+
+div.body h1,
+div.body h2,
+div.body h3,
+div.body h4,
+div.body h5,
+div.body h6 {
+ font-family: Georgia, serif;
+ font-weight: normal;
+ margin: 30px 0px 10px 0px;
+ padding: 0;
+}
+
+div.body h1 { margin-top: 0; padding-top: 0; font-size: 240%; }
+div.body h2 { font-size: 180%; }
+div.body h3 { font-size: 150%; }
+div.body h4 { font-size: 130%; }
+div.body h5 { font-size: 100%; }
+div.body h6 { font-size: 100%; }
+
+a.headerlink {
+ color: #DDD;
+ padding: 0 4px;
+ text-decoration: none;
+}
+
+a.headerlink:hover {
+ color: #444;
+ background: #EAEAEA;
+}
+
+div.body p, div.body dd, div.body li {
+ line-height: 1.4em;
+}
+
+div.admonition {
+ margin: 20px 0px;
+ padding: 10px 30px;
+ background-color: #EEE;
+ border: 1px solid #CCC;
+}
+
+div.admonition tt.xref, div.admonition code.xref, div.admonition a tt {
+ background-color: #FBFBFB;
+ border-bottom: 1px solid #fafafa;
+}
+
+div.admonition p.admonition-title {
+ font-family: Georgia, serif;
+ font-weight: normal;
+ font-size: 24px;
+ margin: 0 0 10px 0;
+ padding: 0;
+ line-height: 1;
+}
+
+div.admonition p.last {
+ margin-bottom: 0;
+}
+
+div.highlight {
+ background-color: #fff;
+}
+
+dt:target, .highlight {
+ background: #FAF3E8;
+}
+
+div.warning {
+ background-color: #FCC;
+ border: 1px solid #FAA;
+}
+
+div.danger {
+ background-color: #FCC;
+ border: 1px solid #FAA;
+ -moz-box-shadow: 2px 2px 4px #D52C2C;
+ -webkit-box-shadow: 2px 2px 4px #D52C2C;
+ box-shadow: 2px 2px 4px #D52C2C;
+}
+
+div.error {
+ background-color: #FCC;
+ border: 1px solid #FAA;
+ -moz-box-shadow: 2px 2px 4px #D52C2C;
+ -webkit-box-shadow: 2px 2px 4px #D52C2C;
+ box-shadow: 2px 2px 4px #D52C2C;
+}
+
+div.caution {
+ background-color: #FCC;
+ border: 1px solid #FAA;
+}
+
+div.attention {
+ background-color: #FCC;
+ border: 1px solid #FAA;
+}
+
+div.important {
+ background-color: #EEE;
+ border: 1px solid #CCC;
+}
+
+div.note {
+ background-color: #EEE;
+ border: 1px solid #CCC;
+}
+
+div.tip {
+ background-color: #EEE;
+ border: 1px solid #CCC;
+}
+
+div.hint {
+ background-color: #EEE;
+ border: 1px solid #CCC;
+}
+
+div.seealso {
+ background-color: #EEE;
+ border: 1px solid #CCC;
+}
+
+div.topic {
+ background-color: #EEE;
+}
+
+p.admonition-title {
+ display: inline;
+}
+
+p.admonition-title:after {
+ content: ":";
+}
+
+pre, tt, code {
+ font-family: 'Consolas', 'Menlo', 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', monospace;
+ font-size: 0.9em;
+}
+
+.hll {
+ background-color: #FFC;
+ margin: 0 -12px;
+ padding: 0 12px;
+ display: block;
+}
+
+img.screenshot {
+}
+
+tt.descname, tt.descclassname, code.descname, code.descclassname {
+ font-size: 0.95em;
+}
+
+tt.descname, code.descname {
+ padding-right: 0.08em;
+}
+
+img.screenshot {
+ -moz-box-shadow: 2px 2px 4px #EEE;
+ -webkit-box-shadow: 2px 2px 4px #EEE;
+ box-shadow: 2px 2px 4px #EEE;
+}
+
+table.docutils {
+ border: 1px solid #888;
+ -moz-box-shadow: 2px 2px 4px #EEE;
+ -webkit-box-shadow: 2px 2px 4px #EEE;
+ box-shadow: 2px 2px 4px #EEE;
+}
+
+table.docutils td, table.docutils th {
+ border: 1px solid #888;
+ padding: 0.25em 0.7em;
+}
+
+table.field-list, table.footnote {
+ border: none;
+ -moz-box-shadow: none;
+ -webkit-box-shadow: none;
+ box-shadow: none;
+}
+
+table.footnote {
+ margin: 15px 0;
+ width: 100%;
+ border: 1px solid #EEE;
+ background: #FDFDFD;
+ font-size: 0.9em;
+}
+
+table.footnote + table.footnote {
+ margin-top: -15px;
+ border-top: none;
+}
+
+table.field-list th {
+ padding: 0 0.8em 0 0;
+}
+
+table.field-list td {
+ padding: 0;
+}
+
+table.field-list p {
+ margin-bottom: 0.8em;
+}
+
+/* Cloned from
+ * https://github.com/sphinx-doc/sphinx/commit/ef60dbfce09286b20b7385333d63a60321784e68
+ */
+.field-name {
+ -moz-hyphens: manual;
+ -ms-hyphens: manual;
+ -webkit-hyphens: manual;
+ hyphens: manual;
+}
+
+table.footnote td.label {
+ width: .1px;
+ padding: 0.3em 0 0.3em 0.5em;
+}
+
+table.footnote td {
+ padding: 0.3em 0.5em;
+}
+
+dl {
+ margin: 0;
+ padding: 0;
+}
+
+dl dd {
+ margin-left: 30px;
+}
+
+blockquote {
+ margin: 0 0 0 30px;
+ padding: 0;
+}
+
+ul, ol {
+ /* Matches the 30px from the narrow-screen "li > ul" selector below */
+ margin: 10px 0 10px 30px;
+ padding: 0;
+}
+
+pre {
+ background: #EEE;
+ padding: 7px 30px;
+ margin: 15px 0px;
+ line-height: 1.3em;
+}
+
+div.viewcode-block:target {
+ background: #ffd;
+}
+
+dl pre, blockquote pre, li pre {
+ margin-left: 0;
+ padding-left: 30px;
+}
+
+tt, code {
+ background-color: #ecf0f3;
+ color: #222;
+ /* padding: 1px 2px; */
+}
+
+tt.xref, code.xref, a tt {
+ background-color: #FBFBFB;
+ border-bottom: 1px solid #fff;
+}
+
+a.reference {
+ text-decoration: none;
+ border-bottom: 1px dotted #004B6B;
+}
+
+/* Don't put an underline on images */
+a.image-reference, a.image-reference:hover {
+ border-bottom: none;
+}
+
+a.reference:hover {
+ border-bottom: 1px solid #6D4100;
+}
+
+a.footnote-reference {
+ text-decoration: none;
+ font-size: 0.7em;
+ vertical-align: top;
+ border-bottom: 1px dotted #004B6B;
+}
+
+a.footnote-reference:hover {
+ border-bottom: 1px solid #6D4100;
+}
+
+a:hover tt, a:hover code {
+ background: #EEE;
+}
+
+
+@media screen and (max-width: 870px) {
+
+ div.sphinxsidebar {
+ display: none;
+ }
+
+ div.document {
+ width: 100%;
+
+ }
+
+ div.documentwrapper {
+ margin-left: 0;
+ margin-top: 0;
+ margin-right: 0;
+ margin-bottom: 0;
+ }
+
+ div.bodywrapper {
+ margin-top: 0;
+ margin-right: 0;
+ margin-bottom: 0;
+ margin-left: 0;
+ }
+
+ ul {
+ margin-left: 0;
+ }
+
+ li > ul {
+ /* Matches the 30px from the "ul, ol" selector above */
+ margin-left: 30px;
+ }
+
+ .document {
+ width: auto;
+ }
+
+ .footer {
+ width: auto;
+ }
+
+ .bodywrapper {
+ margin: 0;
+ }
+
+ .footer {
+ width: auto;
+ }
+
+ .github {
+ display: none;
+ }
+
+
+
+}
+
+
+
+@media screen and (max-width: 875px) {
+
+ body {
+ margin: 0;
+ padding: 20px 30px;
+ }
+
+ div.documentwrapper {
+ float: none;
+ background: #fff;
+ }
+
+ div.sphinxsidebar {
+ display: block;
+ float: none;
+ width: 102.5%;
+ margin: 50px -30px -20px -30px;
+ padding: 10px 20px;
+ background: #333;
+ color: #FFF;
+ }
+
+ div.sphinxsidebar h3, div.sphinxsidebar h4, div.sphinxsidebar p,
+ div.sphinxsidebar h3 a {
+ color: #fff;
+ }
+
+ div.sphinxsidebar a {
+ color: #AAA;
+ }
+
+ div.sphinxsidebar p.logo {
+ display: none;
+ }
+
+ div.document {
+ width: 100%;
+ margin: 0;
+ }
+
+ div.footer {
+ display: none;
+ }
+
+ div.bodywrapper {
+ margin: 0;
+ }
+
+ div.body {
+ min-height: 0;
+ padding: 0;
+ }
+
+ .rtd_doc_footer {
+ display: none;
+ }
+
+ .document {
+ width: auto;
+ }
+
+ .footer {
+ width: auto;
+ }
+
+ .footer {
+ width: auto;
+ }
+
+ .github {
+ display: none;
+ }
+}
+
+
+/* misc. */
+
+.revsys-inline {
+ display: none!important;
+}
+
+/* Make nested-list/multi-paragraph items look better in Releases changelog
+ * pages. Without this, docutils' magical list fuckery causes inconsistent
+ * formatting between different release sub-lists.
+ */
+div#changelog > div.section > ul > li > p:only-child {
+ margin-bottom: 0;
+}
+
+/* Hide fugly table cell borders in ..bibliography:: directive output */
+table.docutils.citation, table.docutils.citation td, table.docutils.citation th {
+ border: none;
+ /* Below needed in some edge cases; if not applied, bottom shadows appear */
+ -moz-box-shadow: none;
+ -webkit-box-shadow: none;
+ box-shadow: none;
+}
+
+
+/* relbar */
+
+.related {
+ line-height: 30px;
+ width: 100%;
+ font-size: 0.9rem;
+}
+
+.related.top {
+ border-bottom: 1px solid #EEE;
+ margin-bottom: 20px;
+}
+
+.related.bottom {
+ border-top: 1px solid #EEE;
+}
+
+.related ul {
+ padding: 0;
+ margin: 0;
+ list-style: none;
+}
+
+.related li {
+ display: inline;
+}
+
+nav#rellinks {
+ float: right;
+}
+
+nav#rellinks li+li:before {
+ content: "|";
+}
+
+nav#breadcrumbs li+li:before {
+ content: "\00BB";
+}
+
+/* Hide certain items when printing */
+@media print {
+ div.related {
+ display: none;
+ }
+}
\ No newline at end of file
diff --git a/docs/html/_static/basic.css b/docs/html/_static/basic.css
new file mode 100644
index 0000000..0807176
--- /dev/null
+++ b/docs/html/_static/basic.css
@@ -0,0 +1,676 @@
+/*
+ * basic.css
+ * ~~~~~~~~~
+ *
+ * Sphinx stylesheet -- basic theme.
+ *
+ * :copyright: Copyright 2007-2019 by the Sphinx team, see AUTHORS.
+ * :license: BSD, see LICENSE for details.
+ *
+ */
+
+/* -- main layout ----------------------------------------------------------- */
+
+div.clearer {
+ clear: both;
+}
+
+/* -- relbar ---------------------------------------------------------------- */
+
+div.related {
+ width: 100%;
+ font-size: 90%;
+}
+
+div.related h3 {
+ display: none;
+}
+
+div.related ul {
+ margin: 0;
+ padding: 0 0 0 10px;
+ list-style: none;
+}
+
+div.related li {
+ display: inline;
+}
+
+div.related li.right {
+ float: right;
+ margin-right: 5px;
+}
+
+/* -- sidebar --------------------------------------------------------------- */
+
+div.sphinxsidebarwrapper {
+ padding: 10px 5px 0 10px;
+}
+
+div.sphinxsidebar {
+ float: left;
+ width: 230px;
+ margin-left: -100%;
+ font-size: 90%;
+ word-wrap: break-word;
+ overflow-wrap : break-word;
+}
+
+div.sphinxsidebar ul {
+ list-style: none;
+}
+
+div.sphinxsidebar ul ul,
+div.sphinxsidebar ul.want-points {
+ margin-left: 20px;
+ list-style: square;
+}
+
+div.sphinxsidebar ul ul {
+ margin-top: 0;
+ margin-bottom: 0;
+}
+
+div.sphinxsidebar form {
+ margin-top: 10px;
+}
+
+div.sphinxsidebar input {
+ border: 1px solid #98dbcc;
+ font-family: sans-serif;
+ font-size: 1em;
+}
+
+div.sphinxsidebar #searchbox form.search {
+ overflow: hidden;
+}
+
+div.sphinxsidebar #searchbox input[type="text"] {
+ float: left;
+ width: 80%;
+ padding: 0.25em;
+ box-sizing: border-box;
+}
+
+div.sphinxsidebar #searchbox input[type="submit"] {
+ float: left;
+ width: 20%;
+ border-left: none;
+ padding: 0.25em;
+ box-sizing: border-box;
+}
+
+
+img {
+ border: 0;
+ max-width: 100%;
+}
+
+/* -- search page ----------------------------------------------------------- */
+
+ul.search {
+ margin: 10px 0 0 20px;
+ padding: 0;
+}
+
+ul.search li {
+ padding: 5px 0 5px 20px;
+ background-image: url(file.png);
+ background-repeat: no-repeat;
+ background-position: 0 7px;
+}
+
+ul.search li a {
+ font-weight: bold;
+}
+
+ul.search li div.context {
+ color: #888;
+ margin: 2px 0 0 30px;
+ text-align: left;
+}
+
+ul.keywordmatches li.goodmatch a {
+ font-weight: bold;
+}
+
+/* -- index page ------------------------------------------------------------ */
+
+table.contentstable {
+ width: 90%;
+ margin-left: auto;
+ margin-right: auto;
+}
+
+table.contentstable p.biglink {
+ line-height: 150%;
+}
+
+a.biglink {
+ font-size: 1.3em;
+}
+
+span.linkdescr {
+ font-style: italic;
+ padding-top: 5px;
+ font-size: 90%;
+}
+
+/* -- general index --------------------------------------------------------- */
+
+table.indextable {
+ width: 100%;
+}
+
+table.indextable td {
+ text-align: left;
+ vertical-align: top;
+}
+
+table.indextable ul {
+ margin-top: 0;
+ margin-bottom: 0;
+ list-style-type: none;
+}
+
+table.indextable > tbody > tr > td > ul {
+ padding-left: 0em;
+}
+
+table.indextable tr.pcap {
+ height: 10px;
+}
+
+table.indextable tr.cap {
+ margin-top: 10px;
+ background-color: #f2f2f2;
+}
+
+img.toggler {
+ margin-right: 3px;
+ margin-top: 3px;
+ cursor: pointer;
+}
+
+div.modindex-jumpbox {
+ border-top: 1px solid #ddd;
+ border-bottom: 1px solid #ddd;
+ margin: 1em 0 1em 0;
+ padding: 0.4em;
+}
+
+div.genindex-jumpbox {
+ border-top: 1px solid #ddd;
+ border-bottom: 1px solid #ddd;
+ margin: 1em 0 1em 0;
+ padding: 0.4em;
+}
+
+/* -- domain module index --------------------------------------------------- */
+
+table.modindextable td {
+ padding: 2px;
+ border-collapse: collapse;
+}
+
+/* -- general body styles --------------------------------------------------- */
+
+div.body {
+ min-width: 450px;
+ max-width: 800px;
+}
+
+div.body p, div.body dd, div.body li, div.body blockquote {
+ -moz-hyphens: auto;
+ -ms-hyphens: auto;
+ -webkit-hyphens: auto;
+ hyphens: auto;
+}
+
+a.headerlink {
+ visibility: hidden;
+}
+
+h1:hover > a.headerlink,
+h2:hover > a.headerlink,
+h3:hover > a.headerlink,
+h4:hover > a.headerlink,
+h5:hover > a.headerlink,
+h6:hover > a.headerlink,
+dt:hover > a.headerlink,
+caption:hover > a.headerlink,
+p.caption:hover > a.headerlink,
+div.code-block-caption:hover > a.headerlink {
+ visibility: visible;
+}
+
+div.body p.caption {
+ text-align: inherit;
+}
+
+div.body td {
+ text-align: left;
+}
+
+.first {
+ margin-top: 0 !important;
+}
+
+p.rubric {
+ margin-top: 30px;
+ font-weight: bold;
+}
+
+img.align-left, .figure.align-left, object.align-left {
+ clear: left;
+ float: left;
+ margin-right: 1em;
+}
+
+img.align-right, .figure.align-right, object.align-right {
+ clear: right;
+ float: right;
+ margin-left: 1em;
+}
+
+img.align-center, .figure.align-center, object.align-center {
+ display: block;
+ margin-left: auto;
+ margin-right: auto;
+}
+
+.align-left {
+ text-align: left;
+}
+
+.align-center {
+ text-align: center;
+}
+
+.align-right {
+ text-align: right;
+}
+
+/* -- sidebars -------------------------------------------------------------- */
+
+div.sidebar {
+ margin: 0 0 0.5em 1em;
+ border: 1px solid #ddb;
+ padding: 7px 7px 0 7px;
+ background-color: #ffe;
+ width: 40%;
+ float: right;
+}
+
+p.sidebar-title {
+ font-weight: bold;
+}
+
+/* -- topics ---------------------------------------------------------------- */
+
+div.topic {
+ border: 1px solid #ccc;
+ padding: 7px 7px 0 7px;
+ margin: 10px 0 10px 0;
+}
+
+p.topic-title {
+ font-size: 1.1em;
+ font-weight: bold;
+ margin-top: 10px;
+}
+
+/* -- admonitions ----------------------------------------------------------- */
+
+div.admonition {
+ margin-top: 10px;
+ margin-bottom: 10px;
+ padding: 7px;
+}
+
+div.admonition dt {
+ font-weight: bold;
+}
+
+div.admonition dl {
+ margin-bottom: 0;
+}
+
+p.admonition-title {
+ margin: 0px 10px 5px 0px;
+ font-weight: bold;
+}
+
+div.body p.centered {
+ text-align: center;
+ margin-top: 25px;
+}
+
+/* -- tables ---------------------------------------------------------------- */
+
+table.docutils {
+ border: 0;
+ border-collapse: collapse;
+}
+
+table.align-center {
+ margin-left: auto;
+ margin-right: auto;
+}
+
+table caption span.caption-number {
+ font-style: italic;
+}
+
+table caption span.caption-text {
+}
+
+table.docutils td, table.docutils th {
+ padding: 1px 8px 1px 5px;
+ border-top: 0;
+ border-left: 0;
+ border-right: 0;
+ border-bottom: 1px solid #aaa;
+}
+
+table.footnote td, table.footnote th {
+ border: 0 !important;
+}
+
+th {
+ text-align: left;
+ padding-right: 5px;
+}
+
+table.citation {
+ border-left: solid 1px gray;
+ margin-left: 1px;
+}
+
+table.citation td {
+ border-bottom: none;
+}
+
+/* -- figures --------------------------------------------------------------- */
+
+div.figure {
+ margin: 0.5em;
+ padding: 0.5em;
+}
+
+div.figure p.caption {
+ padding: 0.3em;
+}
+
+div.figure p.caption span.caption-number {
+ font-style: italic;
+}
+
+div.figure p.caption span.caption-text {
+}
+
+/* -- field list styles ----------------------------------------------------- */
+
+table.field-list td, table.field-list th {
+ border: 0 !important;
+}
+
+.field-list ul {
+ margin: 0;
+ padding-left: 1em;
+}
+
+.field-list p {
+ margin: 0;
+}
+
+.field-name {
+ -moz-hyphens: manual;
+ -ms-hyphens: manual;
+ -webkit-hyphens: manual;
+ hyphens: manual;
+}
+
+/* -- hlist styles ---------------------------------------------------------- */
+
+table.hlist td {
+ vertical-align: top;
+}
+
+
+/* -- other body styles ----------------------------------------------------- */
+
+ol.arabic {
+ list-style: decimal;
+}
+
+ol.loweralpha {
+ list-style: lower-alpha;
+}
+
+ol.upperalpha {
+ list-style: upper-alpha;
+}
+
+ol.lowerroman {
+ list-style: lower-roman;
+}
+
+ol.upperroman {
+ list-style: upper-roman;
+}
+
+dl {
+ margin-bottom: 15px;
+}
+
+dd p {
+ margin-top: 0px;
+}
+
+dd ul, dd table {
+ margin-bottom: 10px;
+}
+
+dd {
+ margin-top: 3px;
+ margin-bottom: 10px;
+ margin-left: 30px;
+}
+
+dt:target, span.highlighted {
+ background-color: #fbe54e;
+}
+
+rect.highlighted {
+ fill: #fbe54e;
+}
+
+dl.glossary dt {
+ font-weight: bold;
+ font-size: 1.1em;
+}
+
+.optional {
+ font-size: 1.3em;
+}
+
+.sig-paren {
+ font-size: larger;
+}
+
+.versionmodified {
+ font-style: italic;
+}
+
+.system-message {
+ background-color: #fda;
+ padding: 5px;
+ border: 3px solid red;
+}
+
+.footnote:target {
+ background-color: #ffa;
+}
+
+.line-block {
+ display: block;
+ margin-top: 1em;
+ margin-bottom: 1em;
+}
+
+.line-block .line-block {
+ margin-top: 0;
+ margin-bottom: 0;
+ margin-left: 1.5em;
+}
+
+.guilabel, .menuselection {
+ font-family: sans-serif;
+}
+
+.accelerator {
+ text-decoration: underline;
+}
+
+.classifier {
+ font-style: oblique;
+}
+
+abbr, acronym {
+ border-bottom: dotted 1px;
+ cursor: help;
+}
+
+/* -- code displays --------------------------------------------------------- */
+
+pre {
+ overflow: auto;
+ overflow-y: hidden; /* fixes display issues on Chrome browsers */
+}
+
+span.pre {
+ -moz-hyphens: none;
+ -ms-hyphens: none;
+ -webkit-hyphens: none;
+ hyphens: none;
+}
+
+td.linenos pre {
+ padding: 5px 0px;
+ border: 0;
+ background-color: transparent;
+ color: #aaa;
+}
+
+table.highlighttable {
+ margin-left: 0.5em;
+}
+
+table.highlighttable td {
+ padding: 0 0.5em 0 0.5em;
+}
+
+div.code-block-caption {
+ padding: 2px 5px;
+ font-size: small;
+}
+
+div.code-block-caption code {
+ background-color: transparent;
+}
+
+div.code-block-caption + div > div.highlight > pre {
+ margin-top: 0;
+}
+
+div.code-block-caption span.caption-number {
+ padding: 0.1em 0.3em;
+ font-style: italic;
+}
+
+div.code-block-caption span.caption-text {
+}
+
+div.literal-block-wrapper {
+ padding: 1em 1em 0;
+}
+
+div.literal-block-wrapper div.highlight {
+ margin: 0;
+}
+
+code.descname {
+ background-color: transparent;
+ font-weight: bold;
+ font-size: 1.2em;
+}
+
+code.descclassname {
+ background-color: transparent;
+}
+
+code.xref, a code {
+ background-color: transparent;
+ font-weight: bold;
+}
+
+h1 code, h2 code, h3 code, h4 code, h5 code, h6 code {
+ background-color: transparent;
+}
+
+.viewcode-link {
+ float: right;
+}
+
+.viewcode-back {
+ float: right;
+ font-family: sans-serif;
+}
+
+div.viewcode-block:target {
+ margin: -1px -10px;
+ padding: 0 10px;
+}
+
+/* -- math display ---------------------------------------------------------- */
+
+img.math {
+ vertical-align: middle;
+}
+
+div.body div.math p {
+ text-align: center;
+}
+
+span.eqno {
+ float: right;
+}
+
+span.eqno a.headerlink {
+ position: relative;
+ left: 0px;
+ z-index: 1;
+}
+
+div.math:hover a.headerlink {
+ visibility: visible;
+}
+
+/* -- printout stylesheet --------------------------------------------------- */
+
+@media print {
+ div.document,
+ div.documentwrapper,
+ div.bodywrapper {
+ margin: 0 !important;
+ width: 100%;
+ }
+
+ div.sphinxsidebar,
+ div.related,
+ div.footer,
+ #top-link {
+ display: none;
+ }
+}
\ No newline at end of file
diff --git a/docs/html/_static/comment-bright.png b/docs/html/_static/comment-bright.png
new file mode 100644
index 0000000..15e27ed
--- /dev/null
+++ b/docs/html/_static/comment-bright.png
Binary files differ
diff --git a/docs/html/_static/comment-close.png b/docs/html/_static/comment-close.png
new file mode 100644
index 0000000..4d91bcf
--- /dev/null
+++ b/docs/html/_static/comment-close.png
Binary files differ
diff --git a/docs/html/_static/comment.png b/docs/html/_static/comment.png
new file mode 100644
index 0000000..dfbc0cb
--- /dev/null
+++ b/docs/html/_static/comment.png
Binary files differ
diff --git a/docs/html/_static/custom.css b/docs/html/_static/custom.css
new file mode 100644
index 0000000..2a924f1
--- /dev/null
+++ b/docs/html/_static/custom.css
@@ -0,0 +1 @@
+/* This file intentionally left blank. */
diff --git a/docs/html/_static/doctools.js b/docs/html/_static/doctools.js
new file mode 100644
index 0000000..344db17
--- /dev/null
+++ b/docs/html/_static/doctools.js
@@ -0,0 +1,315 @@
+/*
+ * doctools.js
+ * ~~~~~~~~~~~
+ *
+ * Sphinx JavaScript utilities for all documentation.
+ *
+ * :copyright: Copyright 2007-2019 by the Sphinx team, see AUTHORS.
+ * :license: BSD, see LICENSE for details.
+ *
+ */
+
+/**
+ * select a different prefix for underscore
+ */
+$u = _.noConflict();
+
+/**
+ * make the code below compatible with browsers without
+ * an installed firebug like debugger
+if (!window.console || !console.firebug) {
+ var names = ["log", "debug", "info", "warn", "error", "assert", "dir",
+ "dirxml", "group", "groupEnd", "time", "timeEnd", "count", "trace",
+ "profile", "profileEnd"];
+ window.console = {};
+ for (var i = 0; i < names.length; ++i)
+ window.console[names[i]] = function() {};
+}
+ */
+
+/**
+ * small helper function to urldecode strings
+ */
+jQuery.urldecode = function(x) {
+ return decodeURIComponent(x).replace(/\+/g, ' ');
+};
+
+/**
+ * small helper function to urlencode strings
+ */
+jQuery.urlencode = encodeURIComponent;
+
+/**
+ * This function returns the parsed url parameters of the
+ * current request. Multiple values per key are supported,
+ * it will always return arrays of strings for the value parts.
+ */
+jQuery.getQueryParameters = function(s) {
+ if (typeof s === 'undefined')
+ s = document.location.search;
+ var parts = s.substr(s.indexOf('?') + 1).split('&');
+ var result = {};
+ for (var i = 0; i < parts.length; i++) {
+ var tmp = parts[i].split('=', 2);
+ var key = jQuery.urldecode(tmp[0]);
+ var value = jQuery.urldecode(tmp[1]);
+ if (key in result)
+ result[key].push(value);
+ else
+ result[key] = [value];
+ }
+ return result;
+};
+
+/**
+ * highlight a given string on a jquery object by wrapping it in
+ * span elements with the given class name.
+ */
+jQuery.fn.highlightText = function(text, className) {
+ function highlight(node, addItems) {
+ if (node.nodeType === 3) {
+ var val = node.nodeValue;
+ var pos = val.toLowerCase().indexOf(text);
+ if (pos >= 0 &&
+ !jQuery(node.parentNode).hasClass(className) &&
+ !jQuery(node.parentNode).hasClass("nohighlight")) {
+ var span;
+ var isInSVG = jQuery(node).closest("body, svg, foreignObject").is("svg");
+ if (isInSVG) {
+ span = document.createElementNS("http://www.w3.org/2000/svg", "tspan");
+ } else {
+ span = document.createElement("span");
+ span.className = className;
+ }
+ span.appendChild(document.createTextNode(val.substr(pos, text.length)));
+ node.parentNode.insertBefore(span, node.parentNode.insertBefore(
+ document.createTextNode(val.substr(pos + text.length)),
+ node.nextSibling));
+ node.nodeValue = val.substr(0, pos);
+ if (isInSVG) {
+ var bbox = span.getBBox();
+ var rect = document.createElementNS("http://www.w3.org/2000/svg", "rect");
+ rect.x.baseVal.value = bbox.x;
+ rect.y.baseVal.value = bbox.y;
+ rect.width.baseVal.value = bbox.width;
+ rect.height.baseVal.value = bbox.height;
+ rect.setAttribute('class', className);
+ var parentOfText = node.parentNode.parentNode;
+ addItems.push({
+ "parent": node.parentNode,
+ "target": rect});
+ }
+ }
+ }
+ else if (!jQuery(node).is("button, select, textarea")) {
+ jQuery.each(node.childNodes, function() {
+ highlight(this, addItems);
+ });
+ }
+ }
+ var addItems = [];
+ var result = this.each(function() {
+ highlight(this, addItems);
+ });
+ for (var i = 0; i < addItems.length; ++i) {
+ jQuery(addItems[i].parent).before(addItems[i].target);
+ }
+ return result;
+};
+
+/*
+ * backward compatibility for jQuery.browser
+ * This will be supported until firefox bug is fixed.
+ */
+if (!jQuery.browser) {
+ jQuery.uaMatch = function(ua) {
+ ua = ua.toLowerCase();
+
+ var match = /(chrome)[ \/]([\w.]+)/.exec(ua) ||
+ /(webkit)[ \/]([\w.]+)/.exec(ua) ||
+ /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) ||
+ /(msie) ([\w.]+)/.exec(ua) ||
+ ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) ||
+ [];
+
+ return {
+ browser: match[ 1 ] || "",
+ version: match[ 2 ] || "0"
+ };
+ };
+ jQuery.browser = {};
+ jQuery.browser[jQuery.uaMatch(navigator.userAgent).browser] = true;
+}
+
+/**
+ * Small JavaScript module for the documentation.
+ */
+var Documentation = {
+
+ init : function() {
+ this.fixFirefoxAnchorBug();
+ this.highlightSearchWords();
+ this.initIndexTable();
+ if (DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) {
+ this.initOnKeyListeners();
+ }
+ },
+
+ /**
+ * i18n support
+ */
+ TRANSLATIONS : {},
+ PLURAL_EXPR : function(n) { return n === 1 ? 0 : 1; },
+ LOCALE : 'unknown',
+
+ // gettext and ngettext don't access this so that the functions
+ // can safely bound to a different name (_ = Documentation.gettext)
+ gettext : function(string) {
+ var translated = Documentation.TRANSLATIONS[string];
+ if (typeof translated === 'undefined')
+ return string;
+ return (typeof translated === 'string') ? translated : translated[0];
+ },
+
+ ngettext : function(singular, plural, n) {
+ var translated = Documentation.TRANSLATIONS[singular];
+ if (typeof translated === 'undefined')
+ return (n == 1) ? singular : plural;
+ return translated[Documentation.PLURALEXPR(n)];
+ },
+
+ addTranslations : function(catalog) {
+ for (var key in catalog.messages)
+ this.TRANSLATIONS[key] = catalog.messages[key];
+ this.PLURAL_EXPR = new Function('n', 'return +(' + catalog.plural_expr + ')');
+ this.LOCALE = catalog.locale;
+ },
+
+ /**
+ * add context elements like header anchor links
+ */
+ addContextElements : function() {
+ $('div[id] > :header:first').each(function() {
+ $('<a class="headerlink">\u00B6</a>').
+ attr('href', '#' + this.id).
+ attr('title', _('Permalink to this headline')).
+ appendTo(this);
+ });
+ $('dt[id]').each(function() {
+ $('<a class="headerlink">\u00B6</a>').
+ attr('href', '#' + this.id).
+ attr('title', _('Permalink to this definition')).
+ appendTo(this);
+ });
+ },
+
+ /**
+ * workaround a firefox stupidity
+ * see: https://bugzilla.mozilla.org/show_bug.cgi?id=645075
+ */
+ fixFirefoxAnchorBug : function() {
+ if (document.location.hash && $.browser.mozilla)
+ window.setTimeout(function() {
+ document.location.href += '';
+ }, 10);
+ },
+
+ /**
+ * highlight the search words provided in the url in the text
+ */
+ highlightSearchWords : function() {
+ var params = $.getQueryParameters();
+ var terms = (params.highlight) ? params.highlight[0].split(/\s+/) : [];
+ if (terms.length) {
+ var body = $('div.body');
+ if (!body.length) {
+ body = $('body');
+ }
+ window.setTimeout(function() {
+ $.each(terms, function() {
+ body.highlightText(this.toLowerCase(), 'highlighted');
+ });
+ }, 10);
+ $('<p class="highlight-link"><a href="javascript:Documentation.' +
+ 'hideSearchWords()">' + _('Hide Search Matches') + '</a></p>')
+ .appendTo($('#searchbox'));
+ }
+ },
+
+ /**
+ * init the domain index toggle buttons
+ */
+ initIndexTable : function() {
+ var togglers = $('img.toggler').click(function() {
+ var src = $(this).attr('src');
+ var idnum = $(this).attr('id').substr(7);
+ $('tr.cg-' + idnum).toggle();
+ if (src.substr(-9) === 'minus.png')
+ $(this).attr('src', src.substr(0, src.length-9) + 'plus.png');
+ else
+ $(this).attr('src', src.substr(0, src.length-8) + 'minus.png');
+ }).css('display', '');
+ if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) {
+ togglers.click();
+ }
+ },
+
+ /**
+ * helper function to hide the search marks again
+ */
+ hideSearchWords : function() {
+ $('#searchbox .highlight-link').fadeOut(300);
+ $('span.highlighted').removeClass('highlighted');
+ },
+
+ /**
+ * make the url absolute
+ */
+ makeURL : function(relativeURL) {
+ return DOCUMENTATION_OPTIONS.URL_ROOT + '/' + relativeURL;
+ },
+
+ /**
+ * get the current relative url
+ */
+ getCurrentURL : function() {
+ var path = document.location.pathname;
+ var parts = path.split(/\//);
+ $.each(DOCUMENTATION_OPTIONS.URL_ROOT.split(/\//), function() {
+ if (this === '..')
+ parts.pop();
+ });
+ var url = parts.join('/');
+ return path.substring(url.lastIndexOf('/') + 1, path.length - 1);
+ },
+
+ initOnKeyListeners: function() {
+ $(document).keyup(function(event) {
+ var activeElementType = document.activeElement.tagName;
+ // don't navigate when in search box or textarea
+ if (activeElementType !== 'TEXTAREA' && activeElementType !== 'INPUT' && activeElementType !== 'SELECT') {
+ switch (event.keyCode) {
+ case 37: // left
+ var prevHref = $('link[rel="prev"]').prop('href');
+ if (prevHref) {
+ window.location.href = prevHref;
+ return false;
+ }
+ case 39: // right
+ var nextHref = $('link[rel="next"]').prop('href');
+ if (nextHref) {
+ window.location.href = nextHref;
+ return false;
+ }
+ }
+ }
+ });
+ }
+};
+
+// quick alias for translations
+_ = Documentation.gettext;
+
+$(document).ready(function() {
+ Documentation.init();
+});
diff --git a/docs/html/_static/documentation_options.js b/docs/html/_static/documentation_options.js
new file mode 100644
index 0000000..b2f4f64
--- /dev/null
+++ b/docs/html/_static/documentation_options.js
@@ -0,0 +1,10 @@
+var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: document.getElementById("documentation_options").getAttribute('data-url_root'),
+ VERSION: '1.0 beta3',
+ LANGUAGE: 'None',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true,
+ SOURCELINK_SUFFIX: '.txt',
+ NAVIGATION_WITH_KEYS: false,
+};
\ No newline at end of file
diff --git a/docs/html/_static/down-pressed.png b/docs/html/_static/down-pressed.png
new file mode 100644
index 0000000..5756c8c
--- /dev/null
+++ b/docs/html/_static/down-pressed.png
Binary files differ
diff --git a/docs/html/_static/down.png b/docs/html/_static/down.png
new file mode 100644
index 0000000..1b3bdad
--- /dev/null
+++ b/docs/html/_static/down.png
Binary files differ
diff --git a/docs/html/_static/file.png b/docs/html/_static/file.png
new file mode 100644
index 0000000..a858a41
--- /dev/null
+++ b/docs/html/_static/file.png
Binary files differ
diff --git a/docs/html/_static/jquery-3.2.1.js b/docs/html/_static/jquery-3.2.1.js
new file mode 100644
index 0000000..d2d8ca4
--- /dev/null
+++ b/docs/html/_static/jquery-3.2.1.js
@@ -0,0 +1,10253 @@
+/*!
+ * jQuery JavaScript Library v3.2.1
+ * https://jquery.com/
+ *
+ * Includes Sizzle.js
+ * https://sizzlejs.com/
+ *
+ * Copyright JS Foundation and other contributors
+ * Released under the MIT license
+ * https://jquery.org/license
+ *
+ * Date: 2017-03-20T18:59Z
+ */
+( function( global, factory ) {
+
+ "use strict";
+
+ if ( typeof module === "object" && typeof module.exports === "object" ) {
+
+ // For CommonJS and CommonJS-like environments where a proper `window`
+ // is present, execute the factory and get jQuery.
+ // For environments that do not have a `window` with a `document`
+ // (such as Node.js), expose a factory as module.exports.
+ // This accentuates the need for the creation of a real `window`.
+ // e.g. var jQuery = require("jquery")(window);
+ // See ticket #14549 for more info.
+ module.exports = global.document ?
+ factory( global, true ) :
+ function( w ) {
+ if ( !w.document ) {
+ throw new Error( "jQuery requires a window with a document" );
+ }
+ return factory( w );
+ };
+ } else {
+ factory( global );
+ }
+
+// Pass this if window is not defined yet
+} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
+
+// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
+// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
+// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
+// enough that all such attempts are guarded in a try block.
+"use strict";
+
+var arr = [];
+
+var document = window.document;
+
+var getProto = Object.getPrototypeOf;
+
+var slice = arr.slice;
+
+var concat = arr.concat;
+
+var push = arr.push;
+
+var indexOf = arr.indexOf;
+
+var class2type = {};
+
+var toString = class2type.toString;
+
+var hasOwn = class2type.hasOwnProperty;
+
+var fnToString = hasOwn.toString;
+
+var ObjectFunctionString = fnToString.call( Object );
+
+var support = {};
+
+
+
+ function DOMEval( code, doc ) {
+ doc = doc || document;
+
+ var script = doc.createElement( "script" );
+
+ script.text = code;
+ doc.head.appendChild( script ).parentNode.removeChild( script );
+ }
+/* global Symbol */
+// Defining this global in .eslintrc.json would create a danger of using the global
+// unguarded in another place, it seems safer to define global only for this module
+
+
+
+var
+ version = "3.2.1",
+
+ // Define a local copy of jQuery
+ jQuery = function( selector, context ) {
+
+ // The jQuery object is actually just the init constructor 'enhanced'
+ // Need init if jQuery is called (just allow error to be thrown if not included)
+ return new jQuery.fn.init( selector, context );
+ },
+
+ // Support: Android <=4.0 only
+ // Make sure we trim BOM and NBSP
+ rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
+
+ // Matches dashed string for camelizing
+ rmsPrefix = /^-ms-/,
+ rdashAlpha = /-([a-z])/g,
+
+ // Used by jQuery.camelCase as callback to replace()
+ fcamelCase = function( all, letter ) {
+ return letter.toUpperCase();
+ };
+
+jQuery.fn = jQuery.prototype = {
+
+ // The current version of jQuery being used
+ jquery: version,
+
+ constructor: jQuery,
+
+ // The default length of a jQuery object is 0
+ length: 0,
+
+ toArray: function() {
+ return slice.call( this );
+ },
+
+ // Get the Nth element in the matched element set OR
+ // Get the whole matched element set as a clean array
+ get: function( num ) {
+
+ // Return all the elements in a clean array
+ if ( num == null ) {
+ return slice.call( this );
+ }
+
+ // Return just the one element from the set
+ return num < 0 ? this[ num + this.length ] : this[ num ];
+ },
+
+ // Take an array of elements and push it onto the stack
+ // (returning the new matched element set)
+ pushStack: function( elems ) {
+
+ // Build a new jQuery matched element set
+ var ret = jQuery.merge( this.constructor(), elems );
+
+ // Add the old object onto the stack (as a reference)
+ ret.prevObject = this;
+
+ // Return the newly-formed element set
+ return ret;
+ },
+
+ // Execute a callback for every element in the matched set.
+ each: function( callback ) {
+ return jQuery.each( this, callback );
+ },
+
+ map: function( callback ) {
+ return this.pushStack( jQuery.map( this, function( elem, i ) {
+ return callback.call( elem, i, elem );
+ } ) );
+ },
+
+ slice: function() {
+ return this.pushStack( slice.apply( this, arguments ) );
+ },
+
+ first: function() {
+ return this.eq( 0 );
+ },
+
+ last: function() {
+ return this.eq( -1 );
+ },
+
+ eq: function( i ) {
+ var len = this.length,
+ j = +i + ( i < 0 ? len : 0 );
+ return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
+ },
+
+ end: function() {
+ return this.prevObject || this.constructor();
+ },
+
+ // For internal use only.
+ // Behaves like an Array's method, not like a jQuery method.
+ push: push,
+ sort: arr.sort,
+ splice: arr.splice
+};
+
+jQuery.extend = jQuery.fn.extend = function() {
+ var options, name, src, copy, copyIsArray, clone,
+ target = arguments[ 0 ] || {},
+ i = 1,
+ length = arguments.length,
+ deep = false;
+
+ // Handle a deep copy situation
+ if ( typeof target === "boolean" ) {
+ deep = target;
+
+ // Skip the boolean and the target
+ target = arguments[ i ] || {};
+ i++;
+ }
+
+ // Handle case when target is a string or something (possible in deep copy)
+ if ( typeof target !== "object" && !jQuery.isFunction( target ) ) {
+ target = {};
+ }
+
+ // Extend jQuery itself if only one argument is passed
+ if ( i === length ) {
+ target = this;
+ i--;
+ }
+
+ for ( ; i < length; i++ ) {
+
+ // Only deal with non-null/undefined values
+ if ( ( options = arguments[ i ] ) != null ) {
+
+ // Extend the base object
+ for ( name in options ) {
+ src = target[ name ];
+ copy = options[ name ];
+
+ // Prevent never-ending loop
+ if ( target === copy ) {
+ continue;
+ }
+
+ // Recurse if we're merging plain objects or arrays
+ if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
+ ( copyIsArray = Array.isArray( copy ) ) ) ) {
+
+ if ( copyIsArray ) {
+ copyIsArray = false;
+ clone = src && Array.isArray( src ) ? src : [];
+
+ } else {
+ clone = src && jQuery.isPlainObject( src ) ? src : {};
+ }
+
+ // Never move original objects, clone them
+ target[ name ] = jQuery.extend( deep, clone, copy );
+
+ // Don't bring in undefined values
+ } else if ( copy !== undefined ) {
+ target[ name ] = copy;
+ }
+ }
+ }
+ }
+
+ // Return the modified object
+ return target;
+};
+
+jQuery.extend( {
+
+ // Unique for each copy of jQuery on the page
+ expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
+
+ // Assume jQuery is ready without the ready module
+ isReady: true,
+
+ error: function( msg ) {
+ throw new Error( msg );
+ },
+
+ noop: function() {},
+
+ isFunction: function( obj ) {
+ return jQuery.type( obj ) === "function";
+ },
+
+ isWindow: function( obj ) {
+ return obj != null && obj === obj.window;
+ },
+
+ isNumeric: function( obj ) {
+
+ // As of jQuery 3.0, isNumeric is limited to
+ // strings and numbers (primitives or objects)
+ // that can be coerced to finite numbers (gh-2662)
+ var type = jQuery.type( obj );
+ return ( type === "number" || type === "string" ) &&
+
+ // parseFloat NaNs numeric-cast false positives ("")
+ // ...but misinterprets leading-number strings, particularly hex literals ("0x...")
+ // subtraction forces infinities to NaN
+ !isNaN( obj - parseFloat( obj ) );
+ },
+
+ isPlainObject: function( obj ) {
+ var proto, Ctor;
+
+ // Detect obvious negatives
+ // Use toString instead of jQuery.type to catch host objects
+ if ( !obj || toString.call( obj ) !== "[object Object]" ) {
+ return false;
+ }
+
+ proto = getProto( obj );
+
+ // Objects with no prototype (e.g., `Object.create( null )`) are plain
+ if ( !proto ) {
+ return true;
+ }
+
+ // Objects with prototype are plain iff they were constructed by a global Object function
+ Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
+ return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
+ },
+
+ isEmptyObject: function( obj ) {
+
+ /* eslint-disable no-unused-vars */
+ // See https://github.com/eslint/eslint/issues/6125
+ var name;
+
+ for ( name in obj ) {
+ return false;
+ }
+ return true;
+ },
+
+ type: function( obj ) {
+ if ( obj == null ) {
+ return obj + "";
+ }
+
+ // Support: Android <=2.3 only (functionish RegExp)
+ return typeof obj === "object" || typeof obj === "function" ?
+ class2type[ toString.call( obj ) ] || "object" :
+ typeof obj;
+ },
+
+ // Evaluates a script in a global context
+ globalEval: function( code ) {
+ DOMEval( code );
+ },
+
+ // Convert dashed to camelCase; used by the css and data modules
+ // Support: IE <=9 - 11, Edge 12 - 13
+ // Microsoft forgot to hump their vendor prefix (#9572)
+ camelCase: function( string ) {
+ return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
+ },
+
+ each: function( obj, callback ) {
+ var length, i = 0;
+
+ if ( isArrayLike( obj ) ) {
+ length = obj.length;
+ for ( ; i < length; i++ ) {
+ if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
+ break;
+ }
+ }
+ } else {
+ for ( i in obj ) {
+ if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
+ break;
+ }
+ }
+ }
+
+ return obj;
+ },
+
+ // Support: Android <=4.0 only
+ trim: function( text ) {
+ return text == null ?
+ "" :
+ ( text + "" ).replace( rtrim, "" );
+ },
+
+ // results is for internal usage only
+ makeArray: function( arr, results ) {
+ var ret = results || [];
+
+ if ( arr != null ) {
+ if ( isArrayLike( Object( arr ) ) ) {
+ jQuery.merge( ret,
+ typeof arr === "string" ?
+ [ arr ] : arr
+ );
+ } else {
+ push.call( ret, arr );
+ }
+ }
+
+ return ret;
+ },
+
+ inArray: function( elem, arr, i ) {
+ return arr == null ? -1 : indexOf.call( arr, elem, i );
+ },
+
+ // Support: Android <=4.0 only, PhantomJS 1 only
+ // push.apply(_, arraylike) throws on ancient WebKit
+ merge: function( first, second ) {
+ var len = +second.length,
+ j = 0,
+ i = first.length;
+
+ for ( ; j < len; j++ ) {
+ first[ i++ ] = second[ j ];
+ }
+
+ first.length = i;
+
+ return first;
+ },
+
+ grep: function( elems, callback, invert ) {
+ var callbackInverse,
+ matches = [],
+ i = 0,
+ length = elems.length,
+ callbackExpect = !invert;
+
+ // Go through the array, only saving the items
+ // that pass the validator function
+ for ( ; i < length; i++ ) {
+ callbackInverse = !callback( elems[ i ], i );
+ if ( callbackInverse !== callbackExpect ) {
+ matches.push( elems[ i ] );
+ }
+ }
+
+ return matches;
+ },
+
+ // arg is for internal usage only
+ map: function( elems, callback, arg ) {
+ var length, value,
+ i = 0,
+ ret = [];
+
+ // Go through the array, translating each of the items to their new values
+ if ( isArrayLike( elems ) ) {
+ length = elems.length;
+ for ( ; i < length; i++ ) {
+ value = callback( elems[ i ], i, arg );
+
+ if ( value != null ) {
+ ret.push( value );
+ }
+ }
+
+ // Go through every key on the object,
+ } else {
+ for ( i in elems ) {
+ value = callback( elems[ i ], i, arg );
+
+ if ( value != null ) {
+ ret.push( value );
+ }
+ }
+ }
+
+ // Flatten any nested arrays
+ return concat.apply( [], ret );
+ },
+
+ // A global GUID counter for objects
+ guid: 1,
+
+ // Bind a function to a context, optionally partially applying any
+ // arguments.
+ proxy: function( fn, context ) {
+ var tmp, args, proxy;
+
+ if ( typeof context === "string" ) {
+ tmp = fn[ context ];
+ context = fn;
+ fn = tmp;
+ }
+
+ // Quick check to determine if target is callable, in the spec
+ // this throws a TypeError, but we will just return undefined.
+ if ( !jQuery.isFunction( fn ) ) {
+ return undefined;
+ }
+
+ // Simulated bind
+ args = slice.call( arguments, 2 );
+ proxy = function() {
+ return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
+ };
+
+ // Set the guid of unique handler to the same of original handler, so it can be removed
+ proxy.guid = fn.guid = fn.guid || jQuery.guid++;
+
+ return proxy;
+ },
+
+ now: Date.now,
+
+ // jQuery.support is not used in Core but other projects attach their
+ // properties to it so it needs to exist.
+ support: support
+} );
+
+if ( typeof Symbol === "function" ) {
+ jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
+}
+
+// Populate the class2type map
+jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
+function( i, name ) {
+ class2type[ "[object " + name + "]" ] = name.toLowerCase();
+} );
+
+function isArrayLike( obj ) {
+
+ // Support: real iOS 8.2 only (not reproducible in simulator)
+ // `in` check used to prevent JIT error (gh-2145)
+ // hasOwn isn't used here due to false negatives
+ // regarding Nodelist length in IE
+ var length = !!obj && "length" in obj && obj.length,
+ type = jQuery.type( obj );
+
+ if ( type === "function" || jQuery.isWindow( obj ) ) {
+ return false;
+ }
+
+ return type === "array" || length === 0 ||
+ typeof length === "number" && length > 0 && ( length - 1 ) in obj;
+}
+var Sizzle =
+/*!
+ * Sizzle CSS Selector Engine v2.3.3
+ * https://sizzlejs.com/
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license
+ * http://jquery.org/license
+ *
+ * Date: 2016-08-08
+ */
+(function( window ) {
+
+var i,
+ support,
+ Expr,
+ getText,
+ isXML,
+ tokenize,
+ compile,
+ select,
+ outermostContext,
+ sortInput,
+ hasDuplicate,
+
+ // Local document vars
+ setDocument,
+ document,
+ docElem,
+ documentIsHTML,
+ rbuggyQSA,
+ rbuggyMatches,
+ matches,
+ contains,
+
+ // Instance-specific data
+ expando = "sizzle" + 1 * new Date(),
+ preferredDoc = window.document,
+ dirruns = 0,
+ done = 0,
+ classCache = createCache(),
+ tokenCache = createCache(),
+ compilerCache = createCache(),
+ sortOrder = function( a, b ) {
+ if ( a === b ) {
+ hasDuplicate = true;
+ }
+ return 0;
+ },
+
+ // Instance methods
+ hasOwn = ({}).hasOwnProperty,
+ arr = [],
+ pop = arr.pop,
+ push_native = arr.push,
+ push = arr.push,
+ slice = arr.slice,
+ // Use a stripped-down indexOf as it's faster than native
+ // https://jsperf.com/thor-indexof-vs-for/5
+ indexOf = function( list, elem ) {
+ var i = 0,
+ len = list.length;
+ for ( ; i < len; i++ ) {
+ if ( list[i] === elem ) {
+ return i;
+ }
+ }
+ return -1;
+ },
+
+ booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
+
+ // Regular expressions
+
+ // http://www.w3.org/TR/css3-selectors/#whitespace
+ whitespace = "[\\x20\\t\\r\\n\\f]",
+
+ // http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
+ identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+",
+
+ // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
+ attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
+ // Operator (capture 2)
+ "*([*^$|!~]?=)" + whitespace +
+ // "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
+ "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +
+ "*\\]",
+
+ pseudos = ":(" + identifier + ")(?:\\((" +
+ // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
+ // 1. quoted (capture 3; capture 4 or capture 5)
+ "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
+ // 2. simple (capture 6)
+ "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
+ // 3. anything else (capture 2)
+ ".*" +
+ ")\\)|)",
+
+ // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
+ rwhitespace = new RegExp( whitespace + "+", "g" ),
+ rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
+
+ rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
+ rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),
+
+ rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),
+
+ rpseudo = new RegExp( pseudos ),
+ ridentifier = new RegExp( "^" + identifier + "$" ),
+
+ matchExpr = {
+ "ID": new RegExp( "^#(" + identifier + ")" ),
+ "CLASS": new RegExp( "^\\.(" + identifier + ")" ),
+ "TAG": new RegExp( "^(" + identifier + "|[*])" ),
+ "ATTR": new RegExp( "^" + attributes ),
+ "PSEUDO": new RegExp( "^" + pseudos ),
+ "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
+ "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
+ "*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
+ "bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
+ // For use in libraries implementing .is()
+ // We use this for POS matching in `select`
+ "needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
+ whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
+ },
+
+ rinputs = /^(?:input|select|textarea|button)$/i,
+ rheader = /^h\d$/i,
+
+ rnative = /^[^{]+\{\s*\[native \w/,
+
+ // Easily-parseable/retrievable ID or TAG or CLASS selectors
+ rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
+
+ rsibling = /[+~]/,
+
+ // CSS escapes
+ // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
+ runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
+ funescape = function( _, escaped, escapedWhitespace ) {
+ var high = "0x" + escaped - 0x10000;
+ // NaN means non-codepoint
+ // Support: Firefox<24
+ // Workaround erroneous numeric interpretation of +"0x"
+ return high !== high || escapedWhitespace ?
+ escaped :
+ high < 0 ?
+ // BMP codepoint
+ String.fromCharCode( high + 0x10000 ) :
+ // Supplemental Plane codepoint (surrogate pair)
+ String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
+ },
+
+ // CSS string/identifier serialization
+ // https://drafts.csswg.org/cssom/#common-serializing-idioms
+ rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
+ fcssescape = function( ch, asCodePoint ) {
+ if ( asCodePoint ) {
+
+ // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
+ if ( ch === "\0" ) {
+ return "\uFFFD";
+ }
+
+ // Control characters and (dependent upon position) numbers get escaped as code points
+ return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
+ }
+
+ // Other potentially-special ASCII characters get backslash-escaped
+ return "\\" + ch;
+ },
+
+ // Used for iframes
+ // See setDocument()
+ // Removing the function wrapper causes a "Permission Denied"
+ // error in IE
+ unloadHandler = function() {
+ setDocument();
+ },
+
+ disabledAncestor = addCombinator(
+ function( elem ) {
+ return elem.disabled === true && ("form" in elem || "label" in elem);
+ },
+ { dir: "parentNode", next: "legend" }
+ );
+
+// Optimize for push.apply( _, NodeList )
+try {
+ push.apply(
+ (arr = slice.call( preferredDoc.childNodes )),
+ preferredDoc.childNodes
+ );
+ // Support: Android<4.0
+ // Detect silently failing push.apply
+ arr[ preferredDoc.childNodes.length ].nodeType;
+} catch ( e ) {
+ push = { apply: arr.length ?
+
+ // Leverage slice if possible
+ function( target, els ) {
+ push_native.apply( target, slice.call(els) );
+ } :
+
+ // Support: IE<9
+ // Otherwise append directly
+ function( target, els ) {
+ var j = target.length,
+ i = 0;
+ // Can't trust NodeList.length
+ while ( (target[j++] = els[i++]) ) {}
+ target.length = j - 1;
+ }
+ };
+}
+
+function Sizzle( selector, context, results, seed ) {
+ var m, i, elem, nid, match, groups, newSelector,
+ newContext = context && context.ownerDocument,
+
+ // nodeType defaults to 9, since context defaults to document
+ nodeType = context ? context.nodeType : 9;
+
+ results = results || [];
+
+ // Return early from calls with invalid selector or context
+ if ( typeof selector !== "string" || !selector ||
+ nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
+
+ return results;
+ }
+
+ // Try to shortcut find operations (as opposed to filters) in HTML documents
+ if ( !seed ) {
+
+ if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
+ setDocument( context );
+ }
+ context = context || document;
+
+ if ( documentIsHTML ) {
+
+ // If the selector is sufficiently simple, try using a "get*By*" DOM method
+ // (excepting DocumentFragment context, where the methods don't exist)
+ if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {
+
+ // ID selector
+ if ( (m = match[1]) ) {
+
+ // Document context
+ if ( nodeType === 9 ) {
+ if ( (elem = context.getElementById( m )) ) {
+
+ // Support: IE, Opera, Webkit
+ // TODO: identify versions
+ // getElementById can match elements by name instead of ID
+ if ( elem.id === m ) {
+ results.push( elem );
+ return results;
+ }
+ } else {
+ return results;
+ }
+
+ // Element context
+ } else {
+
+ // Support: IE, Opera, Webkit
+ // TODO: identify versions
+ // getElementById can match elements by name instead of ID
+ if ( newContext && (elem = newContext.getElementById( m )) &&
+ contains( context, elem ) &&
+ elem.id === m ) {
+
+ results.push( elem );
+ return results;
+ }
+ }
+
+ // Type selector
+ } else if ( match[2] ) {
+ push.apply( results, context.getElementsByTagName( selector ) );
+ return results;
+
+ // Class selector
+ } else if ( (m = match[3]) && support.getElementsByClassName &&
+ context.getElementsByClassName ) {
+
+ push.apply( results, context.getElementsByClassName( m ) );
+ return results;
+ }
+ }
+
+ // Take advantage of querySelectorAll
+ if ( support.qsa &&
+ !compilerCache[ selector + " " ] &&
+ (!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
+
+ if ( nodeType !== 1 ) {
+ newContext = context;
+ newSelector = selector;
+
+ // qSA looks outside Element context, which is not what we want
+ // Thanks to Andrew Dupont for this workaround technique
+ // Support: IE <=8
+ // Exclude object elements
+ } else if ( context.nodeName.toLowerCase() !== "object" ) {
+
+ // Capture the context ID, setting it first if necessary
+ if ( (nid = context.getAttribute( "id" )) ) {
+ nid = nid.replace( rcssescape, fcssescape );
+ } else {
+ context.setAttribute( "id", (nid = expando) );
+ }
+
+ // Prefix every selector in the list
+ groups = tokenize( selector );
+ i = groups.length;
+ while ( i-- ) {
+ groups[i] = "#" + nid + " " + toSelector( groups[i] );
+ }
+ newSelector = groups.join( "," );
+
+ // Expand context for sibling selectors
+ newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
+ context;
+ }
+
+ if ( newSelector ) {
+ try {
+ push.apply( results,
+ newContext.querySelectorAll( newSelector )
+ );
+ return results;
+ } catch ( qsaError ) {
+ } finally {
+ if ( nid === expando ) {
+ context.removeAttribute( "id" );
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // All others
+ return select( selector.replace( rtrim, "$1" ), context, results, seed );
+}
+
+/**
+ * Create key-value caches of limited size
+ * @returns {function(string, object)} Returns the Object data after storing it on itself with
+ * property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
+ * deleting the oldest entry
+ */
+function createCache() {
+ var keys = [];
+
+ function cache( key, value ) {
+ // Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
+ if ( keys.push( key + " " ) > Expr.cacheLength ) {
+ // Only keep the most recent entries
+ delete cache[ keys.shift() ];
+ }
+ return (cache[ key + " " ] = value);
+ }
+ return cache;
+}
+
+/**
+ * Mark a function for special use by Sizzle
+ * @param {Function} fn The function to mark
+ */
+function markFunction( fn ) {
+ fn[ expando ] = true;
+ return fn;
+}
+
+/**
+ * Support testing using an element
+ * @param {Function} fn Passed the created element and returns a boolean result
+ */
+function assert( fn ) {
+ var el = document.createElement("fieldset");
+
+ try {
+ return !!fn( el );
+ } catch (e) {
+ return false;
+ } finally {
+ // Remove from its parent by default
+ if ( el.parentNode ) {
+ el.parentNode.removeChild( el );
+ }
+ // release memory in IE
+ el = null;
+ }
+}
+
+/**
+ * Adds the same handler for all of the specified attrs
+ * @param {String} attrs Pipe-separated list of attributes
+ * @param {Function} handler The method that will be applied
+ */
+function addHandle( attrs, handler ) {
+ var arr = attrs.split("|"),
+ i = arr.length;
+
+ while ( i-- ) {
+ Expr.attrHandle[ arr[i] ] = handler;
+ }
+}
+
+/**
+ * Checks document order of two siblings
+ * @param {Element} a
+ * @param {Element} b
+ * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
+ */
+function siblingCheck( a, b ) {
+ var cur = b && a,
+ diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
+ a.sourceIndex - b.sourceIndex;
+
+ // Use IE sourceIndex if available on both nodes
+ if ( diff ) {
+ return diff;
+ }
+
+ // Check if b follows a
+ if ( cur ) {
+ while ( (cur = cur.nextSibling) ) {
+ if ( cur === b ) {
+ return -1;
+ }
+ }
+ }
+
+ return a ? 1 : -1;
+}
+
+/**
+ * Returns a function to use in pseudos for input types
+ * @param {String} type
+ */
+function createInputPseudo( type ) {
+ return function( elem ) {
+ var name = elem.nodeName.toLowerCase();
+ return name === "input" && elem.type === type;
+ };
+}
+
+/**
+ * Returns a function to use in pseudos for buttons
+ * @param {String} type
+ */
+function createButtonPseudo( type ) {
+ return function( elem ) {
+ var name = elem.nodeName.toLowerCase();
+ return (name === "input" || name === "button") && elem.type === type;
+ };
+}
+
+/**
+ * Returns a function to use in pseudos for :enabled/:disabled
+ * @param {Boolean} disabled true for :disabled; false for :enabled
+ */
+function createDisabledPseudo( disabled ) {
+
+ // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
+ return function( elem ) {
+
+ // Only certain elements can match :enabled or :disabled
+ // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
+ // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
+ if ( "form" in elem ) {
+
+ // Check for inherited disabledness on relevant non-disabled elements:
+ // * listed form-associated elements in a disabled fieldset
+ // https://html.spec.whatwg.org/multipage/forms.html#category-listed
+ // https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
+ // * option elements in a disabled optgroup
+ // https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
+ // All such elements have a "form" property.
+ if ( elem.parentNode && elem.disabled === false ) {
+
+ // Option elements defer to a parent optgroup if present
+ if ( "label" in elem ) {
+ if ( "label" in elem.parentNode ) {
+ return elem.parentNode.disabled === disabled;
+ } else {
+ return elem.disabled === disabled;
+ }
+ }
+
+ // Support: IE 6 - 11
+ // Use the isDisabled shortcut property to check for disabled fieldset ancestors
+ return elem.isDisabled === disabled ||
+
+ // Where there is no isDisabled, check manually
+ /* jshint -W018 */
+ elem.isDisabled !== !disabled &&
+ disabledAncestor( elem ) === disabled;
+ }
+
+ return elem.disabled === disabled;
+
+ // Try to winnow out elements that can't be disabled before trusting the disabled property.
+ // Some victims get caught in our net (label, legend, menu, track), but it shouldn't
+ // even exist on them, let alone have a boolean value.
+ } else if ( "label" in elem ) {
+ return elem.disabled === disabled;
+ }
+
+ // Remaining elements are neither :enabled nor :disabled
+ return false;
+ };
+}
+
+/**
+ * Returns a function to use in pseudos for positionals
+ * @param {Function} fn
+ */
+function createPositionalPseudo( fn ) {
+ return markFunction(function( argument ) {
+ argument = +argument;
+ return markFunction(function( seed, matches ) {
+ var j,
+ matchIndexes = fn( [], seed.length, argument ),
+ i = matchIndexes.length;
+
+ // Match elements found at the specified indexes
+ while ( i-- ) {
+ if ( seed[ (j = matchIndexes[i]) ] ) {
+ seed[j] = !(matches[j] = seed[j]);
+ }
+ }
+ });
+ });
+}
+
+/**
+ * Checks a node for validity as a Sizzle context
+ * @param {Element|Object=} context
+ * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
+ */
+function testContext( context ) {
+ return context && typeof context.getElementsByTagName !== "undefined" && context;
+}
+
+// Expose support vars for convenience
+support = Sizzle.support = {};
+
+/**
+ * Detects XML nodes
+ * @param {Element|Object} elem An element or a document
+ * @returns {Boolean} True iff elem is a non-HTML XML node
+ */
+isXML = Sizzle.isXML = function( elem ) {
+ // documentElement is verified for cases where it doesn't yet exist
+ // (such as loading iframes in IE - #4833)
+ var documentElement = elem && (elem.ownerDocument || elem).documentElement;
+ return documentElement ? documentElement.nodeName !== "HTML" : false;
+};
+
+/**
+ * Sets document-related variables once based on the current document
+ * @param {Element|Object} [doc] An element or document object to use to set the document
+ * @returns {Object} Returns the current document
+ */
+setDocument = Sizzle.setDocument = function( node ) {
+ var hasCompare, subWindow,
+ doc = node ? node.ownerDocument || node : preferredDoc;
+
+ // Return early if doc is invalid or already selected
+ if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
+ return document;
+ }
+
+ // Update global variables
+ document = doc;
+ docElem = document.documentElement;
+ documentIsHTML = !isXML( document );
+
+ // Support: IE 9-11, Edge
+ // Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
+ if ( preferredDoc !== document &&
+ (subWindow = document.defaultView) && subWindow.top !== subWindow ) {
+
+ // Support: IE 11, Edge
+ if ( subWindow.addEventListener ) {
+ subWindow.addEventListener( "unload", unloadHandler, false );
+
+ // Support: IE 9 - 10 only
+ } else if ( subWindow.attachEvent ) {
+ subWindow.attachEvent( "onunload", unloadHandler );
+ }
+ }
+
+ /* Attributes
+ ---------------------------------------------------------------------- */
+
+ // Support: IE<8
+ // Verify that getAttribute really returns attributes and not properties
+ // (excepting IE8 booleans)
+ support.attributes = assert(function( el ) {
+ el.className = "i";
+ return !el.getAttribute("className");
+ });
+
+ /* getElement(s)By*
+ ---------------------------------------------------------------------- */
+
+ // Check if getElementsByTagName("*") returns only elements
+ support.getElementsByTagName = assert(function( el ) {
+ el.appendChild( document.createComment("") );
+ return !el.getElementsByTagName("*").length;
+ });
+
+ // Support: IE<9
+ support.getElementsByClassName = rnative.test( document.getElementsByClassName );
+
+ // Support: IE<10
+ // Check if getElementById returns elements by name
+ // The broken getElementById methods don't pick up programmatically-set names,
+ // so use a roundabout getElementsByName test
+ support.getById = assert(function( el ) {
+ docElem.appendChild( el ).id = expando;
+ return !document.getElementsByName || !document.getElementsByName( expando ).length;
+ });
+
+ // ID filter and find
+ if ( support.getById ) {
+ Expr.filter["ID"] = function( id ) {
+ var attrId = id.replace( runescape, funescape );
+ return function( elem ) {
+ return elem.getAttribute("id") === attrId;
+ };
+ };
+ Expr.find["ID"] = function( id, context ) {
+ if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
+ var elem = context.getElementById( id );
+ return elem ? [ elem ] : [];
+ }
+ };
+ } else {
+ Expr.filter["ID"] = function( id ) {
+ var attrId = id.replace( runescape, funescape );
+ return function( elem ) {
+ var node = typeof elem.getAttributeNode !== "undefined" &&
+ elem.getAttributeNode("id");
+ return node && node.value === attrId;
+ };
+ };
+
+ // Support: IE 6 - 7 only
+ // getElementById is not reliable as a find shortcut
+ Expr.find["ID"] = function( id, context ) {
+ if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
+ var node, i, elems,
+ elem = context.getElementById( id );
+
+ if ( elem ) {
+
+ // Verify the id attribute
+ node = elem.getAttributeNode("id");
+ if ( node && node.value === id ) {
+ return [ elem ];
+ }
+
+ // Fall back on getElementsByName
+ elems = context.getElementsByName( id );
+ i = 0;
+ while ( (elem = elems[i++]) ) {
+ node = elem.getAttributeNode("id");
+ if ( node && node.value === id ) {
+ return [ elem ];
+ }
+ }
+ }
+
+ return [];
+ }
+ };
+ }
+
+ // Tag
+ Expr.find["TAG"] = support.getElementsByTagName ?
+ function( tag, context ) {
+ if ( typeof context.getElementsByTagName !== "undefined" ) {
+ return context.getElementsByTagName( tag );
+
+ // DocumentFragment nodes don't have gEBTN
+ } else if ( support.qsa ) {
+ return context.querySelectorAll( tag );
+ }
+ } :
+
+ function( tag, context ) {
+ var elem,
+ tmp = [],
+ i = 0,
+ // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
+ results = context.getElementsByTagName( tag );
+
+ // Filter out possible comments
+ if ( tag === "*" ) {
+ while ( (elem = results[i++]) ) {
+ if ( elem.nodeType === 1 ) {
+ tmp.push( elem );
+ }
+ }
+
+ return tmp;
+ }
+ return results;
+ };
+
+ // Class
+ Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
+ if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
+ return context.getElementsByClassName( className );
+ }
+ };
+
+ /* QSA/matchesSelector
+ ---------------------------------------------------------------------- */
+
+ // QSA and matchesSelector support
+
+ // matchesSelector(:active) reports false when true (IE9/Opera 11.5)
+ rbuggyMatches = [];
+
+ // qSa(:focus) reports false when true (Chrome 21)
+ // We allow this because of a bug in IE8/9 that throws an error
+ // whenever `document.activeElement` is accessed on an iframe
+ // So, we allow :focus to pass through QSA all the time to avoid the IE error
+ // See https://bugs.jquery.com/ticket/13378
+ rbuggyQSA = [];
+
+ if ( (support.qsa = rnative.test( document.querySelectorAll )) ) {
+ // Build QSA regex
+ // Regex strategy adopted from Diego Perini
+ assert(function( el ) {
+ // Select is set to empty string on purpose
+ // This is to test IE's treatment of not explicitly
+ // setting a boolean content attribute,
+ // since its presence should be enough
+ // https://bugs.jquery.com/ticket/12359
+ docElem.appendChild( el ).innerHTML = "<a id='" + expando + "'></a>" +
+ "<select id='" + expando + "-\r\\' msallowcapture=''>" +
+ "<option selected=''></option></select>";
+
+ // Support: IE8, Opera 11-12.16
+ // Nothing should be selected when empty strings follow ^= or $= or *=
+ // The test attribute must be unknown in Opera but "safe" for WinRT
+ // https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
+ if ( el.querySelectorAll("[msallowcapture^='']").length ) {
+ rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
+ }
+
+ // Support: IE8
+ // Boolean attributes and "value" are not treated correctly
+ if ( !el.querySelectorAll("[selected]").length ) {
+ rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
+ }
+
+ // Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
+ if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
+ rbuggyQSA.push("~=");
+ }
+
+ // Webkit/Opera - :checked should return selected option elements
+ // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
+ // IE8 throws error here and will not see later tests
+ if ( !el.querySelectorAll(":checked").length ) {
+ rbuggyQSA.push(":checked");
+ }
+
+ // Support: Safari 8+, iOS 8+
+ // https://bugs.webkit.org/show_bug.cgi?id=136851
+ // In-page `selector#id sibling-combinator selector` fails
+ if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
+ rbuggyQSA.push(".#.+[+~]");
+ }
+ });
+
+ assert(function( el ) {
+ el.innerHTML = "<a href='' disabled='disabled'></a>" +
+ "<select disabled='disabled'><option/></select>";
+
+ // Support: Windows 8 Native Apps
+ // The type and name attributes are restricted during .innerHTML assignment
+ var input = document.createElement("input");
+ input.setAttribute( "type", "hidden" );
+ el.appendChild( input ).setAttribute( "name", "D" );
+
+ // Support: IE8
+ // Enforce case-sensitivity of name attribute
+ if ( el.querySelectorAll("[name=d]").length ) {
+ rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
+ }
+
+ // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
+ // IE8 throws error here and will not see later tests
+ if ( el.querySelectorAll(":enabled").length !== 2 ) {
+ rbuggyQSA.push( ":enabled", ":disabled" );
+ }
+
+ // Support: IE9-11+
+ // IE's :disabled selector does not pick up the children of disabled fieldsets
+ docElem.appendChild( el ).disabled = true;
+ if ( el.querySelectorAll(":disabled").length !== 2 ) {
+ rbuggyQSA.push( ":enabled", ":disabled" );
+ }
+
+ // Opera 10-11 does not throw on post-comma invalid pseudos
+ el.querySelectorAll("*,:x");
+ rbuggyQSA.push(",.*:");
+ });
+ }
+
+ if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||
+ docElem.webkitMatchesSelector ||
+ docElem.mozMatchesSelector ||
+ docElem.oMatchesSelector ||
+ docElem.msMatchesSelector) )) ) {
+
+ assert(function( el ) {
+ // Check to see if it's possible to do matchesSelector
+ // on a disconnected node (IE 9)
+ support.disconnectedMatch = matches.call( el, "*" );
+
+ // This should fail with an exception
+ // Gecko does not error, returns false instead
+ matches.call( el, "[s!='']:x" );
+ rbuggyMatches.push( "!=", pseudos );
+ });
+ }
+
+ rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
+ rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
+
+ /* Contains
+ ---------------------------------------------------------------------- */
+ hasCompare = rnative.test( docElem.compareDocumentPosition );
+
+ // Element contains another
+ // Purposefully self-exclusive
+ // As in, an element does not contain itself
+ contains = hasCompare || rnative.test( docElem.contains ) ?
+ function( a, b ) {
+ var adown = a.nodeType === 9 ? a.documentElement : a,
+ bup = b && b.parentNode;
+ return a === bup || !!( bup && bup.nodeType === 1 && (
+ adown.contains ?
+ adown.contains( bup ) :
+ a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
+ ));
+ } :
+ function( a, b ) {
+ if ( b ) {
+ while ( (b = b.parentNode) ) {
+ if ( b === a ) {
+ return true;
+ }
+ }
+ }
+ return false;
+ };
+
+ /* Sorting
+ ---------------------------------------------------------------------- */
+
+ // Document order sorting
+ sortOrder = hasCompare ?
+ function( a, b ) {
+
+ // Flag for duplicate removal
+ if ( a === b ) {
+ hasDuplicate = true;
+ return 0;
+ }
+
+ // Sort on method existence if only one input has compareDocumentPosition
+ var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
+ if ( compare ) {
+ return compare;
+ }
+
+ // Calculate position if both inputs belong to the same document
+ compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
+ a.compareDocumentPosition( b ) :
+
+ // Otherwise we know they are disconnected
+ 1;
+
+ // Disconnected nodes
+ if ( compare & 1 ||
+ (!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
+
+ // Choose the first element that is related to our preferred document
+ if ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
+ return -1;
+ }
+ if ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
+ return 1;
+ }
+
+ // Maintain original order
+ return sortInput ?
+ ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
+ 0;
+ }
+
+ return compare & 4 ? -1 : 1;
+ } :
+ function( a, b ) {
+ // Exit early if the nodes are identical
+ if ( a === b ) {
+ hasDuplicate = true;
+ return 0;
+ }
+
+ var cur,
+ i = 0,
+ aup = a.parentNode,
+ bup = b.parentNode,
+ ap = [ a ],
+ bp = [ b ];
+
+ // Parentless nodes are either documents or disconnected
+ if ( !aup || !bup ) {
+ return a === document ? -1 :
+ b === document ? 1 :
+ aup ? -1 :
+ bup ? 1 :
+ sortInput ?
+ ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
+ 0;
+
+ // If the nodes are siblings, we can do a quick check
+ } else if ( aup === bup ) {
+ return siblingCheck( a, b );
+ }
+
+ // Otherwise we need full lists of their ancestors for comparison
+ cur = a;
+ while ( (cur = cur.parentNode) ) {
+ ap.unshift( cur );
+ }
+ cur = b;
+ while ( (cur = cur.parentNode) ) {
+ bp.unshift( cur );
+ }
+
+ // Walk down the tree looking for a discrepancy
+ while ( ap[i] === bp[i] ) {
+ i++;
+ }
+
+ return i ?
+ // Do a sibling check if the nodes have a common ancestor
+ siblingCheck( ap[i], bp[i] ) :
+
+ // Otherwise nodes in our document sort first
+ ap[i] === preferredDoc ? -1 :
+ bp[i] === preferredDoc ? 1 :
+ 0;
+ };
+
+ return document;
+};
+
+Sizzle.matches = function( expr, elements ) {
+ return Sizzle( expr, null, null, elements );
+};
+
+Sizzle.matchesSelector = function( elem, expr ) {
+ // Set document vars if needed
+ if ( ( elem.ownerDocument || elem ) !== document ) {
+ setDocument( elem );
+ }
+
+ // Make sure that attribute selectors are quoted
+ expr = expr.replace( rattributeQuotes, "='$1']" );
+
+ if ( support.matchesSelector && documentIsHTML &&
+ !compilerCache[ expr + " " ] &&
+ ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
+ ( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) {
+
+ try {
+ var ret = matches.call( elem, expr );
+
+ // IE 9's matchesSelector returns false on disconnected nodes
+ if ( ret || support.disconnectedMatch ||
+ // As well, disconnected nodes are said to be in a document
+ // fragment in IE 9
+ elem.document && elem.document.nodeType !== 11 ) {
+ return ret;
+ }
+ } catch (e) {}
+ }
+
+ return Sizzle( expr, document, null, [ elem ] ).length > 0;
+};
+
+Sizzle.contains = function( context, elem ) {
+ // Set document vars if needed
+ if ( ( context.ownerDocument || context ) !== document ) {
+ setDocument( context );
+ }
+ return contains( context, elem );
+};
+
+Sizzle.attr = function( elem, name ) {
+ // Set document vars if needed
+ if ( ( elem.ownerDocument || elem ) !== document ) {
+ setDocument( elem );
+ }
+
+ var fn = Expr.attrHandle[ name.toLowerCase() ],
+ // Don't get fooled by Object.prototype properties (jQuery #13807)
+ val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
+ fn( elem, name, !documentIsHTML ) :
+ undefined;
+
+ return val !== undefined ?
+ val :
+ support.attributes || !documentIsHTML ?
+ elem.getAttribute( name ) :
+ (val = elem.getAttributeNode(name)) && val.specified ?
+ val.value :
+ null;
+};
+
+Sizzle.escape = function( sel ) {
+ return (sel + "").replace( rcssescape, fcssescape );
+};
+
+Sizzle.error = function( msg ) {
+ throw new Error( "Syntax error, unrecognized expression: " + msg );
+};
+
+/**
+ * Document sorting and removing duplicates
+ * @param {ArrayLike} results
+ */
+Sizzle.uniqueSort = function( results ) {
+ var elem,
+ duplicates = [],
+ j = 0,
+ i = 0;
+
+ // Unless we *know* we can detect duplicates, assume their presence
+ hasDuplicate = !support.detectDuplicates;
+ sortInput = !support.sortStable && results.slice( 0 );
+ results.sort( sortOrder );
+
+ if ( hasDuplicate ) {
+ while ( (elem = results[i++]) ) {
+ if ( elem === results[ i ] ) {
+ j = duplicates.push( i );
+ }
+ }
+ while ( j-- ) {
+ results.splice( duplicates[ j ], 1 );
+ }
+ }
+
+ // Clear input after sorting to release objects
+ // See https://github.com/jquery/sizzle/pull/225
+ sortInput = null;
+
+ return results;
+};
+
+/**
+ * Utility function for retrieving the text value of an array of DOM nodes
+ * @param {Array|Element} elem
+ */
+getText = Sizzle.getText = function( elem ) {
+ var node,
+ ret = "",
+ i = 0,
+ nodeType = elem.nodeType;
+
+ if ( !nodeType ) {
+ // If no nodeType, this is expected to be an array
+ while ( (node = elem[i++]) ) {
+ // Do not traverse comment nodes
+ ret += getText( node );
+ }
+ } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
+ // Use textContent for elements
+ // innerText usage removed for consistency of new lines (jQuery #11153)
+ if ( typeof elem.textContent === "string" ) {
+ return elem.textContent;
+ } else {
+ // Traverse its children
+ for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
+ ret += getText( elem );
+ }
+ }
+ } else if ( nodeType === 3 || nodeType === 4 ) {
+ return elem.nodeValue;
+ }
+ // Do not include comment or processing instruction nodes
+
+ return ret;
+};
+
+Expr = Sizzle.selectors = {
+
+ // Can be adjusted by the user
+ cacheLength: 50,
+
+ createPseudo: markFunction,
+
+ match: matchExpr,
+
+ attrHandle: {},
+
+ find: {},
+
+ relative: {
+ ">": { dir: "parentNode", first: true },
+ " ": { dir: "parentNode" },
+ "+": { dir: "previousSibling", first: true },
+ "~": { dir: "previousSibling" }
+ },
+
+ preFilter: {
+ "ATTR": function( match ) {
+ match[1] = match[1].replace( runescape, funescape );
+
+ // Move the given value to match[3] whether quoted or unquoted
+ match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );
+
+ if ( match[2] === "~=" ) {
+ match[3] = " " + match[3] + " ";
+ }
+
+ return match.slice( 0, 4 );
+ },
+
+ "CHILD": function( match ) {
+ /* matches from matchExpr["CHILD"]
+ 1 type (only|nth|...)
+ 2 what (child|of-type)
+ 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
+ 4 xn-component of xn+y argument ([+-]?\d*n|)
+ 5 sign of xn-component
+ 6 x of xn-component
+ 7 sign of y-component
+ 8 y of y-component
+ */
+ match[1] = match[1].toLowerCase();
+
+ if ( match[1].slice( 0, 3 ) === "nth" ) {
+ // nth-* requires argument
+ if ( !match[3] ) {
+ Sizzle.error( match[0] );
+ }
+
+ // numeric x and y parameters for Expr.filter.CHILD
+ // remember that false/true cast respectively to 0/1
+ match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
+ match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
+
+ // other types prohibit arguments
+ } else if ( match[3] ) {
+ Sizzle.error( match[0] );
+ }
+
+ return match;
+ },
+
+ "PSEUDO": function( match ) {
+ var excess,
+ unquoted = !match[6] && match[2];
+
+ if ( matchExpr["CHILD"].test( match[0] ) ) {
+ return null;
+ }
+
+ // Accept quoted arguments as-is
+ if ( match[3] ) {
+ match[2] = match[4] || match[5] || "";
+
+ // Strip excess characters from unquoted arguments
+ } else if ( unquoted && rpseudo.test( unquoted ) &&
+ // Get excess from tokenize (recursively)
+ (excess = tokenize( unquoted, true )) &&
+ // advance to the next closing parenthesis
+ (excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
+
+ // excess is a negative index
+ match[0] = match[0].slice( 0, excess );
+ match[2] = unquoted.slice( 0, excess );
+ }
+
+ // Return only captures needed by the pseudo filter method (type and argument)
+ return match.slice( 0, 3 );
+ }
+ },
+
+ filter: {
+
+ "TAG": function( nodeNameSelector ) {
+ var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
+ return nodeNameSelector === "*" ?
+ function() { return true; } :
+ function( elem ) {
+ return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
+ };
+ },
+
+ "CLASS": function( className ) {
+ var pattern = classCache[ className + " " ];
+
+ return pattern ||
+ (pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
+ classCache( className, function( elem ) {
+ return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" );
+ });
+ },
+
+ "ATTR": function( name, operator, check ) {
+ return function( elem ) {
+ var result = Sizzle.attr( elem, name );
+
+ if ( result == null ) {
+ return operator === "!=";
+ }
+ if ( !operator ) {
+ return true;
+ }
+
+ result += "";
+
+ return operator === "=" ? result === check :
+ operator === "!=" ? result !== check :
+ operator === "^=" ? check && result.indexOf( check ) === 0 :
+ operator === "*=" ? check && result.indexOf( check ) > -1 :
+ operator === "$=" ? check && result.slice( -check.length ) === check :
+ operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
+ operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
+ false;
+ };
+ },
+
+ "CHILD": function( type, what, argument, first, last ) {
+ var simple = type.slice( 0, 3 ) !== "nth",
+ forward = type.slice( -4 ) !== "last",
+ ofType = what === "of-type";
+
+ return first === 1 && last === 0 ?
+
+ // Shortcut for :nth-*(n)
+ function( elem ) {
+ return !!elem.parentNode;
+ } :
+
+ function( elem, context, xml ) {
+ var cache, uniqueCache, outerCache, node, nodeIndex, start,
+ dir = simple !== forward ? "nextSibling" : "previousSibling",
+ parent = elem.parentNode,
+ name = ofType && elem.nodeName.toLowerCase(),
+ useCache = !xml && !ofType,
+ diff = false;
+
+ if ( parent ) {
+
+ // :(first|last|only)-(child|of-type)
+ if ( simple ) {
+ while ( dir ) {
+ node = elem;
+ while ( (node = node[ dir ]) ) {
+ if ( ofType ?
+ node.nodeName.toLowerCase() === name :
+ node.nodeType === 1 ) {
+
+ return false;
+ }
+ }
+ // Reverse direction for :only-* (if we haven't yet done so)
+ start = dir = type === "only" && !start && "nextSibling";
+ }
+ return true;
+ }
+
+ start = [ forward ? parent.firstChild : parent.lastChild ];
+
+ // non-xml :nth-child(...) stores cache data on `parent`
+ if ( forward && useCache ) {
+
+ // Seek `elem` from a previously-cached index
+
+ // ...in a gzip-friendly way
+ node = parent;
+ outerCache = node[ expando ] || (node[ expando ] = {});
+
+ // Support: IE <9 only
+ // Defend against cloned attroperties (jQuery gh-1709)
+ uniqueCache = outerCache[ node.uniqueID ] ||
+ (outerCache[ node.uniqueID ] = {});
+
+ cache = uniqueCache[ type ] || [];
+ nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
+ diff = nodeIndex && cache[ 2 ];
+ node = nodeIndex && parent.childNodes[ nodeIndex ];
+
+ while ( (node = ++nodeIndex && node && node[ dir ] ||
+
+ // Fallback to seeking `elem` from the start
+ (diff = nodeIndex = 0) || start.pop()) ) {
+
+ // When found, cache indexes on `parent` and break
+ if ( node.nodeType === 1 && ++diff && node === elem ) {
+ uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
+ break;
+ }
+ }
+
+ } else {
+ // Use previously-cached element index if available
+ if ( useCache ) {
+ // ...in a gzip-friendly way
+ node = elem;
+ outerCache = node[ expando ] || (node[ expando ] = {});
+
+ // Support: IE <9 only
+ // Defend against cloned attroperties (jQuery gh-1709)
+ uniqueCache = outerCache[ node.uniqueID ] ||
+ (outerCache[ node.uniqueID ] = {});
+
+ cache = uniqueCache[ type ] || [];
+ nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
+ diff = nodeIndex;
+ }
+
+ // xml :nth-child(...)
+ // or :nth-last-child(...) or :nth(-last)?-of-type(...)
+ if ( diff === false ) {
+ // Use the same loop as above to seek `elem` from the start
+ while ( (node = ++nodeIndex && node && node[ dir ] ||
+ (diff = nodeIndex = 0) || start.pop()) ) {
+
+ if ( ( ofType ?
+ node.nodeName.toLowerCase() === name :
+ node.nodeType === 1 ) &&
+ ++diff ) {
+
+ // Cache the index of each encountered element
+ if ( useCache ) {
+ outerCache = node[ expando ] || (node[ expando ] = {});
+
+ // Support: IE <9 only
+ // Defend against cloned attroperties (jQuery gh-1709)
+ uniqueCache = outerCache[ node.uniqueID ] ||
+ (outerCache[ node.uniqueID ] = {});
+
+ uniqueCache[ type ] = [ dirruns, diff ];
+ }
+
+ if ( node === elem ) {
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ // Incorporate the offset, then check against cycle size
+ diff -= last;
+ return diff === first || ( diff % first === 0 && diff / first >= 0 );
+ }
+ };
+ },
+
+ "PSEUDO": function( pseudo, argument ) {
+ // pseudo-class names are case-insensitive
+ // http://www.w3.org/TR/selectors/#pseudo-classes
+ // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
+ // Remember that setFilters inherits from pseudos
+ var args,
+ fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
+ Sizzle.error( "unsupported pseudo: " + pseudo );
+
+ // The user may use createPseudo to indicate that
+ // arguments are needed to create the filter function
+ // just as Sizzle does
+ if ( fn[ expando ] ) {
+ return fn( argument );
+ }
+
+ // But maintain support for old signatures
+ if ( fn.length > 1 ) {
+ args = [ pseudo, pseudo, "", argument ];
+ return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
+ markFunction(function( seed, matches ) {
+ var idx,
+ matched = fn( seed, argument ),
+ i = matched.length;
+ while ( i-- ) {
+ idx = indexOf( seed, matched[i] );
+ seed[ idx ] = !( matches[ idx ] = matched[i] );
+ }
+ }) :
+ function( elem ) {
+ return fn( elem, 0, args );
+ };
+ }
+
+ return fn;
+ }
+ },
+
+ pseudos: {
+ // Potentially complex pseudos
+ "not": markFunction(function( selector ) {
+ // Trim the selector passed to compile
+ // to avoid treating leading and trailing
+ // spaces as combinators
+ var input = [],
+ results = [],
+ matcher = compile( selector.replace( rtrim, "$1" ) );
+
+ return matcher[ expando ] ?
+ markFunction(function( seed, matches, context, xml ) {
+ var elem,
+ unmatched = matcher( seed, null, xml, [] ),
+ i = seed.length;
+
+ // Match elements unmatched by `matcher`
+ while ( i-- ) {
+ if ( (elem = unmatched[i]) ) {
+ seed[i] = !(matches[i] = elem);
+ }
+ }
+ }) :
+ function( elem, context, xml ) {
+ input[0] = elem;
+ matcher( input, null, xml, results );
+ // Don't keep the element (issue #299)
+ input[0] = null;
+ return !results.pop();
+ };
+ }),
+
+ "has": markFunction(function( selector ) {
+ return function( elem ) {
+ return Sizzle( selector, elem ).length > 0;
+ };
+ }),
+
+ "contains": markFunction(function( text ) {
+ text = text.replace( runescape, funescape );
+ return function( elem ) {
+ return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
+ };
+ }),
+
+ // "Whether an element is represented by a :lang() selector
+ // is based solely on the element's language value
+ // being equal to the identifier C,
+ // or beginning with the identifier C immediately followed by "-".
+ // The matching of C against the element's language value is performed case-insensitively.
+ // The identifier C does not have to be a valid language name."
+ // http://www.w3.org/TR/selectors/#lang-pseudo
+ "lang": markFunction( function( lang ) {
+ // lang value must be a valid identifier
+ if ( !ridentifier.test(lang || "") ) {
+ Sizzle.error( "unsupported lang: " + lang );
+ }
+ lang = lang.replace( runescape, funescape ).toLowerCase();
+ return function( elem ) {
+ var elemLang;
+ do {
+ if ( (elemLang = documentIsHTML ?
+ elem.lang :
+ elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
+
+ elemLang = elemLang.toLowerCase();
+ return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
+ }
+ } while ( (elem = elem.parentNode) && elem.nodeType === 1 );
+ return false;
+ };
+ }),
+
+ // Miscellaneous
+ "target": function( elem ) {
+ var hash = window.location && window.location.hash;
+ return hash && hash.slice( 1 ) === elem.id;
+ },
+
+ "root": function( elem ) {
+ return elem === docElem;
+ },
+
+ "focus": function( elem ) {
+ return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
+ },
+
+ // Boolean properties
+ "enabled": createDisabledPseudo( false ),
+ "disabled": createDisabledPseudo( true ),
+
+ "checked": function( elem ) {
+ // In CSS3, :checked should return both checked and selected elements
+ // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
+ var nodeName = elem.nodeName.toLowerCase();
+ return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
+ },
+
+ "selected": function( elem ) {
+ // Accessing this property makes selected-by-default
+ // options in Safari work properly
+ if ( elem.parentNode ) {
+ elem.parentNode.selectedIndex;
+ }
+
+ return elem.selected === true;
+ },
+
+ // Contents
+ "empty": function( elem ) {
+ // http://www.w3.org/TR/selectors/#empty-pseudo
+ // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
+ // but not by others (comment: 8; processing instruction: 7; etc.)
+ // nodeType < 6 works because attributes (2) do not appear as children
+ for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
+ if ( elem.nodeType < 6 ) {
+ return false;
+ }
+ }
+ return true;
+ },
+
+ "parent": function( elem ) {
+ return !Expr.pseudos["empty"]( elem );
+ },
+
+ // Element/input types
+ "header": function( elem ) {
+ return rheader.test( elem.nodeName );
+ },
+
+ "input": function( elem ) {
+ return rinputs.test( elem.nodeName );
+ },
+
+ "button": function( elem ) {
+ var name = elem.nodeName.toLowerCase();
+ return name === "input" && elem.type === "button" || name === "button";
+ },
+
+ "text": function( elem ) {
+ var attr;
+ return elem.nodeName.toLowerCase() === "input" &&
+ elem.type === "text" &&
+
+ // Support: IE<8
+ // New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
+ ( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );
+ },
+
+ // Position-in-collection
+ "first": createPositionalPseudo(function() {
+ return [ 0 ];
+ }),
+
+ "last": createPositionalPseudo(function( matchIndexes, length ) {
+ return [ length - 1 ];
+ }),
+
+ "eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
+ return [ argument < 0 ? argument + length : argument ];
+ }),
+
+ "even": createPositionalPseudo(function( matchIndexes, length ) {
+ var i = 0;
+ for ( ; i < length; i += 2 ) {
+ matchIndexes.push( i );
+ }
+ return matchIndexes;
+ }),
+
+ "odd": createPositionalPseudo(function( matchIndexes, length ) {
+ var i = 1;
+ for ( ; i < length; i += 2 ) {
+ matchIndexes.push( i );
+ }
+ return matchIndexes;
+ }),
+
+ "lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
+ var i = argument < 0 ? argument + length : argument;
+ for ( ; --i >= 0; ) {
+ matchIndexes.push( i );
+ }
+ return matchIndexes;
+ }),
+
+ "gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
+ var i = argument < 0 ? argument + length : argument;
+ for ( ; ++i < length; ) {
+ matchIndexes.push( i );
+ }
+ return matchIndexes;
+ })
+ }
+};
+
+Expr.pseudos["nth"] = Expr.pseudos["eq"];
+
+// Add button/input type pseudos
+for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
+ Expr.pseudos[ i ] = createInputPseudo( i );
+}
+for ( i in { submit: true, reset: true } ) {
+ Expr.pseudos[ i ] = createButtonPseudo( i );
+}
+
+// Easy API for creating new setFilters
+function setFilters() {}
+setFilters.prototype = Expr.filters = Expr.pseudos;
+Expr.setFilters = new setFilters();
+
+tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
+ var matched, match, tokens, type,
+ soFar, groups, preFilters,
+ cached = tokenCache[ selector + " " ];
+
+ if ( cached ) {
+ return parseOnly ? 0 : cached.slice( 0 );
+ }
+
+ soFar = selector;
+ groups = [];
+ preFilters = Expr.preFilter;
+
+ while ( soFar ) {
+
+ // Comma and first run
+ if ( !matched || (match = rcomma.exec( soFar )) ) {
+ if ( match ) {
+ // Don't consume trailing commas as valid
+ soFar = soFar.slice( match[0].length ) || soFar;
+ }
+ groups.push( (tokens = []) );
+ }
+
+ matched = false;
+
+ // Combinators
+ if ( (match = rcombinators.exec( soFar )) ) {
+ matched = match.shift();
+ tokens.push({
+ value: matched,
+ // Cast descendant combinators to space
+ type: match[0].replace( rtrim, " " )
+ });
+ soFar = soFar.slice( matched.length );
+ }
+
+ // Filters
+ for ( type in Expr.filter ) {
+ if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
+ (match = preFilters[ type ]( match ))) ) {
+ matched = match.shift();
+ tokens.push({
+ value: matched,
+ type: type,
+ matches: match
+ });
+ soFar = soFar.slice( matched.length );
+ }
+ }
+
+ if ( !matched ) {
+ break;
+ }
+ }
+
+ // Return the length of the invalid excess
+ // if we're just parsing
+ // Otherwise, throw an error or return tokens
+ return parseOnly ?
+ soFar.length :
+ soFar ?
+ Sizzle.error( selector ) :
+ // Cache the tokens
+ tokenCache( selector, groups ).slice( 0 );
+};
+
+function toSelector( tokens ) {
+ var i = 0,
+ len = tokens.length,
+ selector = "";
+ for ( ; i < len; i++ ) {
+ selector += tokens[i].value;
+ }
+ return selector;
+}
+
+function addCombinator( matcher, combinator, base ) {
+ var dir = combinator.dir,
+ skip = combinator.next,
+ key = skip || dir,
+ checkNonElements = base && key === "parentNode",
+ doneName = done++;
+
+ return combinator.first ?
+ // Check against closest ancestor/preceding element
+ function( elem, context, xml ) {
+ while ( (elem = elem[ dir ]) ) {
+ if ( elem.nodeType === 1 || checkNonElements ) {
+ return matcher( elem, context, xml );
+ }
+ }
+ return false;
+ } :
+
+ // Check against all ancestor/preceding elements
+ function( elem, context, xml ) {
+ var oldCache, uniqueCache, outerCache,
+ newCache = [ dirruns, doneName ];
+
+ // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
+ if ( xml ) {
+ while ( (elem = elem[ dir ]) ) {
+ if ( elem.nodeType === 1 || checkNonElements ) {
+ if ( matcher( elem, context, xml ) ) {
+ return true;
+ }
+ }
+ }
+ } else {
+ while ( (elem = elem[ dir ]) ) {
+ if ( elem.nodeType === 1 || checkNonElements ) {
+ outerCache = elem[ expando ] || (elem[ expando ] = {});
+
+ // Support: IE <9 only
+ // Defend against cloned attroperties (jQuery gh-1709)
+ uniqueCache = outerCache[ elem.uniqueID ] || (outerCache[ elem.uniqueID ] = {});
+
+ if ( skip && skip === elem.nodeName.toLowerCase() ) {
+ elem = elem[ dir ] || elem;
+ } else if ( (oldCache = uniqueCache[ key ]) &&
+ oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
+
+ // Assign to newCache so results back-propagate to previous elements
+ return (newCache[ 2 ] = oldCache[ 2 ]);
+ } else {
+ // Reuse newcache so results back-propagate to previous elements
+ uniqueCache[ key ] = newCache;
+
+ // A match means we're done; a fail means we have to keep checking
+ if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
+ return true;
+ }
+ }
+ }
+ }
+ }
+ return false;
+ };
+}
+
+function elementMatcher( matchers ) {
+ return matchers.length > 1 ?
+ function( elem, context, xml ) {
+ var i = matchers.length;
+ while ( i-- ) {
+ if ( !matchers[i]( elem, context, xml ) ) {
+ return false;
+ }
+ }
+ return true;
+ } :
+ matchers[0];
+}
+
+function multipleContexts( selector, contexts, results ) {
+ var i = 0,
+ len = contexts.length;
+ for ( ; i < len; i++ ) {
+ Sizzle( selector, contexts[i], results );
+ }
+ return results;
+}
+
+function condense( unmatched, map, filter, context, xml ) {
+ var elem,
+ newUnmatched = [],
+ i = 0,
+ len = unmatched.length,
+ mapped = map != null;
+
+ for ( ; i < len; i++ ) {
+ if ( (elem = unmatched[i]) ) {
+ if ( !filter || filter( elem, context, xml ) ) {
+ newUnmatched.push( elem );
+ if ( mapped ) {
+ map.push( i );
+ }
+ }
+ }
+ }
+
+ return newUnmatched;
+}
+
+function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
+ if ( postFilter && !postFilter[ expando ] ) {
+ postFilter = setMatcher( postFilter );
+ }
+ if ( postFinder && !postFinder[ expando ] ) {
+ postFinder = setMatcher( postFinder, postSelector );
+ }
+ return markFunction(function( seed, results, context, xml ) {
+ var temp, i, elem,
+ preMap = [],
+ postMap = [],
+ preexisting = results.length,
+
+ // Get initial elements from seed or context
+ elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
+
+ // Prefilter to get matcher input, preserving a map for seed-results synchronization
+ matcherIn = preFilter && ( seed || !selector ) ?
+ condense( elems, preMap, preFilter, context, xml ) :
+ elems,
+
+ matcherOut = matcher ?
+ // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
+ postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
+
+ // ...intermediate processing is necessary
+ [] :
+
+ // ...otherwise use results directly
+ results :
+ matcherIn;
+
+ // Find primary matches
+ if ( matcher ) {
+ matcher( matcherIn, matcherOut, context, xml );
+ }
+
+ // Apply postFilter
+ if ( postFilter ) {
+ temp = condense( matcherOut, postMap );
+ postFilter( temp, [], context, xml );
+
+ // Un-match failing elements by moving them back to matcherIn
+ i = temp.length;
+ while ( i-- ) {
+ if ( (elem = temp[i]) ) {
+ matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
+ }
+ }
+ }
+
+ if ( seed ) {
+ if ( postFinder || preFilter ) {
+ if ( postFinder ) {
+ // Get the final matcherOut by condensing this intermediate into postFinder contexts
+ temp = [];
+ i = matcherOut.length;
+ while ( i-- ) {
+ if ( (elem = matcherOut[i]) ) {
+ // Restore matcherIn since elem is not yet a final match
+ temp.push( (matcherIn[i] = elem) );
+ }
+ }
+ postFinder( null, (matcherOut = []), temp, xml );
+ }
+
+ // Move matched elements from seed to results to keep them synchronized
+ i = matcherOut.length;
+ while ( i-- ) {
+ if ( (elem = matcherOut[i]) &&
+ (temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {
+
+ seed[temp] = !(results[temp] = elem);
+ }
+ }
+ }
+
+ // Add elements to results, through postFinder if defined
+ } else {
+ matcherOut = condense(
+ matcherOut === results ?
+ matcherOut.splice( preexisting, matcherOut.length ) :
+ matcherOut
+ );
+ if ( postFinder ) {
+ postFinder( null, results, matcherOut, xml );
+ } else {
+ push.apply( results, matcherOut );
+ }
+ }
+ });
+}
+
+function matcherFromTokens( tokens ) {
+ var checkContext, matcher, j,
+ len = tokens.length,
+ leadingRelative = Expr.relative[ tokens[0].type ],
+ implicitRelative = leadingRelative || Expr.relative[" "],
+ i = leadingRelative ? 1 : 0,
+
+ // The foundational matcher ensures that elements are reachable from top-level context(s)
+ matchContext = addCombinator( function( elem ) {
+ return elem === checkContext;
+ }, implicitRelative, true ),
+ matchAnyContext = addCombinator( function( elem ) {
+ return indexOf( checkContext, elem ) > -1;
+ }, implicitRelative, true ),
+ matchers = [ function( elem, context, xml ) {
+ var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
+ (checkContext = context).nodeType ?
+ matchContext( elem, context, xml ) :
+ matchAnyContext( elem, context, xml ) );
+ // Avoid hanging onto element (issue #299)
+ checkContext = null;
+ return ret;
+ } ];
+
+ for ( ; i < len; i++ ) {
+ if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
+ matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
+ } else {
+ matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
+
+ // Return special upon seeing a positional matcher
+ if ( matcher[ expando ] ) {
+ // Find the next relative operator (if any) for proper handling
+ j = ++i;
+ for ( ; j < len; j++ ) {
+ if ( Expr.relative[ tokens[j].type ] ) {
+ break;
+ }
+ }
+ return setMatcher(
+ i > 1 && elementMatcher( matchers ),
+ i > 1 && toSelector(
+ // If the preceding token was a descendant combinator, insert an implicit any-element `*`
+ tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
+ ).replace( rtrim, "$1" ),
+ matcher,
+ i < j && matcherFromTokens( tokens.slice( i, j ) ),
+ j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
+ j < len && toSelector( tokens )
+ );
+ }
+ matchers.push( matcher );
+ }
+ }
+
+ return elementMatcher( matchers );
+}
+
+function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
+ var bySet = setMatchers.length > 0,
+ byElement = elementMatchers.length > 0,
+ superMatcher = function( seed, context, xml, results, outermost ) {
+ var elem, j, matcher,
+ matchedCount = 0,
+ i = "0",
+ unmatched = seed && [],
+ setMatched = [],
+ contextBackup = outermostContext,
+ // We must always have either seed elements or outermost context
+ elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
+ // Use integer dirruns iff this is the outermost matcher
+ dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
+ len = elems.length;
+
+ if ( outermost ) {
+ outermostContext = context === document || context || outermost;
+ }
+
+ // Add elements passing elementMatchers directly to results
+ // Support: IE<9, Safari
+ // Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
+ for ( ; i !== len && (elem = elems[i]) != null; i++ ) {
+ if ( byElement && elem ) {
+ j = 0;
+ if ( !context && elem.ownerDocument !== document ) {
+ setDocument( elem );
+ xml = !documentIsHTML;
+ }
+ while ( (matcher = elementMatchers[j++]) ) {
+ if ( matcher( elem, context || document, xml) ) {
+ results.push( elem );
+ break;
+ }
+ }
+ if ( outermost ) {
+ dirruns = dirrunsUnique;
+ }
+ }
+
+ // Track unmatched elements for set filters
+ if ( bySet ) {
+ // They will have gone through all possible matchers
+ if ( (elem = !matcher && elem) ) {
+ matchedCount--;
+ }
+
+ // Lengthen the array for every element, matched or not
+ if ( seed ) {
+ unmatched.push( elem );
+ }
+ }
+ }
+
+ // `i` is now the count of elements visited above, and adding it to `matchedCount`
+ // makes the latter nonnegative.
+ matchedCount += i;
+
+ // Apply set filters to unmatched elements
+ // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
+ // equals `i`), unless we didn't visit _any_ elements in the above loop because we have
+ // no element matchers and no seed.
+ // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
+ // case, which will result in a "00" `matchedCount` that differs from `i` but is also
+ // numerically zero.
+ if ( bySet && i !== matchedCount ) {
+ j = 0;
+ while ( (matcher = setMatchers[j++]) ) {
+ matcher( unmatched, setMatched, context, xml );
+ }
+
+ if ( seed ) {
+ // Reintegrate element matches to eliminate the need for sorting
+ if ( matchedCount > 0 ) {
+ while ( i-- ) {
+ if ( !(unmatched[i] || setMatched[i]) ) {
+ setMatched[i] = pop.call( results );
+ }
+ }
+ }
+
+ // Discard index placeholder values to get only actual matches
+ setMatched = condense( setMatched );
+ }
+
+ // Add matches to results
+ push.apply( results, setMatched );
+
+ // Seedless set matches succeeding multiple successful matchers stipulate sorting
+ if ( outermost && !seed && setMatched.length > 0 &&
+ ( matchedCount + setMatchers.length ) > 1 ) {
+
+ Sizzle.uniqueSort( results );
+ }
+ }
+
+ // Override manipulation of globals by nested matchers
+ if ( outermost ) {
+ dirruns = dirrunsUnique;
+ outermostContext = contextBackup;
+ }
+
+ return unmatched;
+ };
+
+ return bySet ?
+ markFunction( superMatcher ) :
+ superMatcher;
+}
+
+compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
+ var i,
+ setMatchers = [],
+ elementMatchers = [],
+ cached = compilerCache[ selector + " " ];
+
+ if ( !cached ) {
+ // Generate a function of recursive functions that can be used to check each element
+ if ( !match ) {
+ match = tokenize( selector );
+ }
+ i = match.length;
+ while ( i-- ) {
+ cached = matcherFromTokens( match[i] );
+ if ( cached[ expando ] ) {
+ setMatchers.push( cached );
+ } else {
+ elementMatchers.push( cached );
+ }
+ }
+
+ // Cache the compiled function
+ cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
+
+ // Save selector and tokenization
+ cached.selector = selector;
+ }
+ return cached;
+};
+
+/**
+ * A low-level selection function that works with Sizzle's compiled
+ * selector functions
+ * @param {String|Function} selector A selector or a pre-compiled
+ * selector function built with Sizzle.compile
+ * @param {Element} context
+ * @param {Array} [results]
+ * @param {Array} [seed] A set of elements to match against
+ */
+select = Sizzle.select = function( selector, context, results, seed ) {
+ var i, tokens, token, type, find,
+ compiled = typeof selector === "function" && selector,
+ match = !seed && tokenize( (selector = compiled.selector || selector) );
+
+ results = results || [];
+
+ // Try to minimize operations if there is only one selector in the list and no seed
+ // (the latter of which guarantees us context)
+ if ( match.length === 1 ) {
+
+ // Reduce context if the leading compound selector is an ID
+ tokens = match[0] = match[0].slice( 0 );
+ if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
+ context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[1].type ] ) {
+
+ context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
+ if ( !context ) {
+ return results;
+
+ // Precompiled matchers will still verify ancestry, so step up a level
+ } else if ( compiled ) {
+ context = context.parentNode;
+ }
+
+ selector = selector.slice( tokens.shift().value.length );
+ }
+
+ // Fetch a seed set for right-to-left matching
+ i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
+ while ( i-- ) {
+ token = tokens[i];
+
+ // Abort if we hit a combinator
+ if ( Expr.relative[ (type = token.type) ] ) {
+ break;
+ }
+ if ( (find = Expr.find[ type ]) ) {
+ // Search, expanding context for leading sibling combinators
+ if ( (seed = find(
+ token.matches[0].replace( runescape, funescape ),
+ rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context
+ )) ) {
+
+ // If seed is empty or no tokens remain, we can return early
+ tokens.splice( i, 1 );
+ selector = seed.length && toSelector( tokens );
+ if ( !selector ) {
+ push.apply( results, seed );
+ return results;
+ }
+
+ break;
+ }
+ }
+ }
+ }
+
+ // Compile and execute a filtering function if one is not provided
+ // Provide `match` to avoid retokenization if we modified the selector above
+ ( compiled || compile( selector, match ) )(
+ seed,
+ context,
+ !documentIsHTML,
+ results,
+ !context || rsibling.test( selector ) && testContext( context.parentNode ) || context
+ );
+ return results;
+};
+
+// One-time assignments
+
+// Sort stability
+support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
+
+// Support: Chrome 14-35+
+// Always assume duplicates if they aren't passed to the comparison function
+support.detectDuplicates = !!hasDuplicate;
+
+// Initialize against the default document
+setDocument();
+
+// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
+// Detached nodes confoundingly follow *each other*
+support.sortDetached = assert(function( el ) {
+ // Should return 1, but returns 4 (following)
+ return el.compareDocumentPosition( document.createElement("fieldset") ) & 1;
+});
+
+// Support: IE<8
+// Prevent attribute/property "interpolation"
+// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
+if ( !assert(function( el ) {
+ el.innerHTML = "<a href='#'></a>";
+ return el.firstChild.getAttribute("href") === "#" ;
+}) ) {
+ addHandle( "type|href|height|width", function( elem, name, isXML ) {
+ if ( !isXML ) {
+ return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
+ }
+ });
+}
+
+// Support: IE<9
+// Use defaultValue in place of getAttribute("value")
+if ( !support.attributes || !assert(function( el ) {
+ el.innerHTML = "<input/>";
+ el.firstChild.setAttribute( "value", "" );
+ return el.firstChild.getAttribute( "value" ) === "";
+}) ) {
+ addHandle( "value", function( elem, name, isXML ) {
+ if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
+ return elem.defaultValue;
+ }
+ });
+}
+
+// Support: IE<9
+// Use getAttributeNode to fetch booleans when getAttribute lies
+if ( !assert(function( el ) {
+ return el.getAttribute("disabled") == null;
+}) ) {
+ addHandle( booleans, function( elem, name, isXML ) {
+ var val;
+ if ( !isXML ) {
+ return elem[ name ] === true ? name.toLowerCase() :
+ (val = elem.getAttributeNode( name )) && val.specified ?
+ val.value :
+ null;
+ }
+ });
+}
+
+return Sizzle;
+
+})( window );
+
+
+
+jQuery.find = Sizzle;
+jQuery.expr = Sizzle.selectors;
+
+// Deprecated
+jQuery.expr[ ":" ] = jQuery.expr.pseudos;
+jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
+jQuery.text = Sizzle.getText;
+jQuery.isXMLDoc = Sizzle.isXML;
+jQuery.contains = Sizzle.contains;
+jQuery.escapeSelector = Sizzle.escape;
+
+
+
+
+var dir = function( elem, dir, until ) {
+ var matched = [],
+ truncate = until !== undefined;
+
+ while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
+ if ( elem.nodeType === 1 ) {
+ if ( truncate && jQuery( elem ).is( until ) ) {
+ break;
+ }
+ matched.push( elem );
+ }
+ }
+ return matched;
+};
+
+
+var siblings = function( n, elem ) {
+ var matched = [];
+
+ for ( ; n; n = n.nextSibling ) {
+ if ( n.nodeType === 1 && n !== elem ) {
+ matched.push( n );
+ }
+ }
+
+ return matched;
+};
+
+
+var rneedsContext = jQuery.expr.match.needsContext;
+
+
+
+function nodeName( elem, name ) {
+
+ return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
+
+};
+var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i );
+
+
+
+var risSimple = /^.[^:#\[\.,]*$/;
+
+// Implement the identical functionality for filter and not
+function winnow( elements, qualifier, not ) {
+ if ( jQuery.isFunction( qualifier ) ) {
+ return jQuery.grep( elements, function( elem, i ) {
+ return !!qualifier.call( elem, i, elem ) !== not;
+ } );
+ }
+
+ // Single element
+ if ( qualifier.nodeType ) {
+ return jQuery.grep( elements, function( elem ) {
+ return ( elem === qualifier ) !== not;
+ } );
+ }
+
+ // Arraylike of elements (jQuery, arguments, Array)
+ if ( typeof qualifier !== "string" ) {
+ return jQuery.grep( elements, function( elem ) {
+ return ( indexOf.call( qualifier, elem ) > -1 ) !== not;
+ } );
+ }
+
+ // Simple selector that can be filtered directly, removing non-Elements
+ if ( risSimple.test( qualifier ) ) {
+ return jQuery.filter( qualifier, elements, not );
+ }
+
+ // Complex selector, compare the two sets, removing non-Elements
+ qualifier = jQuery.filter( qualifier, elements );
+ return jQuery.grep( elements, function( elem ) {
+ return ( indexOf.call( qualifier, elem ) > -1 ) !== not && elem.nodeType === 1;
+ } );
+}
+
+jQuery.filter = function( expr, elems, not ) {
+ var elem = elems[ 0 ];
+
+ if ( not ) {
+ expr = ":not(" + expr + ")";
+ }
+
+ if ( elems.length === 1 && elem.nodeType === 1 ) {
+ return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];
+ }
+
+ return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
+ return elem.nodeType === 1;
+ } ) );
+};
+
+jQuery.fn.extend( {
+ find: function( selector ) {
+ var i, ret,
+ len = this.length,
+ self = this;
+
+ if ( typeof selector !== "string" ) {
+ return this.pushStack( jQuery( selector ).filter( function() {
+ for ( i = 0; i < len; i++ ) {
+ if ( jQuery.contains( self[ i ], this ) ) {
+ return true;
+ }
+ }
+ } ) );
+ }
+
+ ret = this.pushStack( [] );
+
+ for ( i = 0; i < len; i++ ) {
+ jQuery.find( selector, self[ i ], ret );
+ }
+
+ return len > 1 ? jQuery.uniqueSort( ret ) : ret;
+ },
+ filter: function( selector ) {
+ return this.pushStack( winnow( this, selector || [], false ) );
+ },
+ not: function( selector ) {
+ return this.pushStack( winnow( this, selector || [], true ) );
+ },
+ is: function( selector ) {
+ return !!winnow(
+ this,
+
+ // If this is a positional/relative selector, check membership in the returned set
+ // so $("p:first").is("p:last") won't return true for a doc with two "p".
+ typeof selector === "string" && rneedsContext.test( selector ) ?
+ jQuery( selector ) :
+ selector || [],
+ false
+ ).length;
+ }
+} );
+
+
+// Initialize a jQuery object
+
+
+// A central reference to the root jQuery(document)
+var rootjQuery,
+
+ // A simple way to check for HTML strings
+ // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
+ // Strict HTML recognition (#11290: must start with <)
+ // Shortcut simple #id case for speed
+ rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,
+
+ init = jQuery.fn.init = function( selector, context, root ) {
+ var match, elem;
+
+ // HANDLE: $(""), $(null), $(undefined), $(false)
+ if ( !selector ) {
+ return this;
+ }
+
+ // Method init() accepts an alternate rootjQuery
+ // so migrate can support jQuery.sub (gh-2101)
+ root = root || rootjQuery;
+
+ // Handle HTML strings
+ if ( typeof selector === "string" ) {
+ if ( selector[ 0 ] === "<" &&
+ selector[ selector.length - 1 ] === ">" &&
+ selector.length >= 3 ) {
+
+ // Assume that strings that start and end with <> are HTML and skip the regex check
+ match = [ null, selector, null ];
+
+ } else {
+ match = rquickExpr.exec( selector );
+ }
+
+ // Match html or make sure no context is specified for #id
+ if ( match && ( match[ 1 ] || !context ) ) {
+
+ // HANDLE: $(html) -> $(array)
+ if ( match[ 1 ] ) {
+ context = context instanceof jQuery ? context[ 0 ] : context;
+
+ // Option to run scripts is true for back-compat
+ // Intentionally let the error be thrown if parseHTML is not present
+ jQuery.merge( this, jQuery.parseHTML(
+ match[ 1 ],
+ context && context.nodeType ? context.ownerDocument || context : document,
+ true
+ ) );
+
+ // HANDLE: $(html, props)
+ if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {
+ for ( match in context ) {
+
+ // Properties of context are called as methods if possible
+ if ( jQuery.isFunction( this[ match ] ) ) {
+ this[ match ]( context[ match ] );
+
+ // ...and otherwise set as attributes
+ } else {
+ this.attr( match, context[ match ] );
+ }
+ }
+ }
+
+ return this;
+
+ // HANDLE: $(#id)
+ } else {
+ elem = document.getElementById( match[ 2 ] );
+
+ if ( elem ) {
+
+ // Inject the element directly into the jQuery object
+ this[ 0 ] = elem;
+ this.length = 1;
+ }
+ return this;
+ }
+
+ // HANDLE: $(expr, $(...))
+ } else if ( !context || context.jquery ) {
+ return ( context || root ).find( selector );
+
+ // HANDLE: $(expr, context)
+ // (which is just equivalent to: $(context).find(expr)
+ } else {
+ return this.constructor( context ).find( selector );
+ }
+
+ // HANDLE: $(DOMElement)
+ } else if ( selector.nodeType ) {
+ this[ 0 ] = selector;
+ this.length = 1;
+ return this;
+
+ // HANDLE: $(function)
+ // Shortcut for document ready
+ } else if ( jQuery.isFunction( selector ) ) {
+ return root.ready !== undefined ?
+ root.ready( selector ) :
+
+ // Execute immediately if ready is not present
+ selector( jQuery );
+ }
+
+ return jQuery.makeArray( selector, this );
+ };
+
+// Give the init function the jQuery prototype for later instantiation
+init.prototype = jQuery.fn;
+
+// Initialize central reference
+rootjQuery = jQuery( document );
+
+
+var rparentsprev = /^(?:parents|prev(?:Until|All))/,
+
+ // Methods guaranteed to produce a unique set when starting from a unique set
+ guaranteedUnique = {
+ children: true,
+ contents: true,
+ next: true,
+ prev: true
+ };
+
+jQuery.fn.extend( {
+ has: function( target ) {
+ var targets = jQuery( target, this ),
+ l = targets.length;
+
+ return this.filter( function() {
+ var i = 0;
+ for ( ; i < l; i++ ) {
+ if ( jQuery.contains( this, targets[ i ] ) ) {
+ return true;
+ }
+ }
+ } );
+ },
+
+ closest: function( selectors, context ) {
+ var cur,
+ i = 0,
+ l = this.length,
+ matched = [],
+ targets = typeof selectors !== "string" && jQuery( selectors );
+
+ // Positional selectors never match, since there's no _selection_ context
+ if ( !rneedsContext.test( selectors ) ) {
+ for ( ; i < l; i++ ) {
+ for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {
+
+ // Always skip document fragments
+ if ( cur.nodeType < 11 && ( targets ?
+ targets.index( cur ) > -1 :
+
+ // Don't pass non-elements to Sizzle
+ cur.nodeType === 1 &&
+ jQuery.find.matchesSelector( cur, selectors ) ) ) {
+
+ matched.push( cur );
+ break;
+ }
+ }
+ }
+ }
+
+ return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );
+ },
+
+ // Determine the position of an element within the set
+ index: function( elem ) {
+
+ // No argument, return index in parent
+ if ( !elem ) {
+ return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
+ }
+
+ // Index in selector
+ if ( typeof elem === "string" ) {
+ return indexOf.call( jQuery( elem ), this[ 0 ] );
+ }
+
+ // Locate the position of the desired element
+ return indexOf.call( this,
+
+ // If it receives a jQuery object, the first element is used
+ elem.jquery ? elem[ 0 ] : elem
+ );
+ },
+
+ add: function( selector, context ) {
+ return this.pushStack(
+ jQuery.uniqueSort(
+ jQuery.merge( this.get(), jQuery( selector, context ) )
+ )
+ );
+ },
+
+ addBack: function( selector ) {
+ return this.add( selector == null ?
+ this.prevObject : this.prevObject.filter( selector )
+ );
+ }
+} );
+
+function sibling( cur, dir ) {
+ while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}
+ return cur;
+}
+
+jQuery.each( {
+ parent: function( elem ) {
+ var parent = elem.parentNode;
+ return parent && parent.nodeType !== 11 ? parent : null;
+ },
+ parents: function( elem ) {
+ return dir( elem, "parentNode" );
+ },
+ parentsUntil: function( elem, i, until ) {
+ return dir( elem, "parentNode", until );
+ },
+ next: function( elem ) {
+ return sibling( elem, "nextSibling" );
+ },
+ prev: function( elem ) {
+ return sibling( elem, "previousSibling" );
+ },
+ nextAll: function( elem ) {
+ return dir( elem, "nextSibling" );
+ },
+ prevAll: function( elem ) {
+ return dir( elem, "previousSibling" );
+ },
+ nextUntil: function( elem, i, until ) {
+ return dir( elem, "nextSibling", until );
+ },
+ prevUntil: function( elem, i, until ) {
+ return dir( elem, "previousSibling", until );
+ },
+ siblings: function( elem ) {
+ return siblings( ( elem.parentNode || {} ).firstChild, elem );
+ },
+ children: function( elem ) {
+ return siblings( elem.firstChild );
+ },
+ contents: function( elem ) {
+ if ( nodeName( elem, "iframe" ) ) {
+ return elem.contentDocument;
+ }
+
+ // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only
+ // Treat the template element as a regular one in browsers that
+ // don't support it.
+ if ( nodeName( elem, "template" ) ) {
+ elem = elem.content || elem;
+ }
+
+ return jQuery.merge( [], elem.childNodes );
+ }
+}, function( name, fn ) {
+ jQuery.fn[ name ] = function( until, selector ) {
+ var matched = jQuery.map( this, fn, until );
+
+ if ( name.slice( -5 ) !== "Until" ) {
+ selector = until;
+ }
+
+ if ( selector && typeof selector === "string" ) {
+ matched = jQuery.filter( selector, matched );
+ }
+
+ if ( this.length > 1 ) {
+
+ // Remove duplicates
+ if ( !guaranteedUnique[ name ] ) {
+ jQuery.uniqueSort( matched );
+ }
+
+ // Reverse order for parents* and prev-derivatives
+ if ( rparentsprev.test( name ) ) {
+ matched.reverse();
+ }
+ }
+
+ return this.pushStack( matched );
+ };
+} );
+var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g );
+
+
+
+// Convert String-formatted options into Object-formatted ones
+function createOptions( options ) {
+ var object = {};
+ jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {
+ object[ flag ] = true;
+ } );
+ return object;
+}
+
+/*
+ * Create a callback list using the following parameters:
+ *
+ * options: an optional list of space-separated options that will change how
+ * the callback list behaves or a more traditional option object
+ *
+ * By default a callback list will act like an event callback list and can be
+ * "fired" multiple times.
+ *
+ * Possible options:
+ *
+ * once: will ensure the callback list can only be fired once (like a Deferred)
+ *
+ * memory: will keep track of previous values and will call any callback added
+ * after the list has been fired right away with the latest "memorized"
+ * values (like a Deferred)
+ *
+ * unique: will ensure a callback can only be added once (no duplicate in the list)
+ *
+ * stopOnFalse: interrupt callings when a callback returns false
+ *
+ */
+jQuery.Callbacks = function( options ) {
+
+ // Convert options from String-formatted to Object-formatted if needed
+ // (we check in cache first)
+ options = typeof options === "string" ?
+ createOptions( options ) :
+ jQuery.extend( {}, options );
+
+ var // Flag to know if list is currently firing
+ firing,
+
+ // Last fire value for non-forgettable lists
+ memory,
+
+ // Flag to know if list was already fired
+ fired,
+
+ // Flag to prevent firing
+ locked,
+
+ // Actual callback list
+ list = [],
+
+ // Queue of execution data for repeatable lists
+ queue = [],
+
+ // Index of currently firing callback (modified by add/remove as needed)
+ firingIndex = -1,
+
+ // Fire callbacks
+ fire = function() {
+
+ // Enforce single-firing
+ locked = locked || options.once;
+
+ // Execute callbacks for all pending executions,
+ // respecting firingIndex overrides and runtime changes
+ fired = firing = true;
+ for ( ; queue.length; firingIndex = -1 ) {
+ memory = queue.shift();
+ while ( ++firingIndex < list.length ) {
+
+ // Run callback and check for early termination
+ if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&
+ options.stopOnFalse ) {
+
+ // Jump to end and forget the data so .add doesn't re-fire
+ firingIndex = list.length;
+ memory = false;
+ }
+ }
+ }
+
+ // Forget the data if we're done with it
+ if ( !options.memory ) {
+ memory = false;
+ }
+
+ firing = false;
+
+ // Clean up if we're done firing for good
+ if ( locked ) {
+
+ // Keep an empty list if we have data for future add calls
+ if ( memory ) {
+ list = [];
+
+ // Otherwise, this object is spent
+ } else {
+ list = "";
+ }
+ }
+ },
+
+ // Actual Callbacks object
+ self = {
+
+ // Add a callback or a collection of callbacks to the list
+ add: function() {
+ if ( list ) {
+
+ // If we have memory from a past run, we should fire after adding
+ if ( memory && !firing ) {
+ firingIndex = list.length - 1;
+ queue.push( memory );
+ }
+
+ ( function add( args ) {
+ jQuery.each( args, function( _, arg ) {
+ if ( jQuery.isFunction( arg ) ) {
+ if ( !options.unique || !self.has( arg ) ) {
+ list.push( arg );
+ }
+ } else if ( arg && arg.length && jQuery.type( arg ) !== "string" ) {
+
+ // Inspect recursively
+ add( arg );
+ }
+ } );
+ } )( arguments );
+
+ if ( memory && !firing ) {
+ fire();
+ }
+ }
+ return this;
+ },
+
+ // Remove a callback from the list
+ remove: function() {
+ jQuery.each( arguments, function( _, arg ) {
+ var index;
+ while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
+ list.splice( index, 1 );
+
+ // Handle firing indexes
+ if ( index <= firingIndex ) {
+ firingIndex--;
+ }
+ }
+ } );
+ return this;
+ },
+
+ // Check if a given callback is in the list.
+ // If no argument is given, return whether or not list has callbacks attached.
+ has: function( fn ) {
+ return fn ?
+ jQuery.inArray( fn, list ) > -1 :
+ list.length > 0;
+ },
+
+ // Remove all callbacks from the list
+ empty: function() {
+ if ( list ) {
+ list = [];
+ }
+ return this;
+ },
+
+ // Disable .fire and .add
+ // Abort any current/pending executions
+ // Clear all callbacks and values
+ disable: function() {
+ locked = queue = [];
+ list = memory = "";
+ return this;
+ },
+ disabled: function() {
+ return !list;
+ },
+
+ // Disable .fire
+ // Also disable .add unless we have memory (since it would have no effect)
+ // Abort any pending executions
+ lock: function() {
+ locked = queue = [];
+ if ( !memory && !firing ) {
+ list = memory = "";
+ }
+ return this;
+ },
+ locked: function() {
+ return !!locked;
+ },
+
+ // Call all callbacks with the given context and arguments
+ fireWith: function( context, args ) {
+ if ( !locked ) {
+ args = args || [];
+ args = [ context, args.slice ? args.slice() : args ];
+ queue.push( args );
+ if ( !firing ) {
+ fire();
+ }
+ }
+ return this;
+ },
+
+ // Call all the callbacks with the given arguments
+ fire: function() {
+ self.fireWith( this, arguments );
+ return this;
+ },
+
+ // To know if the callbacks have already been called at least once
+ fired: function() {
+ return !!fired;
+ }
+ };
+
+ return self;
+};
+
+
+function Identity( v ) {
+ return v;
+}
+function Thrower( ex ) {
+ throw ex;
+}
+
+function adoptValue( value, resolve, reject, noValue ) {
+ var method;
+
+ try {
+
+ // Check for promise aspect first to privilege synchronous behavior
+ if ( value && jQuery.isFunction( ( method = value.promise ) ) ) {
+ method.call( value ).done( resolve ).fail( reject );
+
+ // Other thenables
+ } else if ( value && jQuery.isFunction( ( method = value.then ) ) ) {
+ method.call( value, resolve, reject );
+
+ // Other non-thenables
+ } else {
+
+ // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:
+ // * false: [ value ].slice( 0 ) => resolve( value )
+ // * true: [ value ].slice( 1 ) => resolve()
+ resolve.apply( undefined, [ value ].slice( noValue ) );
+ }
+
+ // For Promises/A+, convert exceptions into rejections
+ // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in
+ // Deferred#then to conditionally suppress rejection.
+ } catch ( value ) {
+
+ // Support: Android 4.0 only
+ // Strict mode functions invoked without .call/.apply get global-object context
+ reject.apply( undefined, [ value ] );
+ }
+}
+
+jQuery.extend( {
+
+ Deferred: function( func ) {
+ var tuples = [
+
+ // action, add listener, callbacks,
+ // ... .then handlers, argument index, [final state]
+ [ "notify", "progress", jQuery.Callbacks( "memory" ),
+ jQuery.Callbacks( "memory" ), 2 ],
+ [ "resolve", "done", jQuery.Callbacks( "once memory" ),
+ jQuery.Callbacks( "once memory" ), 0, "resolved" ],
+ [ "reject", "fail", jQuery.Callbacks( "once memory" ),
+ jQuery.Callbacks( "once memory" ), 1, "rejected" ]
+ ],
+ state = "pending",
+ promise = {
+ state: function() {
+ return state;
+ },
+ always: function() {
+ deferred.done( arguments ).fail( arguments );
+ return this;
+ },
+ "catch": function( fn ) {
+ return promise.then( null, fn );
+ },
+
+ // Keep pipe for back-compat
+ pipe: function( /* fnDone, fnFail, fnProgress */ ) {
+ var fns = arguments;
+
+ return jQuery.Deferred( function( newDefer ) {
+ jQuery.each( tuples, function( i, tuple ) {
+
+ // Map tuples (progress, done, fail) to arguments (done, fail, progress)
+ var fn = jQuery.isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];
+
+ // deferred.progress(function() { bind to newDefer or newDefer.notify })
+ // deferred.done(function() { bind to newDefer or newDefer.resolve })
+ // deferred.fail(function() { bind to newDefer or newDefer.reject })
+ deferred[ tuple[ 1 ] ]( function() {
+ var returned = fn && fn.apply( this, arguments );
+ if ( returned && jQuery.isFunction( returned.promise ) ) {
+ returned.promise()
+ .progress( newDefer.notify )
+ .done( newDefer.resolve )
+ .fail( newDefer.reject );
+ } else {
+ newDefer[ tuple[ 0 ] + "With" ](
+ this,
+ fn ? [ returned ] : arguments
+ );
+ }
+ } );
+ } );
+ fns = null;
+ } ).promise();
+ },
+ then: function( onFulfilled, onRejected, onProgress ) {
+ var maxDepth = 0;
+ function resolve( depth, deferred, handler, special ) {
+ return function() {
+ var that = this,
+ args = arguments,
+ mightThrow = function() {
+ var returned, then;
+
+ // Support: Promises/A+ section 2.3.3.3.3
+ // https://promisesaplus.com/#point-59
+ // Ignore double-resolution attempts
+ if ( depth < maxDepth ) {
+ return;
+ }
+
+ returned = handler.apply( that, args );
+
+ // Support: Promises/A+ section 2.3.1
+ // https://promisesaplus.com/#point-48
+ if ( returned === deferred.promise() ) {
+ throw new TypeError( "Thenable self-resolution" );
+ }
+
+ // Support: Promises/A+ sections 2.3.3.1, 3.5
+ // https://promisesaplus.com/#point-54
+ // https://promisesaplus.com/#point-75
+ // Retrieve `then` only once
+ then = returned &&
+
+ // Support: Promises/A+ section 2.3.4
+ // https://promisesaplus.com/#point-64
+ // Only check objects and functions for thenability
+ ( typeof returned === "object" ||
+ typeof returned === "function" ) &&
+ returned.then;
+
+ // Handle a returned thenable
+ if ( jQuery.isFunction( then ) ) {
+
+ // Special processors (notify) just wait for resolution
+ if ( special ) {
+ then.call(
+ returned,
+ resolve( maxDepth, deferred, Identity, special ),
+ resolve( maxDepth, deferred, Thrower, special )
+ );
+
+ // Normal processors (resolve) also hook into progress
+ } else {
+
+ // ...and disregard older resolution values
+ maxDepth++;
+
+ then.call(
+ returned,
+ resolve( maxDepth, deferred, Identity, special ),
+ resolve( maxDepth, deferred, Thrower, special ),
+ resolve( maxDepth, deferred, Identity,
+ deferred.notifyWith )
+ );
+ }
+
+ // Handle all other returned values
+ } else {
+
+ // Only substitute handlers pass on context
+ // and multiple values (non-spec behavior)
+ if ( handler !== Identity ) {
+ that = undefined;
+ args = [ returned ];
+ }
+
+ // Process the value(s)
+ // Default process is resolve
+ ( special || deferred.resolveWith )( that, args );
+ }
+ },
+
+ // Only normal processors (resolve) catch and reject exceptions
+ process = special ?
+ mightThrow :
+ function() {
+ try {
+ mightThrow();
+ } catch ( e ) {
+
+ if ( jQuery.Deferred.exceptionHook ) {
+ jQuery.Deferred.exceptionHook( e,
+ process.stackTrace );
+ }
+
+ // Support: Promises/A+ section 2.3.3.3.4.1
+ // https://promisesaplus.com/#point-61
+ // Ignore post-resolution exceptions
+ if ( depth + 1 >= maxDepth ) {
+
+ // Only substitute handlers pass on context
+ // and multiple values (non-spec behavior)
+ if ( handler !== Thrower ) {
+ that = undefined;
+ args = [ e ];
+ }
+
+ deferred.rejectWith( that, args );
+ }
+ }
+ };
+
+ // Support: Promises/A+ section 2.3.3.3.1
+ // https://promisesaplus.com/#point-57
+ // Re-resolve promises immediately to dodge false rejection from
+ // subsequent errors
+ if ( depth ) {
+ process();
+ } else {
+
+ // Call an optional hook to record the stack, in case of exception
+ // since it's otherwise lost when execution goes async
+ if ( jQuery.Deferred.getStackHook ) {
+ process.stackTrace = jQuery.Deferred.getStackHook();
+ }
+ window.setTimeout( process );
+ }
+ };
+ }
+
+ return jQuery.Deferred( function( newDefer ) {
+
+ // progress_handlers.add( ... )
+ tuples[ 0 ][ 3 ].add(
+ resolve(
+ 0,
+ newDefer,
+ jQuery.isFunction( onProgress ) ?
+ onProgress :
+ Identity,
+ newDefer.notifyWith
+ )
+ );
+
+ // fulfilled_handlers.add( ... )
+ tuples[ 1 ][ 3 ].add(
+ resolve(
+ 0,
+ newDefer,
+ jQuery.isFunction( onFulfilled ) ?
+ onFulfilled :
+ Identity
+ )
+ );
+
+ // rejected_handlers.add( ... )
+ tuples[ 2 ][ 3 ].add(
+ resolve(
+ 0,
+ newDefer,
+ jQuery.isFunction( onRejected ) ?
+ onRejected :
+ Thrower
+ )
+ );
+ } ).promise();
+ },
+
+ // Get a promise for this deferred
+ // If obj is provided, the promise aspect is added to the object
+ promise: function( obj ) {
+ return obj != null ? jQuery.extend( obj, promise ) : promise;
+ }
+ },
+ deferred = {};
+
+ // Add list-specific methods
+ jQuery.each( tuples, function( i, tuple ) {
+ var list = tuple[ 2 ],
+ stateString = tuple[ 5 ];
+
+ // promise.progress = list.add
+ // promise.done = list.add
+ // promise.fail = list.add
+ promise[ tuple[ 1 ] ] = list.add;
+
+ // Handle state
+ if ( stateString ) {
+ list.add(
+ function() {
+
+ // state = "resolved" (i.e., fulfilled)
+ // state = "rejected"
+ state = stateString;
+ },
+
+ // rejected_callbacks.disable
+ // fulfilled_callbacks.disable
+ tuples[ 3 - i ][ 2 ].disable,
+
+ // progress_callbacks.lock
+ tuples[ 0 ][ 2 ].lock
+ );
+ }
+
+ // progress_handlers.fire
+ // fulfilled_handlers.fire
+ // rejected_handlers.fire
+ list.add( tuple[ 3 ].fire );
+
+ // deferred.notify = function() { deferred.notifyWith(...) }
+ // deferred.resolve = function() { deferred.resolveWith(...) }
+ // deferred.reject = function() { deferred.rejectWith(...) }
+ deferred[ tuple[ 0 ] ] = function() {
+ deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments );
+ return this;
+ };
+
+ // deferred.notifyWith = list.fireWith
+ // deferred.resolveWith = list.fireWith
+ // deferred.rejectWith = list.fireWith
+ deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
+ } );
+
+ // Make the deferred a promise
+ promise.promise( deferred );
+
+ // Call given func if any
+ if ( func ) {
+ func.call( deferred, deferred );
+ }
+
+ // All done!
+ return deferred;
+ },
+
+ // Deferred helper
+ when: function( singleValue ) {
+ var
+
+ // count of uncompleted subordinates
+ remaining = arguments.length,
+
+ // count of unprocessed arguments
+ i = remaining,
+
+ // subordinate fulfillment data
+ resolveContexts = Array( i ),
+ resolveValues = slice.call( arguments ),
+
+ // the master Deferred
+ master = jQuery.Deferred(),
+
+ // subordinate callback factory
+ updateFunc = function( i ) {
+ return function( value ) {
+ resolveContexts[ i ] = this;
+ resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
+ if ( !( --remaining ) ) {
+ master.resolveWith( resolveContexts, resolveValues );
+ }
+ };
+ };
+
+ // Single- and empty arguments are adopted like Promise.resolve
+ if ( remaining <= 1 ) {
+ adoptValue( singleValue, master.done( updateFunc( i ) ).resolve, master.reject,
+ !remaining );
+
+ // Use .then() to unwrap secondary thenables (cf. gh-3000)
+ if ( master.state() === "pending" ||
+ jQuery.isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {
+
+ return master.then();
+ }
+ }
+
+ // Multiple arguments are aggregated like Promise.all array elements
+ while ( i-- ) {
+ adoptValue( resolveValues[ i ], updateFunc( i ), master.reject );
+ }
+
+ return master.promise();
+ }
+} );
+
+
+// These usually indicate a programmer mistake during development,
+// warn about them ASAP rather than swallowing them by default.
+var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;
+
+jQuery.Deferred.exceptionHook = function( error, stack ) {
+
+ // Support: IE 8 - 9 only
+ // Console exists when dev tools are open, which can happen at any time
+ if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {
+ window.console.warn( "jQuery.Deferred exception: " + error.message, error.stack, stack );
+ }
+};
+
+
+
+
+jQuery.readyException = function( error ) {
+ window.setTimeout( function() {
+ throw error;
+ } );
+};
+
+
+
+
+// The deferred used on DOM ready
+var readyList = jQuery.Deferred();
+
+jQuery.fn.ready = function( fn ) {
+
+ readyList
+ .then( fn )
+
+ // Wrap jQuery.readyException in a function so that the lookup
+ // happens at the time of error handling instead of callback
+ // registration.
+ .catch( function( error ) {
+ jQuery.readyException( error );
+ } );
+
+ return this;
+};
+
+jQuery.extend( {
+
+ // Is the DOM ready to be used? Set to true once it occurs.
+ isReady: false,
+
+ // A counter to track how many items to wait for before
+ // the ready event fires. See #6781
+ readyWait: 1,
+
+ // Handle when the DOM is ready
+ ready: function( wait ) {
+
+ // Abort if there are pending holds or we're already ready
+ if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
+ return;
+ }
+
+ // Remember that the DOM is ready
+ jQuery.isReady = true;
+
+ // If a normal DOM Ready event fired, decrement, and wait if need be
+ if ( wait !== true && --jQuery.readyWait > 0 ) {
+ return;
+ }
+
+ // If there are functions bound, to execute
+ readyList.resolveWith( document, [ jQuery ] );
+ }
+} );
+
+jQuery.ready.then = readyList.then;
+
+// The ready event handler and self cleanup method
+function completed() {
+ document.removeEventListener( "DOMContentLoaded", completed );
+ window.removeEventListener( "load", completed );
+ jQuery.ready();
+}
+
+// Catch cases where $(document).ready() is called
+// after the browser event has already occurred.
+// Support: IE <=9 - 10 only
+// Older IE sometimes signals "interactive" too soon
+if ( document.readyState === "complete" ||
+ ( document.readyState !== "loading" && !document.documentElement.doScroll ) ) {
+
+ // Handle it asynchronously to allow scripts the opportunity to delay ready
+ window.setTimeout( jQuery.ready );
+
+} else {
+
+ // Use the handy event callback
+ document.addEventListener( "DOMContentLoaded", completed );
+
+ // A fallback to window.onload, that will always work
+ window.addEventListener( "load", completed );
+}
+
+
+
+
+// Multifunctional method to get and set values of a collection
+// The value/s can optionally be executed if it's a function
+var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
+ var i = 0,
+ len = elems.length,
+ bulk = key == null;
+
+ // Sets many values
+ if ( jQuery.type( key ) === "object" ) {
+ chainable = true;
+ for ( i in key ) {
+ access( elems, fn, i, key[ i ], true, emptyGet, raw );
+ }
+
+ // Sets one value
+ } else if ( value !== undefined ) {
+ chainable = true;
+
+ if ( !jQuery.isFunction( value ) ) {
+ raw = true;
+ }
+
+ if ( bulk ) {
+
+ // Bulk operations run against the entire set
+ if ( raw ) {
+ fn.call( elems, value );
+ fn = null;
+
+ // ...except when executing function values
+ } else {
+ bulk = fn;
+ fn = function( elem, key, value ) {
+ return bulk.call( jQuery( elem ), value );
+ };
+ }
+ }
+
+ if ( fn ) {
+ for ( ; i < len; i++ ) {
+ fn(
+ elems[ i ], key, raw ?
+ value :
+ value.call( elems[ i ], i, fn( elems[ i ], key ) )
+ );
+ }
+ }
+ }
+
+ if ( chainable ) {
+ return elems;
+ }
+
+ // Gets
+ if ( bulk ) {
+ return fn.call( elems );
+ }
+
+ return len ? fn( elems[ 0 ], key ) : emptyGet;
+};
+var acceptData = function( owner ) {
+
+ // Accepts only:
+ // - Node
+ // - Node.ELEMENT_NODE
+ // - Node.DOCUMENT_NODE
+ // - Object
+ // - Any
+ return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );
+};
+
+
+
+
+function Data() {
+ this.expando = jQuery.expando + Data.uid++;
+}
+
+Data.uid = 1;
+
+Data.prototype = {
+
+ cache: function( owner ) {
+
+ // Check if the owner object already has a cache
+ var value = owner[ this.expando ];
+
+ // If not, create one
+ if ( !value ) {
+ value = {};
+
+ // We can accept data for non-element nodes in modern browsers,
+ // but we should not, see #8335.
+ // Always return an empty object.
+ if ( acceptData( owner ) ) {
+
+ // If it is a node unlikely to be stringify-ed or looped over
+ // use plain assignment
+ if ( owner.nodeType ) {
+ owner[ this.expando ] = value;
+
+ // Otherwise secure it in a non-enumerable property
+ // configurable must be true to allow the property to be
+ // deleted when data is removed
+ } else {
+ Object.defineProperty( owner, this.expando, {
+ value: value,
+ configurable: true
+ } );
+ }
+ }
+ }
+
+ return value;
+ },
+ set: function( owner, data, value ) {
+ var prop,
+ cache = this.cache( owner );
+
+ // Handle: [ owner, key, value ] args
+ // Always use camelCase key (gh-2257)
+ if ( typeof data === "string" ) {
+ cache[ jQuery.camelCase( data ) ] = value;
+
+ // Handle: [ owner, { properties } ] args
+ } else {
+
+ // Copy the properties one-by-one to the cache object
+ for ( prop in data ) {
+ cache[ jQuery.camelCase( prop ) ] = data[ prop ];
+ }
+ }
+ return cache;
+ },
+ get: function( owner, key ) {
+ return key === undefined ?
+ this.cache( owner ) :
+
+ // Always use camelCase key (gh-2257)
+ owner[ this.expando ] && owner[ this.expando ][ jQuery.camelCase( key ) ];
+ },
+ access: function( owner, key, value ) {
+
+ // In cases where either:
+ //
+ // 1. No key was specified
+ // 2. A string key was specified, but no value provided
+ //
+ // Take the "read" path and allow the get method to determine
+ // which value to return, respectively either:
+ //
+ // 1. The entire cache object
+ // 2. The data stored at the key
+ //
+ if ( key === undefined ||
+ ( ( key && typeof key === "string" ) && value === undefined ) ) {
+
+ return this.get( owner, key );
+ }
+
+ // When the key is not a string, or both a key and value
+ // are specified, set or extend (existing objects) with either:
+ //
+ // 1. An object of properties
+ // 2. A key and value
+ //
+ this.set( owner, key, value );
+
+ // Since the "set" path can have two possible entry points
+ // return the expected data based on which path was taken[*]
+ return value !== undefined ? value : key;
+ },
+ remove: function( owner, key ) {
+ var i,
+ cache = owner[ this.expando ];
+
+ if ( cache === undefined ) {
+ return;
+ }
+
+ if ( key !== undefined ) {
+
+ // Support array or space separated string of keys
+ if ( Array.isArray( key ) ) {
+
+ // If key is an array of keys...
+ // We always set camelCase keys, so remove that.
+ key = key.map( jQuery.camelCase );
+ } else {
+ key = jQuery.camelCase( key );
+
+ // If a key with the spaces exists, use it.
+ // Otherwise, create an array by matching non-whitespace
+ key = key in cache ?
+ [ key ] :
+ ( key.match( rnothtmlwhite ) || [] );
+ }
+
+ i = key.length;
+
+ while ( i-- ) {
+ delete cache[ key[ i ] ];
+ }
+ }
+
+ // Remove the expando if there's no more data
+ if ( key === undefined || jQuery.isEmptyObject( cache ) ) {
+
+ // Support: Chrome <=35 - 45
+ // Webkit & Blink performance suffers when deleting properties
+ // from DOM nodes, so set to undefined instead
+ // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)
+ if ( owner.nodeType ) {
+ owner[ this.expando ] = undefined;
+ } else {
+ delete owner[ this.expando ];
+ }
+ }
+ },
+ hasData: function( owner ) {
+ var cache = owner[ this.expando ];
+ return cache !== undefined && !jQuery.isEmptyObject( cache );
+ }
+};
+var dataPriv = new Data();
+
+var dataUser = new Data();
+
+
+
+// Implementation Summary
+//
+// 1. Enforce API surface and semantic compatibility with 1.9.x branch
+// 2. Improve the module's maintainability by reducing the storage
+// paths to a single mechanism.
+// 3. Use the same single mechanism to support "private" and "user" data.
+// 4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
+// 5. Avoid exposing implementation details on user objects (eg. expando properties)
+// 6. Provide a clear path for implementation upgrade to WeakMap in 2014
+
+var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
+ rmultiDash = /[A-Z]/g;
+
+function getData( data ) {
+ if ( data === "true" ) {
+ return true;
+ }
+
+ if ( data === "false" ) {
+ return false;
+ }
+
+ if ( data === "null" ) {
+ return null;
+ }
+
+ // Only convert to a number if it doesn't change the string
+ if ( data === +data + "" ) {
+ return +data;
+ }
+
+ if ( rbrace.test( data ) ) {
+ return JSON.parse( data );
+ }
+
+ return data;
+}
+
+function dataAttr( elem, key, data ) {
+ var name;
+
+ // If nothing was found internally, try to fetch any
+ // data from the HTML5 data-* attribute
+ if ( data === undefined && elem.nodeType === 1 ) {
+ name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase();
+ data = elem.getAttribute( name );
+
+ if ( typeof data === "string" ) {
+ try {
+ data = getData( data );
+ } catch ( e ) {}
+
+ // Make sure we set the data so it isn't changed later
+ dataUser.set( elem, key, data );
+ } else {
+ data = undefined;
+ }
+ }
+ return data;
+}
+
+jQuery.extend( {
+ hasData: function( elem ) {
+ return dataUser.hasData( elem ) || dataPriv.hasData( elem );
+ },
+
+ data: function( elem, name, data ) {
+ return dataUser.access( elem, name, data );
+ },
+
+ removeData: function( elem, name ) {
+ dataUser.remove( elem, name );
+ },
+
+ // TODO: Now that all calls to _data and _removeData have been replaced
+ // with direct calls to dataPriv methods, these can be deprecated.
+ _data: function( elem, name, data ) {
+ return dataPriv.access( elem, name, data );
+ },
+
+ _removeData: function( elem, name ) {
+ dataPriv.remove( elem, name );
+ }
+} );
+
+jQuery.fn.extend( {
+ data: function( key, value ) {
+ var i, name, data,
+ elem = this[ 0 ],
+ attrs = elem && elem.attributes;
+
+ // Gets all values
+ if ( key === undefined ) {
+ if ( this.length ) {
+ data = dataUser.get( elem );
+
+ if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) {
+ i = attrs.length;
+ while ( i-- ) {
+
+ // Support: IE 11 only
+ // The attrs elements can be null (#14894)
+ if ( attrs[ i ] ) {
+ name = attrs[ i ].name;
+ if ( name.indexOf( "data-" ) === 0 ) {
+ name = jQuery.camelCase( name.slice( 5 ) );
+ dataAttr( elem, name, data[ name ] );
+ }
+ }
+ }
+ dataPriv.set( elem, "hasDataAttrs", true );
+ }
+ }
+
+ return data;
+ }
+
+ // Sets multiple values
+ if ( typeof key === "object" ) {
+ return this.each( function() {
+ dataUser.set( this, key );
+ } );
+ }
+
+ return access( this, function( value ) {
+ var data;
+
+ // The calling jQuery object (element matches) is not empty
+ // (and therefore has an element appears at this[ 0 ]) and the
+ // `value` parameter was not undefined. An empty jQuery object
+ // will result in `undefined` for elem = this[ 0 ] which will
+ // throw an exception if an attempt to read a data cache is made.
+ if ( elem && value === undefined ) {
+
+ // Attempt to get data from the cache
+ // The key will always be camelCased in Data
+ data = dataUser.get( elem, key );
+ if ( data !== undefined ) {
+ return data;
+ }
+
+ // Attempt to "discover" the data in
+ // HTML5 custom data-* attrs
+ data = dataAttr( elem, key );
+ if ( data !== undefined ) {
+ return data;
+ }
+
+ // We tried really hard, but the data doesn't exist.
+ return;
+ }
+
+ // Set the data...
+ this.each( function() {
+
+ // We always store the camelCased key
+ dataUser.set( this, key, value );
+ } );
+ }, null, value, arguments.length > 1, null, true );
+ },
+
+ removeData: function( key ) {
+ return this.each( function() {
+ dataUser.remove( this, key );
+ } );
+ }
+} );
+
+
+jQuery.extend( {
+ queue: function( elem, type, data ) {
+ var queue;
+
+ if ( elem ) {
+ type = ( type || "fx" ) + "queue";
+ queue = dataPriv.get( elem, type );
+
+ // Speed up dequeue by getting out quickly if this is just a lookup
+ if ( data ) {
+ if ( !queue || Array.isArray( data ) ) {
+ queue = dataPriv.access( elem, type, jQuery.makeArray( data ) );
+ } else {
+ queue.push( data );
+ }
+ }
+ return queue || [];
+ }
+ },
+
+ dequeue: function( elem, type ) {
+ type = type || "fx";
+
+ var queue = jQuery.queue( elem, type ),
+ startLength = queue.length,
+ fn = queue.shift(),
+ hooks = jQuery._queueHooks( elem, type ),
+ next = function() {
+ jQuery.dequeue( elem, type );
+ };
+
+ // If the fx queue is dequeued, always remove the progress sentinel
+ if ( fn === "inprogress" ) {
+ fn = queue.shift();
+ startLength--;
+ }
+
+ if ( fn ) {
+
+ // Add a progress sentinel to prevent the fx queue from being
+ // automatically dequeued
+ if ( type === "fx" ) {
+ queue.unshift( "inprogress" );
+ }
+
+ // Clear up the last queue stop function
+ delete hooks.stop;
+ fn.call( elem, next, hooks );
+ }
+
+ if ( !startLength && hooks ) {
+ hooks.empty.fire();
+ }
+ },
+
+ // Not public - generate a queueHooks object, or return the current one
+ _queueHooks: function( elem, type ) {
+ var key = type + "queueHooks";
+ return dataPriv.get( elem, key ) || dataPriv.access( elem, key, {
+ empty: jQuery.Callbacks( "once memory" ).add( function() {
+ dataPriv.remove( elem, [ type + "queue", key ] );
+ } )
+ } );
+ }
+} );
+
+jQuery.fn.extend( {
+ queue: function( type, data ) {
+ var setter = 2;
+
+ if ( typeof type !== "string" ) {
+ data = type;
+ type = "fx";
+ setter--;
+ }
+
+ if ( arguments.length < setter ) {
+ return jQuery.queue( this[ 0 ], type );
+ }
+
+ return data === undefined ?
+ this :
+ this.each( function() {
+ var queue = jQuery.queue( this, type, data );
+
+ // Ensure a hooks for this queue
+ jQuery._queueHooks( this, type );
+
+ if ( type === "fx" && queue[ 0 ] !== "inprogress" ) {
+ jQuery.dequeue( this, type );
+ }
+ } );
+ },
+ dequeue: function( type ) {
+ return this.each( function() {
+ jQuery.dequeue( this, type );
+ } );
+ },
+ clearQueue: function( type ) {
+ return this.queue( type || "fx", [] );
+ },
+
+ // Get a promise resolved when queues of a certain type
+ // are emptied (fx is the type by default)
+ promise: function( type, obj ) {
+ var tmp,
+ count = 1,
+ defer = jQuery.Deferred(),
+ elements = this,
+ i = this.length,
+ resolve = function() {
+ if ( !( --count ) ) {
+ defer.resolveWith( elements, [ elements ] );
+ }
+ };
+
+ if ( typeof type !== "string" ) {
+ obj = type;
+ type = undefined;
+ }
+ type = type || "fx";
+
+ while ( i-- ) {
+ tmp = dataPriv.get( elements[ i ], type + "queueHooks" );
+ if ( tmp && tmp.empty ) {
+ count++;
+ tmp.empty.add( resolve );
+ }
+ }
+ resolve();
+ return defer.promise( obj );
+ }
+} );
+var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source;
+
+var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" );
+
+
+var cssExpand = [ "Top", "Right", "Bottom", "Left" ];
+
+var isHiddenWithinTree = function( elem, el ) {
+
+ // isHiddenWithinTree might be called from jQuery#filter function;
+ // in that case, element will be second argument
+ elem = el || elem;
+
+ // Inline style trumps all
+ return elem.style.display === "none" ||
+ elem.style.display === "" &&
+
+ // Otherwise, check computed style
+ // Support: Firefox <=43 - 45
+ // Disconnected elements can have computed display: none, so first confirm that elem is
+ // in the document.
+ jQuery.contains( elem.ownerDocument, elem ) &&
+
+ jQuery.css( elem, "display" ) === "none";
+ };
+
+var swap = function( elem, options, callback, args ) {
+ var ret, name,
+ old = {};
+
+ // Remember the old values, and insert the new ones
+ for ( name in options ) {
+ old[ name ] = elem.style[ name ];
+ elem.style[ name ] = options[ name ];
+ }
+
+ ret = callback.apply( elem, args || [] );
+
+ // Revert the old values
+ for ( name in options ) {
+ elem.style[ name ] = old[ name ];
+ }
+
+ return ret;
+};
+
+
+
+
+function adjustCSS( elem, prop, valueParts, tween ) {
+ var adjusted,
+ scale = 1,
+ maxIterations = 20,
+ currentValue = tween ?
+ function() {
+ return tween.cur();
+ } :
+ function() {
+ return jQuery.css( elem, prop, "" );
+ },
+ initial = currentValue(),
+ unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),
+
+ // Starting value computation is required for potential unit mismatches
+ initialInUnit = ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) &&
+ rcssNum.exec( jQuery.css( elem, prop ) );
+
+ if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {
+
+ // Trust units reported by jQuery.css
+ unit = unit || initialInUnit[ 3 ];
+
+ // Make sure we update the tween properties later on
+ valueParts = valueParts || [];
+
+ // Iteratively approximate from a nonzero starting point
+ initialInUnit = +initial || 1;
+
+ do {
+
+ // If previous iteration zeroed out, double until we get *something*.
+ // Use string for doubling so we don't accidentally see scale as unchanged below
+ scale = scale || ".5";
+
+ // Adjust and apply
+ initialInUnit = initialInUnit / scale;
+ jQuery.style( elem, prop, initialInUnit + unit );
+
+ // Update scale, tolerating zero or NaN from tween.cur()
+ // Break the loop if scale is unchanged or perfect, or if we've just had enough.
+ } while (
+ scale !== ( scale = currentValue() / initial ) && scale !== 1 && --maxIterations
+ );
+ }
+
+ if ( valueParts ) {
+ initialInUnit = +initialInUnit || +initial || 0;
+
+ // Apply relative offset (+=/-=) if specified
+ adjusted = valueParts[ 1 ] ?
+ initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :
+ +valueParts[ 2 ];
+ if ( tween ) {
+ tween.unit = unit;
+ tween.start = initialInUnit;
+ tween.end = adjusted;
+ }
+ }
+ return adjusted;
+}
+
+
+var defaultDisplayMap = {};
+
+function getDefaultDisplay( elem ) {
+ var temp,
+ doc = elem.ownerDocument,
+ nodeName = elem.nodeName,
+ display = defaultDisplayMap[ nodeName ];
+
+ if ( display ) {
+ return display;
+ }
+
+ temp = doc.body.appendChild( doc.createElement( nodeName ) );
+ display = jQuery.css( temp, "display" );
+
+ temp.parentNode.removeChild( temp );
+
+ if ( display === "none" ) {
+ display = "block";
+ }
+ defaultDisplayMap[ nodeName ] = display;
+
+ return display;
+}
+
+function showHide( elements, show ) {
+ var display, elem,
+ values = [],
+ index = 0,
+ length = elements.length;
+
+ // Determine new display value for elements that need to change
+ for ( ; index < length; index++ ) {
+ elem = elements[ index ];
+ if ( !elem.style ) {
+ continue;
+ }
+
+ display = elem.style.display;
+ if ( show ) {
+
+ // Since we force visibility upon cascade-hidden elements, an immediate (and slow)
+ // check is required in this first loop unless we have a nonempty display value (either
+ // inline or about-to-be-restored)
+ if ( display === "none" ) {
+ values[ index ] = dataPriv.get( elem, "display" ) || null;
+ if ( !values[ index ] ) {
+ elem.style.display = "";
+ }
+ }
+ if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) {
+ values[ index ] = getDefaultDisplay( elem );
+ }
+ } else {
+ if ( display !== "none" ) {
+ values[ index ] = "none";
+
+ // Remember what we're overwriting
+ dataPriv.set( elem, "display", display );
+ }
+ }
+ }
+
+ // Set the display of the elements in a second loop to avoid constant reflow
+ for ( index = 0; index < length; index++ ) {
+ if ( values[ index ] != null ) {
+ elements[ index ].style.display = values[ index ];
+ }
+ }
+
+ return elements;
+}
+
+jQuery.fn.extend( {
+ show: function() {
+ return showHide( this, true );
+ },
+ hide: function() {
+ return showHide( this );
+ },
+ toggle: function( state ) {
+ if ( typeof state === "boolean" ) {
+ return state ? this.show() : this.hide();
+ }
+
+ return this.each( function() {
+ if ( isHiddenWithinTree( this ) ) {
+ jQuery( this ).show();
+ } else {
+ jQuery( this ).hide();
+ }
+ } );
+ }
+} );
+var rcheckableType = ( /^(?:checkbox|radio)$/i );
+
+var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]+)/i );
+
+var rscriptType = ( /^$|\/(?:java|ecma)script/i );
+
+
+
+// We have to close these tags to support XHTML (#13200)
+var wrapMap = {
+
+ // Support: IE <=9 only
+ option: [ 1, "<select multiple='multiple'>", "</select>" ],
+
+ // XHTML parsers do not magically insert elements in the
+ // same way that tag soup parsers do. So we cannot shorten
+ // this by omitting <tbody> or other required elements.
+ thead: [ 1, "<table>", "</table>" ],
+ col: [ 2, "<table><colgroup>", "</colgroup></table>" ],
+ tr: [ 2, "<table><tbody>", "</tbody></table>" ],
+ td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
+
+ _default: [ 0, "", "" ]
+};
+
+// Support: IE <=9 only
+wrapMap.optgroup = wrapMap.option;
+
+wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
+wrapMap.th = wrapMap.td;
+
+
+function getAll( context, tag ) {
+
+ // Support: IE <=9 - 11 only
+ // Use typeof to avoid zero-argument method invocation on host objects (#15151)
+ var ret;
+
+ if ( typeof context.getElementsByTagName !== "undefined" ) {
+ ret = context.getElementsByTagName( tag || "*" );
+
+ } else if ( typeof context.querySelectorAll !== "undefined" ) {
+ ret = context.querySelectorAll( tag || "*" );
+
+ } else {
+ ret = [];
+ }
+
+ if ( tag === undefined || tag && nodeName( context, tag ) ) {
+ return jQuery.merge( [ context ], ret );
+ }
+
+ return ret;
+}
+
+
+// Mark scripts as having already been evaluated
+function setGlobalEval( elems, refElements ) {
+ var i = 0,
+ l = elems.length;
+
+ for ( ; i < l; i++ ) {
+ dataPriv.set(
+ elems[ i ],
+ "globalEval",
+ !refElements || dataPriv.get( refElements[ i ], "globalEval" )
+ );
+ }
+}
+
+
+var rhtml = /<|&#?\w+;/;
+
+function buildFragment( elems, context, scripts, selection, ignored ) {
+ var elem, tmp, tag, wrap, contains, j,
+ fragment = context.createDocumentFragment(),
+ nodes = [],
+ i = 0,
+ l = elems.length;
+
+ for ( ; i < l; i++ ) {
+ elem = elems[ i ];
+
+ if ( elem || elem === 0 ) {
+
+ // Add nodes directly
+ if ( jQuery.type( elem ) === "object" ) {
+
+ // Support: Android <=4.0 only, PhantomJS 1 only
+ // push.apply(_, arraylike) throws on ancient WebKit
+ jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
+
+ // Convert non-html into a text node
+ } else if ( !rhtml.test( elem ) ) {
+ nodes.push( context.createTextNode( elem ) );
+
+ // Convert html into DOM nodes
+ } else {
+ tmp = tmp || fragment.appendChild( context.createElement( "div" ) );
+
+ // Deserialize a standard representation
+ tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
+ wrap = wrapMap[ tag ] || wrapMap._default;
+ tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];
+
+ // Descend through wrappers to the right content
+ j = wrap[ 0 ];
+ while ( j-- ) {
+ tmp = tmp.lastChild;
+ }
+
+ // Support: Android <=4.0 only, PhantomJS 1 only
+ // push.apply(_, arraylike) throws on ancient WebKit
+ jQuery.merge( nodes, tmp.childNodes );
+
+ // Remember the top-level container
+ tmp = fragment.firstChild;
+
+ // Ensure the created nodes are orphaned (#12392)
+ tmp.textContent = "";
+ }
+ }
+ }
+
+ // Remove wrapper from fragment
+ fragment.textContent = "";
+
+ i = 0;
+ while ( ( elem = nodes[ i++ ] ) ) {
+
+ // Skip elements already in the context collection (trac-4087)
+ if ( selection && jQuery.inArray( elem, selection ) > -1 ) {
+ if ( ignored ) {
+ ignored.push( elem );
+ }
+ continue;
+ }
+
+ contains = jQuery.contains( elem.ownerDocument, elem );
+
+ // Append to fragment
+ tmp = getAll( fragment.appendChild( elem ), "script" );
+
+ // Preserve script evaluation history
+ if ( contains ) {
+ setGlobalEval( tmp );
+ }
+
+ // Capture executables
+ if ( scripts ) {
+ j = 0;
+ while ( ( elem = tmp[ j++ ] ) ) {
+ if ( rscriptType.test( elem.type || "" ) ) {
+ scripts.push( elem );
+ }
+ }
+ }
+ }
+
+ return fragment;
+}
+
+
+( function() {
+ var fragment = document.createDocumentFragment(),
+ div = fragment.appendChild( document.createElement( "div" ) ),
+ input = document.createElement( "input" );
+
+ // Support: Android 4.0 - 4.3 only
+ // Check state lost if the name is set (#11217)
+ // Support: Windows Web Apps (WWA)
+ // `name` and `type` must use .setAttribute for WWA (#14901)
+ input.setAttribute( "type", "radio" );
+ input.setAttribute( "checked", "checked" );
+ input.setAttribute( "name", "t" );
+
+ div.appendChild( input );
+
+ // Support: Android <=4.1 only
+ // Older WebKit doesn't clone checked state correctly in fragments
+ support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
+
+ // Support: IE <=11 only
+ // Make sure textarea (and checkbox) defaultValue is properly cloned
+ div.innerHTML = "<textarea>x</textarea>";
+ support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
+} )();
+var documentElement = document.documentElement;
+
+
+
+var
+ rkeyEvent = /^key/,
+ rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,
+ rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
+
+function returnTrue() {
+ return true;
+}
+
+function returnFalse() {
+ return false;
+}
+
+// Support: IE <=9 only
+// See #13393 for more info
+function safeActiveElement() {
+ try {
+ return document.activeElement;
+ } catch ( err ) { }
+}
+
+function on( elem, types, selector, data, fn, one ) {
+ var origFn, type;
+
+ // Types can be a map of types/handlers
+ if ( typeof types === "object" ) {
+
+ // ( types-Object, selector, data )
+ if ( typeof selector !== "string" ) {
+
+ // ( types-Object, data )
+ data = data || selector;
+ selector = undefined;
+ }
+ for ( type in types ) {
+ on( elem, type, selector, data, types[ type ], one );
+ }
+ return elem;
+ }
+
+ if ( data == null && fn == null ) {
+
+ // ( types, fn )
+ fn = selector;
+ data = selector = undefined;
+ } else if ( fn == null ) {
+ if ( typeof selector === "string" ) {
+
+ // ( types, selector, fn )
+ fn = data;
+ data = undefined;
+ } else {
+
+ // ( types, data, fn )
+ fn = data;
+ data = selector;
+ selector = undefined;
+ }
+ }
+ if ( fn === false ) {
+ fn = returnFalse;
+ } else if ( !fn ) {
+ return elem;
+ }
+
+ if ( one === 1 ) {
+ origFn = fn;
+ fn = function( event ) {
+
+ // Can use an empty set, since event contains the info
+ jQuery().off( event );
+ return origFn.apply( this, arguments );
+ };
+
+ // Use same guid so caller can remove using origFn
+ fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
+ }
+ return elem.each( function() {
+ jQuery.event.add( this, types, fn, data, selector );
+ } );
+}
+
+/*
+ * Helper functions for managing events -- not part of the public interface.
+ * Props to Dean Edwards' addEvent library for many of the ideas.
+ */
+jQuery.event = {
+
+ global: {},
+
+ add: function( elem, types, handler, data, selector ) {
+
+ var handleObjIn, eventHandle, tmp,
+ events, t, handleObj,
+ special, handlers, type, namespaces, origType,
+ elemData = dataPriv.get( elem );
+
+ // Don't attach events to noData or text/comment nodes (but allow plain objects)
+ if ( !elemData ) {
+ return;
+ }
+
+ // Caller can pass in an object of custom data in lieu of the handler
+ if ( handler.handler ) {
+ handleObjIn = handler;
+ handler = handleObjIn.handler;
+ selector = handleObjIn.selector;
+ }
+
+ // Ensure that invalid selectors throw exceptions at attach time
+ // Evaluate against documentElement in case elem is a non-element node (e.g., document)
+ if ( selector ) {
+ jQuery.find.matchesSelector( documentElement, selector );
+ }
+
+ // Make sure that the handler has a unique ID, used to find/remove it later
+ if ( !handler.guid ) {
+ handler.guid = jQuery.guid++;
+ }
+
+ // Init the element's event structure and main handler, if this is the first
+ if ( !( events = elemData.events ) ) {
+ events = elemData.events = {};
+ }
+ if ( !( eventHandle = elemData.handle ) ) {
+ eventHandle = elemData.handle = function( e ) {
+
+ // Discard the second event of a jQuery.event.trigger() and
+ // when an event is called after a page has unloaded
+ return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ?
+ jQuery.event.dispatch.apply( elem, arguments ) : undefined;
+ };
+ }
+
+ // Handle multiple events separated by a space
+ types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
+ t = types.length;
+ while ( t-- ) {
+ tmp = rtypenamespace.exec( types[ t ] ) || [];
+ type = origType = tmp[ 1 ];
+ namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
+
+ // There *must* be a type, no attaching namespace-only handlers
+ if ( !type ) {
+ continue;
+ }
+
+ // If event changes its type, use the special event handlers for the changed type
+ special = jQuery.event.special[ type ] || {};
+
+ // If selector defined, determine special event api type, otherwise given type
+ type = ( selector ? special.delegateType : special.bindType ) || type;
+
+ // Update special based on newly reset type
+ special = jQuery.event.special[ type ] || {};
+
+ // handleObj is passed to all event handlers
+ handleObj = jQuery.extend( {
+ type: type,
+ origType: origType,
+ data: data,
+ handler: handler,
+ guid: handler.guid,
+ selector: selector,
+ needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
+ namespace: namespaces.join( "." )
+ }, handleObjIn );
+
+ // Init the event handler queue if we're the first
+ if ( !( handlers = events[ type ] ) ) {
+ handlers = events[ type ] = [];
+ handlers.delegateCount = 0;
+
+ // Only use addEventListener if the special events handler returns false
+ if ( !special.setup ||
+ special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
+
+ if ( elem.addEventListener ) {
+ elem.addEventListener( type, eventHandle );
+ }
+ }
+ }
+
+ if ( special.add ) {
+ special.add.call( elem, handleObj );
+
+ if ( !handleObj.handler.guid ) {
+ handleObj.handler.guid = handler.guid;
+ }
+ }
+
+ // Add to the element's handler list, delegates in front
+ if ( selector ) {
+ handlers.splice( handlers.delegateCount++, 0, handleObj );
+ } else {
+ handlers.push( handleObj );
+ }
+
+ // Keep track of which events have ever been used, for event optimization
+ jQuery.event.global[ type ] = true;
+ }
+
+ },
+
+ // Detach an event or set of events from an element
+ remove: function( elem, types, handler, selector, mappedTypes ) {
+
+ var j, origCount, tmp,
+ events, t, handleObj,
+ special, handlers, type, namespaces, origType,
+ elemData = dataPriv.hasData( elem ) && dataPriv.get( elem );
+
+ if ( !elemData || !( events = elemData.events ) ) {
+ return;
+ }
+
+ // Once for each type.namespace in types; type may be omitted
+ types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
+ t = types.length;
+ while ( t-- ) {
+ tmp = rtypenamespace.exec( types[ t ] ) || [];
+ type = origType = tmp[ 1 ];
+ namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
+
+ // Unbind all events (on this namespace, if provided) for the element
+ if ( !type ) {
+ for ( type in events ) {
+ jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
+ }
+ continue;
+ }
+
+ special = jQuery.event.special[ type ] || {};
+ type = ( selector ? special.delegateType : special.bindType ) || type;
+ handlers = events[ type ] || [];
+ tmp = tmp[ 2 ] &&
+ new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" );
+
+ // Remove matching events
+ origCount = j = handlers.length;
+ while ( j-- ) {
+ handleObj = handlers[ j ];
+
+ if ( ( mappedTypes || origType === handleObj.origType ) &&
+ ( !handler || handler.guid === handleObj.guid ) &&
+ ( !tmp || tmp.test( handleObj.namespace ) ) &&
+ ( !selector || selector === handleObj.selector ||
+ selector === "**" && handleObj.selector ) ) {
+ handlers.splice( j, 1 );
+
+ if ( handleObj.selector ) {
+ handlers.delegateCount--;
+ }
+ if ( special.remove ) {
+ special.remove.call( elem, handleObj );
+ }
+ }
+ }
+
+ // Remove generic event handler if we removed something and no more handlers exist
+ // (avoids potential for endless recursion during removal of special event handlers)
+ if ( origCount && !handlers.length ) {
+ if ( !special.teardown ||
+ special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
+
+ jQuery.removeEvent( elem, type, elemData.handle );
+ }
+
+ delete events[ type ];
+ }
+ }
+
+ // Remove data and the expando if it's no longer used
+ if ( jQuery.isEmptyObject( events ) ) {
+ dataPriv.remove( elem, "handle events" );
+ }
+ },
+
+ dispatch: function( nativeEvent ) {
+
+ // Make a writable jQuery.Event from the native event object
+ var event = jQuery.event.fix( nativeEvent );
+
+ var i, j, ret, matched, handleObj, handlerQueue,
+ args = new Array( arguments.length ),
+ handlers = ( dataPriv.get( this, "events" ) || {} )[ event.type ] || [],
+ special = jQuery.event.special[ event.type ] || {};
+
+ // Use the fix-ed jQuery.Event rather than the (read-only) native event
+ args[ 0 ] = event;
+
+ for ( i = 1; i < arguments.length; i++ ) {
+ args[ i ] = arguments[ i ];
+ }
+
+ event.delegateTarget = this;
+
+ // Call the preDispatch hook for the mapped type, and let it bail if desired
+ if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
+ return;
+ }
+
+ // Determine handlers
+ handlerQueue = jQuery.event.handlers.call( this, event, handlers );
+
+ // Run delegates first; they may want to stop propagation beneath us
+ i = 0;
+ while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {
+ event.currentTarget = matched.elem;
+
+ j = 0;
+ while ( ( handleObj = matched.handlers[ j++ ] ) &&
+ !event.isImmediatePropagationStopped() ) {
+
+ // Triggered event must either 1) have no namespace, or 2) have namespace(s)
+ // a subset or equal to those in the bound event (both can have no namespace).
+ if ( !event.rnamespace || event.rnamespace.test( handleObj.namespace ) ) {
+
+ event.handleObj = handleObj;
+ event.data = handleObj.data;
+
+ ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||
+ handleObj.handler ).apply( matched.elem, args );
+
+ if ( ret !== undefined ) {
+ if ( ( event.result = ret ) === false ) {
+ event.preventDefault();
+ event.stopPropagation();
+ }
+ }
+ }
+ }
+ }
+
+ // Call the postDispatch hook for the mapped type
+ if ( special.postDispatch ) {
+ special.postDispatch.call( this, event );
+ }
+
+ return event.result;
+ },
+
+ handlers: function( event, handlers ) {
+ var i, handleObj, sel, matchedHandlers, matchedSelectors,
+ handlerQueue = [],
+ delegateCount = handlers.delegateCount,
+ cur = event.target;
+
+ // Find delegate handlers
+ if ( delegateCount &&
+
+ // Support: IE <=9
+ // Black-hole SVG <use> instance trees (trac-13180)
+ cur.nodeType &&
+
+ // Support: Firefox <=42
+ // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)
+ // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click
+ // Support: IE 11 only
+ // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343)
+ !( event.type === "click" && event.button >= 1 ) ) {
+
+ for ( ; cur !== this; cur = cur.parentNode || this ) {
+
+ // Don't check non-elements (#13208)
+ // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
+ if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) {
+ matchedHandlers = [];
+ matchedSelectors = {};
+ for ( i = 0; i < delegateCount; i++ ) {
+ handleObj = handlers[ i ];
+
+ // Don't conflict with Object.prototype properties (#13203)
+ sel = handleObj.selector + " ";
+
+ if ( matchedSelectors[ sel ] === undefined ) {
+ matchedSelectors[ sel ] = handleObj.needsContext ?
+ jQuery( sel, this ).index( cur ) > -1 :
+ jQuery.find( sel, this, null, [ cur ] ).length;
+ }
+ if ( matchedSelectors[ sel ] ) {
+ matchedHandlers.push( handleObj );
+ }
+ }
+ if ( matchedHandlers.length ) {
+ handlerQueue.push( { elem: cur, handlers: matchedHandlers } );
+ }
+ }
+ }
+ }
+
+ // Add the remaining (directly-bound) handlers
+ cur = this;
+ if ( delegateCount < handlers.length ) {
+ handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );
+ }
+
+ return handlerQueue;
+ },
+
+ addProp: function( name, hook ) {
+ Object.defineProperty( jQuery.Event.prototype, name, {
+ enumerable: true,
+ configurable: true,
+
+ get: jQuery.isFunction( hook ) ?
+ function() {
+ if ( this.originalEvent ) {
+ return hook( this.originalEvent );
+ }
+ } :
+ function() {
+ if ( this.originalEvent ) {
+ return this.originalEvent[ name ];
+ }
+ },
+
+ set: function( value ) {
+ Object.defineProperty( this, name, {
+ enumerable: true,
+ configurable: true,
+ writable: true,
+ value: value
+ } );
+ }
+ } );
+ },
+
+ fix: function( originalEvent ) {
+ return originalEvent[ jQuery.expando ] ?
+ originalEvent :
+ new jQuery.Event( originalEvent );
+ },
+
+ special: {
+ load: {
+
+ // Prevent triggered image.load events from bubbling to window.load
+ noBubble: true
+ },
+ focus: {
+
+ // Fire native event if possible so blur/focus sequence is correct
+ trigger: function() {
+ if ( this !== safeActiveElement() && this.focus ) {
+ this.focus();
+ return false;
+ }
+ },
+ delegateType: "focusin"
+ },
+ blur: {
+ trigger: function() {
+ if ( this === safeActiveElement() && this.blur ) {
+ this.blur();
+ return false;
+ }
+ },
+ delegateType: "focusout"
+ },
+ click: {
+
+ // For checkbox, fire native event so checked state will be right
+ trigger: function() {
+ if ( this.type === "checkbox" && this.click && nodeName( this, "input" ) ) {
+ this.click();
+ return false;
+ }
+ },
+
+ // For cross-browser consistency, don't fire native .click() on links
+ _default: function( event ) {
+ return nodeName( event.target, "a" );
+ }
+ },
+
+ beforeunload: {
+ postDispatch: function( event ) {
+
+ // Support: Firefox 20+
+ // Firefox doesn't alert if the returnValue field is not set.
+ if ( event.result !== undefined && event.originalEvent ) {
+ event.originalEvent.returnValue = event.result;
+ }
+ }
+ }
+ }
+};
+
+jQuery.removeEvent = function( elem, type, handle ) {
+
+ // This "if" is needed for plain objects
+ if ( elem.removeEventListener ) {
+ elem.removeEventListener( type, handle );
+ }
+};
+
+jQuery.Event = function( src, props ) {
+
+ // Allow instantiation without the 'new' keyword
+ if ( !( this instanceof jQuery.Event ) ) {
+ return new jQuery.Event( src, props );
+ }
+
+ // Event object
+ if ( src && src.type ) {
+ this.originalEvent = src;
+ this.type = src.type;
+
+ // Events bubbling up the document may have been marked as prevented
+ // by a handler lower down the tree; reflect the correct value.
+ this.isDefaultPrevented = src.defaultPrevented ||
+ src.defaultPrevented === undefined &&
+
+ // Support: Android <=2.3 only
+ src.returnValue === false ?
+ returnTrue :
+ returnFalse;
+
+ // Create target properties
+ // Support: Safari <=6 - 7 only
+ // Target should not be a text node (#504, #13143)
+ this.target = ( src.target && src.target.nodeType === 3 ) ?
+ src.target.parentNode :
+ src.target;
+
+ this.currentTarget = src.currentTarget;
+ this.relatedTarget = src.relatedTarget;
+
+ // Event type
+ } else {
+ this.type = src;
+ }
+
+ // Put explicitly provided properties onto the event object
+ if ( props ) {
+ jQuery.extend( this, props );
+ }
+
+ // Create a timestamp if incoming event doesn't have one
+ this.timeStamp = src && src.timeStamp || jQuery.now();
+
+ // Mark it as fixed
+ this[ jQuery.expando ] = true;
+};
+
+// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
+// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
+jQuery.Event.prototype = {
+ constructor: jQuery.Event,
+ isDefaultPrevented: returnFalse,
+ isPropagationStopped: returnFalse,
+ isImmediatePropagationStopped: returnFalse,
+ isSimulated: false,
+
+ preventDefault: function() {
+ var e = this.originalEvent;
+
+ this.isDefaultPrevented = returnTrue;
+
+ if ( e && !this.isSimulated ) {
+ e.preventDefault();
+ }
+ },
+ stopPropagation: function() {
+ var e = this.originalEvent;
+
+ this.isPropagationStopped = returnTrue;
+
+ if ( e && !this.isSimulated ) {
+ e.stopPropagation();
+ }
+ },
+ stopImmediatePropagation: function() {
+ var e = this.originalEvent;
+
+ this.isImmediatePropagationStopped = returnTrue;
+
+ if ( e && !this.isSimulated ) {
+ e.stopImmediatePropagation();
+ }
+
+ this.stopPropagation();
+ }
+};
+
+// Includes all common event props including KeyEvent and MouseEvent specific props
+jQuery.each( {
+ altKey: true,
+ bubbles: true,
+ cancelable: true,
+ changedTouches: true,
+ ctrlKey: true,
+ detail: true,
+ eventPhase: true,
+ metaKey: true,
+ pageX: true,
+ pageY: true,
+ shiftKey: true,
+ view: true,
+ "char": true,
+ charCode: true,
+ key: true,
+ keyCode: true,
+ button: true,
+ buttons: true,
+ clientX: true,
+ clientY: true,
+ offsetX: true,
+ offsetY: true,
+ pointerId: true,
+ pointerType: true,
+ screenX: true,
+ screenY: true,
+ targetTouches: true,
+ toElement: true,
+ touches: true,
+
+ which: function( event ) {
+ var button = event.button;
+
+ // Add which for key events
+ if ( event.which == null && rkeyEvent.test( event.type ) ) {
+ return event.charCode != null ? event.charCode : event.keyCode;
+ }
+
+ // Add which for click: 1 === left; 2 === middle; 3 === right
+ if ( !event.which && button !== undefined && rmouseEvent.test( event.type ) ) {
+ if ( button & 1 ) {
+ return 1;
+ }
+
+ if ( button & 2 ) {
+ return 3;
+ }
+
+ if ( button & 4 ) {
+ return 2;
+ }
+
+ return 0;
+ }
+
+ return event.which;
+ }
+}, jQuery.event.addProp );
+
+// Create mouseenter/leave events using mouseover/out and event-time checks
+// so that event delegation works in jQuery.
+// Do the same for pointerenter/pointerleave and pointerover/pointerout
+//
+// Support: Safari 7 only
+// Safari sends mouseenter too often; see:
+// https://bugs.chromium.org/p/chromium/issues/detail?id=470258
+// for the description of the bug (it existed in older Chrome versions as well).
+jQuery.each( {
+ mouseenter: "mouseover",
+ mouseleave: "mouseout",
+ pointerenter: "pointerover",
+ pointerleave: "pointerout"
+}, function( orig, fix ) {
+ jQuery.event.special[ orig ] = {
+ delegateType: fix,
+ bindType: fix,
+
+ handle: function( event ) {
+ var ret,
+ target = this,
+ related = event.relatedTarget,
+ handleObj = event.handleObj;
+
+ // For mouseenter/leave call the handler if related is outside the target.
+ // NB: No relatedTarget if the mouse left/entered the browser window
+ if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {
+ event.type = handleObj.origType;
+ ret = handleObj.handler.apply( this, arguments );
+ event.type = fix;
+ }
+ return ret;
+ }
+ };
+} );
+
+jQuery.fn.extend( {
+
+ on: function( types, selector, data, fn ) {
+ return on( this, types, selector, data, fn );
+ },
+ one: function( types, selector, data, fn ) {
+ return on( this, types, selector, data, fn, 1 );
+ },
+ off: function( types, selector, fn ) {
+ var handleObj, type;
+ if ( types && types.preventDefault && types.handleObj ) {
+
+ // ( event ) dispatched jQuery.Event
+ handleObj = types.handleObj;
+ jQuery( types.delegateTarget ).off(
+ handleObj.namespace ?
+ handleObj.origType + "." + handleObj.namespace :
+ handleObj.origType,
+ handleObj.selector,
+ handleObj.handler
+ );
+ return this;
+ }
+ if ( typeof types === "object" ) {
+
+ // ( types-object [, selector] )
+ for ( type in types ) {
+ this.off( type, selector, types[ type ] );
+ }
+ return this;
+ }
+ if ( selector === false || typeof selector === "function" ) {
+
+ // ( types [, fn] )
+ fn = selector;
+ selector = undefined;
+ }
+ if ( fn === false ) {
+ fn = returnFalse;
+ }
+ return this.each( function() {
+ jQuery.event.remove( this, types, fn, selector );
+ } );
+ }
+} );
+
+
+var
+
+ /* eslint-disable max-len */
+
+ // See https://github.com/eslint/eslint/issues/3229
+ rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi,
+
+ /* eslint-enable */
+
+ // Support: IE <=10 - 11, Edge 12 - 13
+ // In IE/Edge using regex groups here causes severe slowdowns.
+ // See https://connect.microsoft.com/IE/feedback/details/1736512/
+ rnoInnerhtml = /<script|<style|<link/i,
+
+ // checked="checked" or checked
+ rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
+ rscriptTypeMasked = /^true\/(.*)/,
+ rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;
+
+// Prefer a tbody over its parent table for containing new rows
+function manipulationTarget( elem, content ) {
+ if ( nodeName( elem, "table" ) &&
+ nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) {
+
+ return jQuery( ">tbody", elem )[ 0 ] || elem;
+ }
+
+ return elem;
+}
+
+// Replace/restore the type attribute of script elements for safe DOM manipulation
+function disableScript( elem ) {
+ elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type;
+ return elem;
+}
+function restoreScript( elem ) {
+ var match = rscriptTypeMasked.exec( elem.type );
+
+ if ( match ) {
+ elem.type = match[ 1 ];
+ } else {
+ elem.removeAttribute( "type" );
+ }
+
+ return elem;
+}
+
+function cloneCopyEvent( src, dest ) {
+ var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;
+
+ if ( dest.nodeType !== 1 ) {
+ return;
+ }
+
+ // 1. Copy private data: events, handlers, etc.
+ if ( dataPriv.hasData( src ) ) {
+ pdataOld = dataPriv.access( src );
+ pdataCur = dataPriv.set( dest, pdataOld );
+ events = pdataOld.events;
+
+ if ( events ) {
+ delete pdataCur.handle;
+ pdataCur.events = {};
+
+ for ( type in events ) {
+ for ( i = 0, l = events[ type ].length; i < l; i++ ) {
+ jQuery.event.add( dest, type, events[ type ][ i ] );
+ }
+ }
+ }
+ }
+
+ // 2. Copy user data
+ if ( dataUser.hasData( src ) ) {
+ udataOld = dataUser.access( src );
+ udataCur = jQuery.extend( {}, udataOld );
+
+ dataUser.set( dest, udataCur );
+ }
+}
+
+// Fix IE bugs, see support tests
+function fixInput( src, dest ) {
+ var nodeName = dest.nodeName.toLowerCase();
+
+ // Fails to persist the checked state of a cloned checkbox or radio button.
+ if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
+ dest.checked = src.checked;
+
+ // Fails to return the selected option to the default selected state when cloning options
+ } else if ( nodeName === "input" || nodeName === "textarea" ) {
+ dest.defaultValue = src.defaultValue;
+ }
+}
+
+function domManip( collection, args, callback, ignored ) {
+
+ // Flatten any nested arrays
+ args = concat.apply( [], args );
+
+ var fragment, first, scripts, hasScripts, node, doc,
+ i = 0,
+ l = collection.length,
+ iNoClone = l - 1,
+ value = args[ 0 ],
+ isFunction = jQuery.isFunction( value );
+
+ // We can't cloneNode fragments that contain checked, in WebKit
+ if ( isFunction ||
+ ( l > 1 && typeof value === "string" &&
+ !support.checkClone && rchecked.test( value ) ) ) {
+ return collection.each( function( index ) {
+ var self = collection.eq( index );
+ if ( isFunction ) {
+ args[ 0 ] = value.call( this, index, self.html() );
+ }
+ domManip( self, args, callback, ignored );
+ } );
+ }
+
+ if ( l ) {
+ fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );
+ first = fragment.firstChild;
+
+ if ( fragment.childNodes.length === 1 ) {
+ fragment = first;
+ }
+
+ // Require either new content or an interest in ignored elements to invoke the callback
+ if ( first || ignored ) {
+ scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
+ hasScripts = scripts.length;
+
+ // Use the original fragment for the last item
+ // instead of the first because it can end up
+ // being emptied incorrectly in certain situations (#8070).
+ for ( ; i < l; i++ ) {
+ node = fragment;
+
+ if ( i !== iNoClone ) {
+ node = jQuery.clone( node, true, true );
+
+ // Keep references to cloned scripts for later restoration
+ if ( hasScripts ) {
+
+ // Support: Android <=4.0 only, PhantomJS 1 only
+ // push.apply(_, arraylike) throws on ancient WebKit
+ jQuery.merge( scripts, getAll( node, "script" ) );
+ }
+ }
+
+ callback.call( collection[ i ], node, i );
+ }
+
+ if ( hasScripts ) {
+ doc = scripts[ scripts.length - 1 ].ownerDocument;
+
+ // Reenable scripts
+ jQuery.map( scripts, restoreScript );
+
+ // Evaluate executable scripts on first document insertion
+ for ( i = 0; i < hasScripts; i++ ) {
+ node = scripts[ i ];
+ if ( rscriptType.test( node.type || "" ) &&
+ !dataPriv.access( node, "globalEval" ) &&
+ jQuery.contains( doc, node ) ) {
+
+ if ( node.src ) {
+
+ // Optional AJAX dependency, but won't run scripts if not present
+ if ( jQuery._evalUrl ) {
+ jQuery._evalUrl( node.src );
+ }
+ } else {
+ DOMEval( node.textContent.replace( rcleanScript, "" ), doc );
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return collection;
+}
+
+function remove( elem, selector, keepData ) {
+ var node,
+ nodes = selector ? jQuery.filter( selector, elem ) : elem,
+ i = 0;
+
+ for ( ; ( node = nodes[ i ] ) != null; i++ ) {
+ if ( !keepData && node.nodeType === 1 ) {
+ jQuery.cleanData( getAll( node ) );
+ }
+
+ if ( node.parentNode ) {
+ if ( keepData && jQuery.contains( node.ownerDocument, node ) ) {
+ setGlobalEval( getAll( node, "script" ) );
+ }
+ node.parentNode.removeChild( node );
+ }
+ }
+
+ return elem;
+}
+
+jQuery.extend( {
+ htmlPrefilter: function( html ) {
+ return html.replace( rxhtmlTag, "<$1></$2>" );
+ },
+
+ clone: function( elem, dataAndEvents, deepDataAndEvents ) {
+ var i, l, srcElements, destElements,
+ clone = elem.cloneNode( true ),
+ inPage = jQuery.contains( elem.ownerDocument, elem );
+
+ // Fix IE cloning issues
+ if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&
+ !jQuery.isXMLDoc( elem ) ) {
+
+ // We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2
+ destElements = getAll( clone );
+ srcElements = getAll( elem );
+
+ for ( i = 0, l = srcElements.length; i < l; i++ ) {
+ fixInput( srcElements[ i ], destElements[ i ] );
+ }
+ }
+
+ // Copy the events from the original to the clone
+ if ( dataAndEvents ) {
+ if ( deepDataAndEvents ) {
+ srcElements = srcElements || getAll( elem );
+ destElements = destElements || getAll( clone );
+
+ for ( i = 0, l = srcElements.length; i < l; i++ ) {
+ cloneCopyEvent( srcElements[ i ], destElements[ i ] );
+ }
+ } else {
+ cloneCopyEvent( elem, clone );
+ }
+ }
+
+ // Preserve script evaluation history
+ destElements = getAll( clone, "script" );
+ if ( destElements.length > 0 ) {
+ setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
+ }
+
+ // Return the cloned set
+ return clone;
+ },
+
+ cleanData: function( elems ) {
+ var data, elem, type,
+ special = jQuery.event.special,
+ i = 0;
+
+ for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {
+ if ( acceptData( elem ) ) {
+ if ( ( data = elem[ dataPriv.expando ] ) ) {
+ if ( data.events ) {
+ for ( type in data.events ) {
+ if ( special[ type ] ) {
+ jQuery.event.remove( elem, type );
+
+ // This is a shortcut to avoid jQuery.event.remove's overhead
+ } else {
+ jQuery.removeEvent( elem, type, data.handle );
+ }
+ }
+ }
+
+ // Support: Chrome <=35 - 45+
+ // Assign undefined instead of using delete, see Data#remove
+ elem[ dataPriv.expando ] = undefined;
+ }
+ if ( elem[ dataUser.expando ] ) {
+
+ // Support: Chrome <=35 - 45+
+ // Assign undefined instead of using delete, see Data#remove
+ elem[ dataUser.expando ] = undefined;
+ }
+ }
+ }
+ }
+} );
+
+jQuery.fn.extend( {
+ detach: function( selector ) {
+ return remove( this, selector, true );
+ },
+
+ remove: function( selector ) {
+ return remove( this, selector );
+ },
+
+ text: function( value ) {
+ return access( this, function( value ) {
+ return value === undefined ?
+ jQuery.text( this ) :
+ this.empty().each( function() {
+ if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
+ this.textContent = value;
+ }
+ } );
+ }, null, value, arguments.length );
+ },
+
+ append: function() {
+ return domManip( this, arguments, function( elem ) {
+ if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
+ var target = manipulationTarget( this, elem );
+ target.appendChild( elem );
+ }
+ } );
+ },
+
+ prepend: function() {
+ return domManip( this, arguments, function( elem ) {
+ if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
+ var target = manipulationTarget( this, elem );
+ target.insertBefore( elem, target.firstChild );
+ }
+ } );
+ },
+
+ before: function() {
+ return domManip( this, arguments, function( elem ) {
+ if ( this.parentNode ) {
+ this.parentNode.insertBefore( elem, this );
+ }
+ } );
+ },
+
+ after: function() {
+ return domManip( this, arguments, function( elem ) {
+ if ( this.parentNode ) {
+ this.parentNode.insertBefore( elem, this.nextSibling );
+ }
+ } );
+ },
+
+ empty: function() {
+ var elem,
+ i = 0;
+
+ for ( ; ( elem = this[ i ] ) != null; i++ ) {
+ if ( elem.nodeType === 1 ) {
+
+ // Prevent memory leaks
+ jQuery.cleanData( getAll( elem, false ) );
+
+ // Remove any remaining nodes
+ elem.textContent = "";
+ }
+ }
+
+ return this;
+ },
+
+ clone: function( dataAndEvents, deepDataAndEvents ) {
+ dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
+ deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
+
+ return this.map( function() {
+ return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
+ } );
+ },
+
+ html: function( value ) {
+ return access( this, function( value ) {
+ var elem = this[ 0 ] || {},
+ i = 0,
+ l = this.length;
+
+ if ( value === undefined && elem.nodeType === 1 ) {
+ return elem.innerHTML;
+ }
+
+ // See if we can take a shortcut and just use innerHTML
+ if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
+ !wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {
+
+ value = jQuery.htmlPrefilter( value );
+
+ try {
+ for ( ; i < l; i++ ) {
+ elem = this[ i ] || {};
+
+ // Remove element nodes and prevent memory leaks
+ if ( elem.nodeType === 1 ) {
+ jQuery.cleanData( getAll( elem, false ) );
+ elem.innerHTML = value;
+ }
+ }
+
+ elem = 0;
+
+ // If using innerHTML throws an exception, use the fallback method
+ } catch ( e ) {}
+ }
+
+ if ( elem ) {
+ this.empty().append( value );
+ }
+ }, null, value, arguments.length );
+ },
+
+ replaceWith: function() {
+ var ignored = [];
+
+ // Make the changes, replacing each non-ignored context element with the new content
+ return domManip( this, arguments, function( elem ) {
+ var parent = this.parentNode;
+
+ if ( jQuery.inArray( this, ignored ) < 0 ) {
+ jQuery.cleanData( getAll( this ) );
+ if ( parent ) {
+ parent.replaceChild( elem, this );
+ }
+ }
+
+ // Force callback invocation
+ }, ignored );
+ }
+} );
+
+jQuery.each( {
+ appendTo: "append",
+ prependTo: "prepend",
+ insertBefore: "before",
+ insertAfter: "after",
+ replaceAll: "replaceWith"
+}, function( name, original ) {
+ jQuery.fn[ name ] = function( selector ) {
+ var elems,
+ ret = [],
+ insert = jQuery( selector ),
+ last = insert.length - 1,
+ i = 0;
+
+ for ( ; i <= last; i++ ) {
+ elems = i === last ? this : this.clone( true );
+ jQuery( insert[ i ] )[ original ]( elems );
+
+ // Support: Android <=4.0 only, PhantomJS 1 only
+ // .get() because push.apply(_, arraylike) throws on ancient WebKit
+ push.apply( ret, elems.get() );
+ }
+
+ return this.pushStack( ret );
+ };
+} );
+var rmargin = ( /^margin/ );
+
+var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );
+
+var getStyles = function( elem ) {
+
+ // Support: IE <=11 only, Firefox <=30 (#15098, #14150)
+ // IE throws on elements created in popups
+ // FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
+ var view = elem.ownerDocument.defaultView;
+
+ if ( !view || !view.opener ) {
+ view = window;
+ }
+
+ return view.getComputedStyle( elem );
+ };
+
+
+
+( function() {
+
+ // Executing both pixelPosition & boxSizingReliable tests require only one layout
+ // so they're executed at the same time to save the second computation.
+ function computeStyleTests() {
+
+ // This is a singleton, we need to execute it only once
+ if ( !div ) {
+ return;
+ }
+
+ div.style.cssText =
+ "box-sizing:border-box;" +
+ "position:relative;display:block;" +
+ "margin:auto;border:1px;padding:1px;" +
+ "top:1%;width:50%";
+ div.innerHTML = "";
+ documentElement.appendChild( container );
+
+ var divStyle = window.getComputedStyle( div );
+ pixelPositionVal = divStyle.top !== "1%";
+
+ // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44
+ reliableMarginLeftVal = divStyle.marginLeft === "2px";
+ boxSizingReliableVal = divStyle.width === "4px";
+
+ // Support: Android 4.0 - 4.3 only
+ // Some styles come back with percentage values, even though they shouldn't
+ div.style.marginRight = "50%";
+ pixelMarginRightVal = divStyle.marginRight === "4px";
+
+ documentElement.removeChild( container );
+
+ // Nullify the div so it wouldn't be stored in the memory and
+ // it will also be a sign that checks already performed
+ div = null;
+ }
+
+ var pixelPositionVal, boxSizingReliableVal, pixelMarginRightVal, reliableMarginLeftVal,
+ container = document.createElement( "div" ),
+ div = document.createElement( "div" );
+
+ // Finish early in limited (non-browser) environments
+ if ( !div.style ) {
+ return;
+ }
+
+ // Support: IE <=9 - 11 only
+ // Style of cloned element affects source element cloned (#8908)
+ div.style.backgroundClip = "content-box";
+ div.cloneNode( true ).style.backgroundClip = "";
+ support.clearCloneStyle = div.style.backgroundClip === "content-box";
+
+ container.style.cssText = "border:0;width:8px;height:0;top:0;left:-9999px;" +
+ "padding:0;margin-top:1px;position:absolute";
+ container.appendChild( div );
+
+ jQuery.extend( support, {
+ pixelPosition: function() {
+ computeStyleTests();
+ return pixelPositionVal;
+ },
+ boxSizingReliable: function() {
+ computeStyleTests();
+ return boxSizingReliableVal;
+ },
+ pixelMarginRight: function() {
+ computeStyleTests();
+ return pixelMarginRightVal;
+ },
+ reliableMarginLeft: function() {
+ computeStyleTests();
+ return reliableMarginLeftVal;
+ }
+ } );
+} )();
+
+
+function curCSS( elem, name, computed ) {
+ var width, minWidth, maxWidth, ret,
+
+ // Support: Firefox 51+
+ // Retrieving style before computed somehow
+ // fixes an issue with getting wrong values
+ // on detached elements
+ style = elem.style;
+
+ computed = computed || getStyles( elem );
+
+ // getPropertyValue is needed for:
+ // .css('filter') (IE 9 only, #12537)
+ // .css('--customProperty) (#3144)
+ if ( computed ) {
+ ret = computed.getPropertyValue( name ) || computed[ name ];
+
+ if ( ret === "" && !jQuery.contains( elem.ownerDocument, elem ) ) {
+ ret = jQuery.style( elem, name );
+ }
+
+ // A tribute to the "awesome hack by Dean Edwards"
+ // Android Browser returns percentage for some values,
+ // but width seems to be reliably pixels.
+ // This is against the CSSOM draft spec:
+ // https://drafts.csswg.org/cssom/#resolved-values
+ if ( !support.pixelMarginRight() && rnumnonpx.test( ret ) && rmargin.test( name ) ) {
+
+ // Remember the original values
+ width = style.width;
+ minWidth = style.minWidth;
+ maxWidth = style.maxWidth;
+
+ // Put in the new values to get a computed value out
+ style.minWidth = style.maxWidth = style.width = ret;
+ ret = computed.width;
+
+ // Revert the changed values
+ style.width = width;
+ style.minWidth = minWidth;
+ style.maxWidth = maxWidth;
+ }
+ }
+
+ return ret !== undefined ?
+
+ // Support: IE <=9 - 11 only
+ // IE returns zIndex value as an integer.
+ ret + "" :
+ ret;
+}
+
+
+function addGetHookIf( conditionFn, hookFn ) {
+
+ // Define the hook, we'll check on the first run if it's really needed.
+ return {
+ get: function() {
+ if ( conditionFn() ) {
+
+ // Hook not needed (or it's not possible to use it due
+ // to missing dependency), remove it.
+ delete this.get;
+ return;
+ }
+
+ // Hook needed; redefine it so that the support test is not executed again.
+ return ( this.get = hookFn ).apply( this, arguments );
+ }
+ };
+}
+
+
+var
+
+ // Swappable if display is none or starts with table
+ // except "table", "table-cell", or "table-caption"
+ // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
+ rdisplayswap = /^(none|table(?!-c[ea]).+)/,
+ rcustomProp = /^--/,
+ cssShow = { position: "absolute", visibility: "hidden", display: "block" },
+ cssNormalTransform = {
+ letterSpacing: "0",
+ fontWeight: "400"
+ },
+
+ cssPrefixes = [ "Webkit", "Moz", "ms" ],
+ emptyStyle = document.createElement( "div" ).style;
+
+// Return a css property mapped to a potentially vendor prefixed property
+function vendorPropName( name ) {
+
+ // Shortcut for names that are not vendor prefixed
+ if ( name in emptyStyle ) {
+ return name;
+ }
+
+ // Check for vendor prefixed names
+ var capName = name[ 0 ].toUpperCase() + name.slice( 1 ),
+ i = cssPrefixes.length;
+
+ while ( i-- ) {
+ name = cssPrefixes[ i ] + capName;
+ if ( name in emptyStyle ) {
+ return name;
+ }
+ }
+}
+
+// Return a property mapped along what jQuery.cssProps suggests or to
+// a vendor prefixed property.
+function finalPropName( name ) {
+ var ret = jQuery.cssProps[ name ];
+ if ( !ret ) {
+ ret = jQuery.cssProps[ name ] = vendorPropName( name ) || name;
+ }
+ return ret;
+}
+
+function setPositiveNumber( elem, value, subtract ) {
+
+ // Any relative (+/-) values have already been
+ // normalized at this point
+ var matches = rcssNum.exec( value );
+ return matches ?
+
+ // Guard against undefined "subtract", e.g., when used as in cssHooks
+ Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) :
+ value;
+}
+
+function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {
+ var i,
+ val = 0;
+
+ // If we already have the right measurement, avoid augmentation
+ if ( extra === ( isBorderBox ? "border" : "content" ) ) {
+ i = 4;
+
+ // Otherwise initialize for horizontal or vertical properties
+ } else {
+ i = name === "width" ? 1 : 0;
+ }
+
+ for ( ; i < 4; i += 2 ) {
+
+ // Both box models exclude margin, so add it if we want it
+ if ( extra === "margin" ) {
+ val += jQuery.css( elem, extra + cssExpand[ i ], true, styles );
+ }
+
+ if ( isBorderBox ) {
+
+ // border-box includes padding, so remove it if we want content
+ if ( extra === "content" ) {
+ val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
+ }
+
+ // At this point, extra isn't border nor margin, so remove border
+ if ( extra !== "margin" ) {
+ val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
+ }
+ } else {
+
+ // At this point, extra isn't content, so add padding
+ val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
+
+ // At this point, extra isn't content nor padding, so add border
+ if ( extra !== "padding" ) {
+ val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
+ }
+ }
+ }
+
+ return val;
+}
+
+function getWidthOrHeight( elem, name, extra ) {
+
+ // Start with computed style
+ var valueIsBorderBox,
+ styles = getStyles( elem ),
+ val = curCSS( elem, name, styles ),
+ isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
+
+ // Computed unit is not pixels. Stop here and return.
+ if ( rnumnonpx.test( val ) ) {
+ return val;
+ }
+
+ // Check for style in case a browser which returns unreliable values
+ // for getComputedStyle silently falls back to the reliable elem.style
+ valueIsBorderBox = isBorderBox &&
+ ( support.boxSizingReliable() || val === elem.style[ name ] );
+
+ // Fall back to offsetWidth/Height when value is "auto"
+ // This happens for inline elements with no explicit setting (gh-3571)
+ if ( val === "auto" ) {
+ val = elem[ "offset" + name[ 0 ].toUpperCase() + name.slice( 1 ) ];
+ }
+
+ // Normalize "", auto, and prepare for extra
+ val = parseFloat( val ) || 0;
+
+ // Use the active box-sizing model to add/subtract irrelevant styles
+ return ( val +
+ augmentWidthOrHeight(
+ elem,
+ name,
+ extra || ( isBorderBox ? "border" : "content" ),
+ valueIsBorderBox,
+ styles
+ )
+ ) + "px";
+}
+
+jQuery.extend( {
+
+ // Add in style property hooks for overriding the default
+ // behavior of getting and setting a style property
+ cssHooks: {
+ opacity: {
+ get: function( elem, computed ) {
+ if ( computed ) {
+
+ // We should always get a number back from opacity
+ var ret = curCSS( elem, "opacity" );
+ return ret === "" ? "1" : ret;
+ }
+ }
+ }
+ },
+
+ // Don't automatically add "px" to these possibly-unitless properties
+ cssNumber: {
+ "animationIterationCount": true,
+ "columnCount": true,
+ "fillOpacity": true,
+ "flexGrow": true,
+ "flexShrink": true,
+ "fontWeight": true,
+ "lineHeight": true,
+ "opacity": true,
+ "order": true,
+ "orphans": true,
+ "widows": true,
+ "zIndex": true,
+ "zoom": true
+ },
+
+ // Add in properties whose names you wish to fix before
+ // setting or getting the value
+ cssProps: {
+ "float": "cssFloat"
+ },
+
+ // Get and set the style property on a DOM Node
+ style: function( elem, name, value, extra ) {
+
+ // Don't set styles on text and comment nodes
+ if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
+ return;
+ }
+
+ // Make sure that we're working with the right name
+ var ret, type, hooks,
+ origName = jQuery.camelCase( name ),
+ isCustomProp = rcustomProp.test( name ),
+ style = elem.style;
+
+ // Make sure that we're working with the right name. We don't
+ // want to query the value if it is a CSS custom property
+ // since they are user-defined.
+ if ( !isCustomProp ) {
+ name = finalPropName( origName );
+ }
+
+ // Gets hook for the prefixed version, then unprefixed version
+ hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
+
+ // Check if we're setting a value
+ if ( value !== undefined ) {
+ type = typeof value;
+
+ // Convert "+=" or "-=" to relative numbers (#7345)
+ if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {
+ value = adjustCSS( elem, name, ret );
+
+ // Fixes bug #9237
+ type = "number";
+ }
+
+ // Make sure that null and NaN values aren't set (#7116)
+ if ( value == null || value !== value ) {
+ return;
+ }
+
+ // If a number was passed in, add the unit (except for certain CSS properties)
+ if ( type === "number" ) {
+ value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" );
+ }
+
+ // background-* props affect original clone's values
+ if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
+ style[ name ] = "inherit";
+ }
+
+ // If a hook was provided, use that value, otherwise just set the specified value
+ if ( !hooks || !( "set" in hooks ) ||
+ ( value = hooks.set( elem, value, extra ) ) !== undefined ) {
+
+ if ( isCustomProp ) {
+ style.setProperty( name, value );
+ } else {
+ style[ name ] = value;
+ }
+ }
+
+ } else {
+
+ // If a hook was provided get the non-computed value from there
+ if ( hooks && "get" in hooks &&
+ ( ret = hooks.get( elem, false, extra ) ) !== undefined ) {
+
+ return ret;
+ }
+
+ // Otherwise just get the value from the style object
+ return style[ name ];
+ }
+ },
+
+ css: function( elem, name, extra, styles ) {
+ var val, num, hooks,
+ origName = jQuery.camelCase( name ),
+ isCustomProp = rcustomProp.test( name );
+
+ // Make sure that we're working with the right name. We don't
+ // want to modify the value if it is a CSS custom property
+ // since they are user-defined.
+ if ( !isCustomProp ) {
+ name = finalPropName( origName );
+ }
+
+ // Try prefixed name followed by the unprefixed name
+ hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
+
+ // If a hook was provided get the computed value from there
+ if ( hooks && "get" in hooks ) {
+ val = hooks.get( elem, true, extra );
+ }
+
+ // Otherwise, if a way to get the computed value exists, use that
+ if ( val === undefined ) {
+ val = curCSS( elem, name, styles );
+ }
+
+ // Convert "normal" to computed value
+ if ( val === "normal" && name in cssNormalTransform ) {
+ val = cssNormalTransform[ name ];
+ }
+
+ // Make numeric if forced or a qualifier was provided and val looks numeric
+ if ( extra === "" || extra ) {
+ num = parseFloat( val );
+ return extra === true || isFinite( num ) ? num || 0 : val;
+ }
+
+ return val;
+ }
+} );
+
+jQuery.each( [ "height", "width" ], function( i, name ) {
+ jQuery.cssHooks[ name ] = {
+ get: function( elem, computed, extra ) {
+ if ( computed ) {
+
+ // Certain elements can have dimension info if we invisibly show them
+ // but it must have a current display style that would benefit
+ return rdisplayswap.test( jQuery.css( elem, "display" ) ) &&
+
+ // Support: Safari 8+
+ // Table columns in Safari have non-zero offsetWidth & zero
+ // getBoundingClientRect().width unless display is changed.
+ // Support: IE <=11 only
+ // Running getBoundingClientRect on a disconnected node
+ // in IE throws an error.
+ ( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?
+ swap( elem, cssShow, function() {
+ return getWidthOrHeight( elem, name, extra );
+ } ) :
+ getWidthOrHeight( elem, name, extra );
+ }
+ },
+
+ set: function( elem, value, extra ) {
+ var matches,
+ styles = extra && getStyles( elem ),
+ subtract = extra && augmentWidthOrHeight(
+ elem,
+ name,
+ extra,
+ jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
+ styles
+ );
+
+ // Convert to pixels if value adjustment is needed
+ if ( subtract && ( matches = rcssNum.exec( value ) ) &&
+ ( matches[ 3 ] || "px" ) !== "px" ) {
+
+ elem.style[ name ] = value;
+ value = jQuery.css( elem, name );
+ }
+
+ return setPositiveNumber( elem, value, subtract );
+ }
+ };
+} );
+
+jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,
+ function( elem, computed ) {
+ if ( computed ) {
+ return ( parseFloat( curCSS( elem, "marginLeft" ) ) ||
+ elem.getBoundingClientRect().left -
+ swap( elem, { marginLeft: 0 }, function() {
+ return elem.getBoundingClientRect().left;
+ } )
+ ) + "px";
+ }
+ }
+);
+
+// These hooks are used by animate to expand properties
+jQuery.each( {
+ margin: "",
+ padding: "",
+ border: "Width"
+}, function( prefix, suffix ) {
+ jQuery.cssHooks[ prefix + suffix ] = {
+ expand: function( value ) {
+ var i = 0,
+ expanded = {},
+
+ // Assumes a single number if not a string
+ parts = typeof value === "string" ? value.split( " " ) : [ value ];
+
+ for ( ; i < 4; i++ ) {
+ expanded[ prefix + cssExpand[ i ] + suffix ] =
+ parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
+ }
+
+ return expanded;
+ }
+ };
+
+ if ( !rmargin.test( prefix ) ) {
+ jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
+ }
+} );
+
+jQuery.fn.extend( {
+ css: function( name, value ) {
+ return access( this, function( elem, name, value ) {
+ var styles, len,
+ map = {},
+ i = 0;
+
+ if ( Array.isArray( name ) ) {
+ styles = getStyles( elem );
+ len = name.length;
+
+ for ( ; i < len; i++ ) {
+ map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
+ }
+
+ return map;
+ }
+
+ return value !== undefined ?
+ jQuery.style( elem, name, value ) :
+ jQuery.css( elem, name );
+ }, name, value, arguments.length > 1 );
+ }
+} );
+
+
+function Tween( elem, options, prop, end, easing ) {
+ return new Tween.prototype.init( elem, options, prop, end, easing );
+}
+jQuery.Tween = Tween;
+
+Tween.prototype = {
+ constructor: Tween,
+ init: function( elem, options, prop, end, easing, unit ) {
+ this.elem = elem;
+ this.prop = prop;
+ this.easing = easing || jQuery.easing._default;
+ this.options = options;
+ this.start = this.now = this.cur();
+ this.end = end;
+ this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
+ },
+ cur: function() {
+ var hooks = Tween.propHooks[ this.prop ];
+
+ return hooks && hooks.get ?
+ hooks.get( this ) :
+ Tween.propHooks._default.get( this );
+ },
+ run: function( percent ) {
+ var eased,
+ hooks = Tween.propHooks[ this.prop ];
+
+ if ( this.options.duration ) {
+ this.pos = eased = jQuery.easing[ this.easing ](
+ percent, this.options.duration * percent, 0, 1, this.options.duration
+ );
+ } else {
+ this.pos = eased = percent;
+ }
+ this.now = ( this.end - this.start ) * eased + this.start;
+
+ if ( this.options.step ) {
+ this.options.step.call( this.elem, this.now, this );
+ }
+
+ if ( hooks && hooks.set ) {
+ hooks.set( this );
+ } else {
+ Tween.propHooks._default.set( this );
+ }
+ return this;
+ }
+};
+
+Tween.prototype.init.prototype = Tween.prototype;
+
+Tween.propHooks = {
+ _default: {
+ get: function( tween ) {
+ var result;
+
+ // Use a property on the element directly when it is not a DOM element,
+ // or when there is no matching style property that exists.
+ if ( tween.elem.nodeType !== 1 ||
+ tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {
+ return tween.elem[ tween.prop ];
+ }
+
+ // Passing an empty string as a 3rd parameter to .css will automatically
+ // attempt a parseFloat and fallback to a string if the parse fails.
+ // Simple values such as "10px" are parsed to Float;
+ // complex values such as "rotate(1rad)" are returned as-is.
+ result = jQuery.css( tween.elem, tween.prop, "" );
+
+ // Empty strings, null, undefined and "auto" are converted to 0.
+ return !result || result === "auto" ? 0 : result;
+ },
+ set: function( tween ) {
+
+ // Use step hook for back compat.
+ // Use cssHook if its there.
+ // Use .style if available and use plain properties where available.
+ if ( jQuery.fx.step[ tween.prop ] ) {
+ jQuery.fx.step[ tween.prop ]( tween );
+ } else if ( tween.elem.nodeType === 1 &&
+ ( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null ||
+ jQuery.cssHooks[ tween.prop ] ) ) {
+ jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
+ } else {
+ tween.elem[ tween.prop ] = tween.now;
+ }
+ }
+ }
+};
+
+// Support: IE <=9 only
+// Panic based approach to setting things on disconnected nodes
+Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
+ set: function( tween ) {
+ if ( tween.elem.nodeType && tween.elem.parentNode ) {
+ tween.elem[ tween.prop ] = tween.now;
+ }
+ }
+};
+
+jQuery.easing = {
+ linear: function( p ) {
+ return p;
+ },
+ swing: function( p ) {
+ return 0.5 - Math.cos( p * Math.PI ) / 2;
+ },
+ _default: "swing"
+};
+
+jQuery.fx = Tween.prototype.init;
+
+// Back compat <1.8 extension point
+jQuery.fx.step = {};
+
+
+
+
+var
+ fxNow, inProgress,
+ rfxtypes = /^(?:toggle|show|hide)$/,
+ rrun = /queueHooks$/;
+
+function schedule() {
+ if ( inProgress ) {
+ if ( document.hidden === false && window.requestAnimationFrame ) {
+ window.requestAnimationFrame( schedule );
+ } else {
+ window.setTimeout( schedule, jQuery.fx.interval );
+ }
+
+ jQuery.fx.tick();
+ }
+}
+
+// Animations created synchronously will run synchronously
+function createFxNow() {
+ window.setTimeout( function() {
+ fxNow = undefined;
+ } );
+ return ( fxNow = jQuery.now() );
+}
+
+// Generate parameters to create a standard animation
+function genFx( type, includeWidth ) {
+ var which,
+ i = 0,
+ attrs = { height: type };
+
+ // If we include width, step value is 1 to do all cssExpand values,
+ // otherwise step value is 2 to skip over Left and Right
+ includeWidth = includeWidth ? 1 : 0;
+ for ( ; i < 4; i += 2 - includeWidth ) {
+ which = cssExpand[ i ];
+ attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
+ }
+
+ if ( includeWidth ) {
+ attrs.opacity = attrs.width = type;
+ }
+
+ return attrs;
+}
+
+function createTween( value, prop, animation ) {
+ var tween,
+ collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ),
+ index = 0,
+ length = collection.length;
+ for ( ; index < length; index++ ) {
+ if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {
+
+ // We're done with this property
+ return tween;
+ }
+ }
+}
+
+function defaultPrefilter( elem, props, opts ) {
+ var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,
+ isBox = "width" in props || "height" in props,
+ anim = this,
+ orig = {},
+ style = elem.style,
+ hidden = elem.nodeType && isHiddenWithinTree( elem ),
+ dataShow = dataPriv.get( elem, "fxshow" );
+
+ // Queue-skipping animations hijack the fx hooks
+ if ( !opts.queue ) {
+ hooks = jQuery._queueHooks( elem, "fx" );
+ if ( hooks.unqueued == null ) {
+ hooks.unqueued = 0;
+ oldfire = hooks.empty.fire;
+ hooks.empty.fire = function() {
+ if ( !hooks.unqueued ) {
+ oldfire();
+ }
+ };
+ }
+ hooks.unqueued++;
+
+ anim.always( function() {
+
+ // Ensure the complete handler is called before this completes
+ anim.always( function() {
+ hooks.unqueued--;
+ if ( !jQuery.queue( elem, "fx" ).length ) {
+ hooks.empty.fire();
+ }
+ } );
+ } );
+ }
+
+ // Detect show/hide animations
+ for ( prop in props ) {
+ value = props[ prop ];
+ if ( rfxtypes.test( value ) ) {
+ delete props[ prop ];
+ toggle = toggle || value === "toggle";
+ if ( value === ( hidden ? "hide" : "show" ) ) {
+
+ // Pretend to be hidden if this is a "show" and
+ // there is still data from a stopped show/hide
+ if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) {
+ hidden = true;
+
+ // Ignore all other no-op show/hide data
+ } else {
+ continue;
+ }
+ }
+ orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );
+ }
+ }
+
+ // Bail out if this is a no-op like .hide().hide()
+ propTween = !jQuery.isEmptyObject( props );
+ if ( !propTween && jQuery.isEmptyObject( orig ) ) {
+ return;
+ }
+
+ // Restrict "overflow" and "display" styles during box animations
+ if ( isBox && elem.nodeType === 1 ) {
+
+ // Support: IE <=9 - 11, Edge 12 - 13
+ // Record all 3 overflow attributes because IE does not infer the shorthand
+ // from identically-valued overflowX and overflowY
+ opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
+
+ // Identify a display type, preferring old show/hide data over the CSS cascade
+ restoreDisplay = dataShow && dataShow.display;
+ if ( restoreDisplay == null ) {
+ restoreDisplay = dataPriv.get( elem, "display" );
+ }
+ display = jQuery.css( elem, "display" );
+ if ( display === "none" ) {
+ if ( restoreDisplay ) {
+ display = restoreDisplay;
+ } else {
+
+ // Get nonempty value(s) by temporarily forcing visibility
+ showHide( [ elem ], true );
+ restoreDisplay = elem.style.display || restoreDisplay;
+ display = jQuery.css( elem, "display" );
+ showHide( [ elem ] );
+ }
+ }
+
+ // Animate inline elements as inline-block
+ if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) {
+ if ( jQuery.css( elem, "float" ) === "none" ) {
+
+ // Restore the original display value at the end of pure show/hide animations
+ if ( !propTween ) {
+ anim.done( function() {
+ style.display = restoreDisplay;
+ } );
+ if ( restoreDisplay == null ) {
+ display = style.display;
+ restoreDisplay = display === "none" ? "" : display;
+ }
+ }
+ style.display = "inline-block";
+ }
+ }
+ }
+
+ if ( opts.overflow ) {
+ style.overflow = "hidden";
+ anim.always( function() {
+ style.overflow = opts.overflow[ 0 ];
+ style.overflowX = opts.overflow[ 1 ];
+ style.overflowY = opts.overflow[ 2 ];
+ } );
+ }
+
+ // Implement show/hide animations
+ propTween = false;
+ for ( prop in orig ) {
+
+ // General show/hide setup for this element animation
+ if ( !propTween ) {
+ if ( dataShow ) {
+ if ( "hidden" in dataShow ) {
+ hidden = dataShow.hidden;
+ }
+ } else {
+ dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } );
+ }
+
+ // Store hidden/visible for toggle so `.stop().toggle()` "reverses"
+ if ( toggle ) {
+ dataShow.hidden = !hidden;
+ }
+
+ // Show elements before animating them
+ if ( hidden ) {
+ showHide( [ elem ], true );
+ }
+
+ /* eslint-disable no-loop-func */
+
+ anim.done( function() {
+
+ /* eslint-enable no-loop-func */
+
+ // The final step of a "hide" animation is actually hiding the element
+ if ( !hidden ) {
+ showHide( [ elem ] );
+ }
+ dataPriv.remove( elem, "fxshow" );
+ for ( prop in orig ) {
+ jQuery.style( elem, prop, orig[ prop ] );
+ }
+ } );
+ }
+
+ // Per-property setup
+ propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );
+ if ( !( prop in dataShow ) ) {
+ dataShow[ prop ] = propTween.start;
+ if ( hidden ) {
+ propTween.end = propTween.start;
+ propTween.start = 0;
+ }
+ }
+ }
+}
+
+function propFilter( props, specialEasing ) {
+ var index, name, easing, value, hooks;
+
+ // camelCase, specialEasing and expand cssHook pass
+ for ( index in props ) {
+ name = jQuery.camelCase( index );
+ easing = specialEasing[ name ];
+ value = props[ index ];
+ if ( Array.isArray( value ) ) {
+ easing = value[ 1 ];
+ value = props[ index ] = value[ 0 ];
+ }
+
+ if ( index !== name ) {
+ props[ name ] = value;
+ delete props[ index ];
+ }
+
+ hooks = jQuery.cssHooks[ name ];
+ if ( hooks && "expand" in hooks ) {
+ value = hooks.expand( value );
+ delete props[ name ];
+
+ // Not quite $.extend, this won't overwrite existing keys.
+ // Reusing 'index' because we have the correct "name"
+ for ( index in value ) {
+ if ( !( index in props ) ) {
+ props[ index ] = value[ index ];
+ specialEasing[ index ] = easing;
+ }
+ }
+ } else {
+ specialEasing[ name ] = easing;
+ }
+ }
+}
+
+function Animation( elem, properties, options ) {
+ var result,
+ stopped,
+ index = 0,
+ length = Animation.prefilters.length,
+ deferred = jQuery.Deferred().always( function() {
+
+ // Don't match elem in the :animated selector
+ delete tick.elem;
+ } ),
+ tick = function() {
+ if ( stopped ) {
+ return false;
+ }
+ var currentTime = fxNow || createFxNow(),
+ remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
+
+ // Support: Android 2.3 only
+ // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
+ temp = remaining / animation.duration || 0,
+ percent = 1 - temp,
+ index = 0,
+ length = animation.tweens.length;
+
+ for ( ; index < length; index++ ) {
+ animation.tweens[ index ].run( percent );
+ }
+
+ deferred.notifyWith( elem, [ animation, percent, remaining ] );
+
+ // If there's more to do, yield
+ if ( percent < 1 && length ) {
+ return remaining;
+ }
+
+ // If this was an empty animation, synthesize a final progress notification
+ if ( !length ) {
+ deferred.notifyWith( elem, [ animation, 1, 0 ] );
+ }
+
+ // Resolve the animation and report its conclusion
+ deferred.resolveWith( elem, [ animation ] );
+ return false;
+ },
+ animation = deferred.promise( {
+ elem: elem,
+ props: jQuery.extend( {}, properties ),
+ opts: jQuery.extend( true, {
+ specialEasing: {},
+ easing: jQuery.easing._default
+ }, options ),
+ originalProperties: properties,
+ originalOptions: options,
+ startTime: fxNow || createFxNow(),
+ duration: options.duration,
+ tweens: [],
+ createTween: function( prop, end ) {
+ var tween = jQuery.Tween( elem, animation.opts, prop, end,
+ animation.opts.specialEasing[ prop ] || animation.opts.easing );
+ animation.tweens.push( tween );
+ return tween;
+ },
+ stop: function( gotoEnd ) {
+ var index = 0,
+
+ // If we are going to the end, we want to run all the tweens
+ // otherwise we skip this part
+ length = gotoEnd ? animation.tweens.length : 0;
+ if ( stopped ) {
+ return this;
+ }
+ stopped = true;
+ for ( ; index < length; index++ ) {
+ animation.tweens[ index ].run( 1 );
+ }
+
+ // Resolve when we played the last frame; otherwise, reject
+ if ( gotoEnd ) {
+ deferred.notifyWith( elem, [ animation, 1, 0 ] );
+ deferred.resolveWith( elem, [ animation, gotoEnd ] );
+ } else {
+ deferred.rejectWith( elem, [ animation, gotoEnd ] );
+ }
+ return this;
+ }
+ } ),
+ props = animation.props;
+
+ propFilter( props, animation.opts.specialEasing );
+
+ for ( ; index < length; index++ ) {
+ result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );
+ if ( result ) {
+ if ( jQuery.isFunction( result.stop ) ) {
+ jQuery._queueHooks( animation.elem, animation.opts.queue ).stop =
+ jQuery.proxy( result.stop, result );
+ }
+ return result;
+ }
+ }
+
+ jQuery.map( props, createTween, animation );
+
+ if ( jQuery.isFunction( animation.opts.start ) ) {
+ animation.opts.start.call( elem, animation );
+ }
+
+ // Attach callbacks from options
+ animation
+ .progress( animation.opts.progress )
+ .done( animation.opts.done, animation.opts.complete )
+ .fail( animation.opts.fail )
+ .always( animation.opts.always );
+
+ jQuery.fx.timer(
+ jQuery.extend( tick, {
+ elem: elem,
+ anim: animation,
+ queue: animation.opts.queue
+ } )
+ );
+
+ return animation;
+}
+
+jQuery.Animation = jQuery.extend( Animation, {
+
+ tweeners: {
+ "*": [ function( prop, value ) {
+ var tween = this.createTween( prop, value );
+ adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );
+ return tween;
+ } ]
+ },
+
+ tweener: function( props, callback ) {
+ if ( jQuery.isFunction( props ) ) {
+ callback = props;
+ props = [ "*" ];
+ } else {
+ props = props.match( rnothtmlwhite );
+ }
+
+ var prop,
+ index = 0,
+ length = props.length;
+
+ for ( ; index < length; index++ ) {
+ prop = props[ index ];
+ Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];
+ Animation.tweeners[ prop ].unshift( callback );
+ }
+ },
+
+ prefilters: [ defaultPrefilter ],
+
+ prefilter: function( callback, prepend ) {
+ if ( prepend ) {
+ Animation.prefilters.unshift( callback );
+ } else {
+ Animation.prefilters.push( callback );
+ }
+ }
+} );
+
+jQuery.speed = function( speed, easing, fn ) {
+ var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
+ complete: fn || !fn && easing ||
+ jQuery.isFunction( speed ) && speed,
+ duration: speed,
+ easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
+ };
+
+ // Go to the end state if fx are off
+ if ( jQuery.fx.off ) {
+ opt.duration = 0;
+
+ } else {
+ if ( typeof opt.duration !== "number" ) {
+ if ( opt.duration in jQuery.fx.speeds ) {
+ opt.duration = jQuery.fx.speeds[ opt.duration ];
+
+ } else {
+ opt.duration = jQuery.fx.speeds._default;
+ }
+ }
+ }
+
+ // Normalize opt.queue - true/undefined/null -> "fx"
+ if ( opt.queue == null || opt.queue === true ) {
+ opt.queue = "fx";
+ }
+
+ // Queueing
+ opt.old = opt.complete;
+
+ opt.complete = function() {
+ if ( jQuery.isFunction( opt.old ) ) {
+ opt.old.call( this );
+ }
+
+ if ( opt.queue ) {
+ jQuery.dequeue( this, opt.queue );
+ }
+ };
+
+ return opt;
+};
+
+jQuery.fn.extend( {
+ fadeTo: function( speed, to, easing, callback ) {
+
+ // Show any hidden elements after setting opacity to 0
+ return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show()
+
+ // Animate to the value specified
+ .end().animate( { opacity: to }, speed, easing, callback );
+ },
+ animate: function( prop, speed, easing, callback ) {
+ var empty = jQuery.isEmptyObject( prop ),
+ optall = jQuery.speed( speed, easing, callback ),
+ doAnimation = function() {
+
+ // Operate on a copy of prop so per-property easing won't be lost
+ var anim = Animation( this, jQuery.extend( {}, prop ), optall );
+
+ // Empty animations, or finishing resolves immediately
+ if ( empty || dataPriv.get( this, "finish" ) ) {
+ anim.stop( true );
+ }
+ };
+ doAnimation.finish = doAnimation;
+
+ return empty || optall.queue === false ?
+ this.each( doAnimation ) :
+ this.queue( optall.queue, doAnimation );
+ },
+ stop: function( type, clearQueue, gotoEnd ) {
+ var stopQueue = function( hooks ) {
+ var stop = hooks.stop;
+ delete hooks.stop;
+ stop( gotoEnd );
+ };
+
+ if ( typeof type !== "string" ) {
+ gotoEnd = clearQueue;
+ clearQueue = type;
+ type = undefined;
+ }
+ if ( clearQueue && type !== false ) {
+ this.queue( type || "fx", [] );
+ }
+
+ return this.each( function() {
+ var dequeue = true,
+ index = type != null && type + "queueHooks",
+ timers = jQuery.timers,
+ data = dataPriv.get( this );
+
+ if ( index ) {
+ if ( data[ index ] && data[ index ].stop ) {
+ stopQueue( data[ index ] );
+ }
+ } else {
+ for ( index in data ) {
+ if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
+ stopQueue( data[ index ] );
+ }
+ }
+ }
+
+ for ( index = timers.length; index--; ) {
+ if ( timers[ index ].elem === this &&
+ ( type == null || timers[ index ].queue === type ) ) {
+
+ timers[ index ].anim.stop( gotoEnd );
+ dequeue = false;
+ timers.splice( index, 1 );
+ }
+ }
+
+ // Start the next in the queue if the last step wasn't forced.
+ // Timers currently will call their complete callbacks, which
+ // will dequeue but only if they were gotoEnd.
+ if ( dequeue || !gotoEnd ) {
+ jQuery.dequeue( this, type );
+ }
+ } );
+ },
+ finish: function( type ) {
+ if ( type !== false ) {
+ type = type || "fx";
+ }
+ return this.each( function() {
+ var index,
+ data = dataPriv.get( this ),
+ queue = data[ type + "queue" ],
+ hooks = data[ type + "queueHooks" ],
+ timers = jQuery.timers,
+ length = queue ? queue.length : 0;
+
+ // Enable finishing flag on private data
+ data.finish = true;
+
+ // Empty the queue first
+ jQuery.queue( this, type, [] );
+
+ if ( hooks && hooks.stop ) {
+ hooks.stop.call( this, true );
+ }
+
+ // Look for any active animations, and finish them
+ for ( index = timers.length; index--; ) {
+ if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
+ timers[ index ].anim.stop( true );
+ timers.splice( index, 1 );
+ }
+ }
+
+ // Look for any animations in the old queue and finish them
+ for ( index = 0; index < length; index++ ) {
+ if ( queue[ index ] && queue[ index ].finish ) {
+ queue[ index ].finish.call( this );
+ }
+ }
+
+ // Turn off finishing flag
+ delete data.finish;
+ } );
+ }
+} );
+
+jQuery.each( [ "toggle", "show", "hide" ], function( i, name ) {
+ var cssFn = jQuery.fn[ name ];
+ jQuery.fn[ name ] = function( speed, easing, callback ) {
+ return speed == null || typeof speed === "boolean" ?
+ cssFn.apply( this, arguments ) :
+ this.animate( genFx( name, true ), speed, easing, callback );
+ };
+} );
+
+// Generate shortcuts for custom animations
+jQuery.each( {
+ slideDown: genFx( "show" ),
+ slideUp: genFx( "hide" ),
+ slideToggle: genFx( "toggle" ),
+ fadeIn: { opacity: "show" },
+ fadeOut: { opacity: "hide" },
+ fadeToggle: { opacity: "toggle" }
+}, function( name, props ) {
+ jQuery.fn[ name ] = function( speed, easing, callback ) {
+ return this.animate( props, speed, easing, callback );
+ };
+} );
+
+jQuery.timers = [];
+jQuery.fx.tick = function() {
+ var timer,
+ i = 0,
+ timers = jQuery.timers;
+
+ fxNow = jQuery.now();
+
+ for ( ; i < timers.length; i++ ) {
+ timer = timers[ i ];
+
+ // Run the timer and safely remove it when done (allowing for external removal)
+ if ( !timer() && timers[ i ] === timer ) {
+ timers.splice( i--, 1 );
+ }
+ }
+
+ if ( !timers.length ) {
+ jQuery.fx.stop();
+ }
+ fxNow = undefined;
+};
+
+jQuery.fx.timer = function( timer ) {
+ jQuery.timers.push( timer );
+ jQuery.fx.start();
+};
+
+jQuery.fx.interval = 13;
+jQuery.fx.start = function() {
+ if ( inProgress ) {
+ return;
+ }
+
+ inProgress = true;
+ schedule();
+};
+
+jQuery.fx.stop = function() {
+ inProgress = null;
+};
+
+jQuery.fx.speeds = {
+ slow: 600,
+ fast: 200,
+
+ // Default speed
+ _default: 400
+};
+
+
+// Based off of the plugin by Clint Helfers, with permission.
+// https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/
+jQuery.fn.delay = function( time, type ) {
+ time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
+ type = type || "fx";
+
+ return this.queue( type, function( next, hooks ) {
+ var timeout = window.setTimeout( next, time );
+ hooks.stop = function() {
+ window.clearTimeout( timeout );
+ };
+ } );
+};
+
+
+( function() {
+ var input = document.createElement( "input" ),
+ select = document.createElement( "select" ),
+ opt = select.appendChild( document.createElement( "option" ) );
+
+ input.type = "checkbox";
+
+ // Support: Android <=4.3 only
+ // Default value for a checkbox should be "on"
+ support.checkOn = input.value !== "";
+
+ // Support: IE <=11 only
+ // Must access selectedIndex to make default options select
+ support.optSelected = opt.selected;
+
+ // Support: IE <=11 only
+ // An input loses its value after becoming a radio
+ input = document.createElement( "input" );
+ input.value = "t";
+ input.type = "radio";
+ support.radioValue = input.value === "t";
+} )();
+
+
+var boolHook,
+ attrHandle = jQuery.expr.attrHandle;
+
+jQuery.fn.extend( {
+ attr: function( name, value ) {
+ return access( this, jQuery.attr, name, value, arguments.length > 1 );
+ },
+
+ removeAttr: function( name ) {
+ return this.each( function() {
+ jQuery.removeAttr( this, name );
+ } );
+ }
+} );
+
+jQuery.extend( {
+ attr: function( elem, name, value ) {
+ var ret, hooks,
+ nType = elem.nodeType;
+
+ // Don't get/set attributes on text, comment and attribute nodes
+ if ( nType === 3 || nType === 8 || nType === 2 ) {
+ return;
+ }
+
+ // Fallback to prop when attributes are not supported
+ if ( typeof elem.getAttribute === "undefined" ) {
+ return jQuery.prop( elem, name, value );
+ }
+
+ // Attribute hooks are determined by the lowercase version
+ // Grab necessary hook if one is defined
+ if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
+ hooks = jQuery.attrHooks[ name.toLowerCase() ] ||
+ ( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );
+ }
+
+ if ( value !== undefined ) {
+ if ( value === null ) {
+ jQuery.removeAttr( elem, name );
+ return;
+ }
+
+ if ( hooks && "set" in hooks &&
+ ( ret = hooks.set( elem, value, name ) ) !== undefined ) {
+ return ret;
+ }
+
+ elem.setAttribute( name, value + "" );
+ return value;
+ }
+
+ if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
+ return ret;
+ }
+
+ ret = jQuery.find.attr( elem, name );
+
+ // Non-existent attributes return null, we normalize to undefined
+ return ret == null ? undefined : ret;
+ },
+
+ attrHooks: {
+ type: {
+ set: function( elem, value ) {
+ if ( !support.radioValue && value === "radio" &&
+ nodeName( elem, "input" ) ) {
+ var val = elem.value;
+ elem.setAttribute( "type", value );
+ if ( val ) {
+ elem.value = val;
+ }
+ return value;
+ }
+ }
+ }
+ },
+
+ removeAttr: function( elem, value ) {
+ var name,
+ i = 0,
+
+ // Attribute names can contain non-HTML whitespace characters
+ // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
+ attrNames = value && value.match( rnothtmlwhite );
+
+ if ( attrNames && elem.nodeType === 1 ) {
+ while ( ( name = attrNames[ i++ ] ) ) {
+ elem.removeAttribute( name );
+ }
+ }
+ }
+} );
+
+// Hooks for boolean attributes
+boolHook = {
+ set: function( elem, value, name ) {
+ if ( value === false ) {
+
+ // Remove boolean attributes when set to false
+ jQuery.removeAttr( elem, name );
+ } else {
+ elem.setAttribute( name, name );
+ }
+ return name;
+ }
+};
+
+jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) {
+ var getter = attrHandle[ name ] || jQuery.find.attr;
+
+ attrHandle[ name ] = function( elem, name, isXML ) {
+ var ret, handle,
+ lowercaseName = name.toLowerCase();
+
+ if ( !isXML ) {
+
+ // Avoid an infinite loop by temporarily removing this function from the getter
+ handle = attrHandle[ lowercaseName ];
+ attrHandle[ lowercaseName ] = ret;
+ ret = getter( elem, name, isXML ) != null ?
+ lowercaseName :
+ null;
+ attrHandle[ lowercaseName ] = handle;
+ }
+ return ret;
+ };
+} );
+
+
+
+
+var rfocusable = /^(?:input|select|textarea|button)$/i,
+ rclickable = /^(?:a|area)$/i;
+
+jQuery.fn.extend( {
+ prop: function( name, value ) {
+ return access( this, jQuery.prop, name, value, arguments.length > 1 );
+ },
+
+ removeProp: function( name ) {
+ return this.each( function() {
+ delete this[ jQuery.propFix[ name ] || name ];
+ } );
+ }
+} );
+
+jQuery.extend( {
+ prop: function( elem, name, value ) {
+ var ret, hooks,
+ nType = elem.nodeType;
+
+ // Don't get/set properties on text, comment and attribute nodes
+ if ( nType === 3 || nType === 8 || nType === 2 ) {
+ return;
+ }
+
+ if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
+
+ // Fix name and attach hooks
+ name = jQuery.propFix[ name ] || name;
+ hooks = jQuery.propHooks[ name ];
+ }
+
+ if ( value !== undefined ) {
+ if ( hooks && "set" in hooks &&
+ ( ret = hooks.set( elem, value, name ) ) !== undefined ) {
+ return ret;
+ }
+
+ return ( elem[ name ] = value );
+ }
+
+ if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
+ return ret;
+ }
+
+ return elem[ name ];
+ },
+
+ propHooks: {
+ tabIndex: {
+ get: function( elem ) {
+
+ // Support: IE <=9 - 11 only
+ // elem.tabIndex doesn't always return the
+ // correct value when it hasn't been explicitly set
+ // https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
+ // Use proper attribute retrieval(#12072)
+ var tabindex = jQuery.find.attr( elem, "tabindex" );
+
+ if ( tabindex ) {
+ return parseInt( tabindex, 10 );
+ }
+
+ if (
+ rfocusable.test( elem.nodeName ) ||
+ rclickable.test( elem.nodeName ) &&
+ elem.href
+ ) {
+ return 0;
+ }
+
+ return -1;
+ }
+ }
+ },
+
+ propFix: {
+ "for": "htmlFor",
+ "class": "className"
+ }
+} );
+
+// Support: IE <=11 only
+// Accessing the selectedIndex property
+// forces the browser to respect setting selected
+// on the option
+// The getter ensures a default option is selected
+// when in an optgroup
+// eslint rule "no-unused-expressions" is disabled for this code
+// since it considers such accessions noop
+if ( !support.optSelected ) {
+ jQuery.propHooks.selected = {
+ get: function( elem ) {
+
+ /* eslint no-unused-expressions: "off" */
+
+ var parent = elem.parentNode;
+ if ( parent && parent.parentNode ) {
+ parent.parentNode.selectedIndex;
+ }
+ return null;
+ },
+ set: function( elem ) {
+
+ /* eslint no-unused-expressions: "off" */
+
+ var parent = elem.parentNode;
+ if ( parent ) {
+ parent.selectedIndex;
+
+ if ( parent.parentNode ) {
+ parent.parentNode.selectedIndex;
+ }
+ }
+ }
+ };
+}
+
+jQuery.each( [
+ "tabIndex",
+ "readOnly",
+ "maxLength",
+ "cellSpacing",
+ "cellPadding",
+ "rowSpan",
+ "colSpan",
+ "useMap",
+ "frameBorder",
+ "contentEditable"
+], function() {
+ jQuery.propFix[ this.toLowerCase() ] = this;
+} );
+
+
+
+
+ // Strip and collapse whitespace according to HTML spec
+ // https://html.spec.whatwg.org/multipage/infrastructure.html#strip-and-collapse-whitespace
+ function stripAndCollapse( value ) {
+ var tokens = value.match( rnothtmlwhite ) || [];
+ return tokens.join( " " );
+ }
+
+
+function getClass( elem ) {
+ return elem.getAttribute && elem.getAttribute( "class" ) || "";
+}
+
+jQuery.fn.extend( {
+ addClass: function( value ) {
+ var classes, elem, cur, curValue, clazz, j, finalValue,
+ i = 0;
+
+ if ( jQuery.isFunction( value ) ) {
+ return this.each( function( j ) {
+ jQuery( this ).addClass( value.call( this, j, getClass( this ) ) );
+ } );
+ }
+
+ if ( typeof value === "string" && value ) {
+ classes = value.match( rnothtmlwhite ) || [];
+
+ while ( ( elem = this[ i++ ] ) ) {
+ curValue = getClass( elem );
+ cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
+
+ if ( cur ) {
+ j = 0;
+ while ( ( clazz = classes[ j++ ] ) ) {
+ if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
+ cur += clazz + " ";
+ }
+ }
+
+ // Only assign if different to avoid unneeded rendering.
+ finalValue = stripAndCollapse( cur );
+ if ( curValue !== finalValue ) {
+ elem.setAttribute( "class", finalValue );
+ }
+ }
+ }
+ }
+
+ return this;
+ },
+
+ removeClass: function( value ) {
+ var classes, elem, cur, curValue, clazz, j, finalValue,
+ i = 0;
+
+ if ( jQuery.isFunction( value ) ) {
+ return this.each( function( j ) {
+ jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );
+ } );
+ }
+
+ if ( !arguments.length ) {
+ return this.attr( "class", "" );
+ }
+
+ if ( typeof value === "string" && value ) {
+ classes = value.match( rnothtmlwhite ) || [];
+
+ while ( ( elem = this[ i++ ] ) ) {
+ curValue = getClass( elem );
+
+ // This expression is here for better compressibility (see addClass)
+ cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
+
+ if ( cur ) {
+ j = 0;
+ while ( ( clazz = classes[ j++ ] ) ) {
+
+ // Remove *all* instances
+ while ( cur.indexOf( " " + clazz + " " ) > -1 ) {
+ cur = cur.replace( " " + clazz + " ", " " );
+ }
+ }
+
+ // Only assign if different to avoid unneeded rendering.
+ finalValue = stripAndCollapse( cur );
+ if ( curValue !== finalValue ) {
+ elem.setAttribute( "class", finalValue );
+ }
+ }
+ }
+ }
+
+ return this;
+ },
+
+ toggleClass: function( value, stateVal ) {
+ var type = typeof value;
+
+ if ( typeof stateVal === "boolean" && type === "string" ) {
+ return stateVal ? this.addClass( value ) : this.removeClass( value );
+ }
+
+ if ( jQuery.isFunction( value ) ) {
+ return this.each( function( i ) {
+ jQuery( this ).toggleClass(
+ value.call( this, i, getClass( this ), stateVal ),
+ stateVal
+ );
+ } );
+ }
+
+ return this.each( function() {
+ var className, i, self, classNames;
+
+ if ( type === "string" ) {
+
+ // Toggle individual class names
+ i = 0;
+ self = jQuery( this );
+ classNames = value.match( rnothtmlwhite ) || [];
+
+ while ( ( className = classNames[ i++ ] ) ) {
+
+ // Check each className given, space separated list
+ if ( self.hasClass( className ) ) {
+ self.removeClass( className );
+ } else {
+ self.addClass( className );
+ }
+ }
+
+ // Toggle whole class name
+ } else if ( value === undefined || type === "boolean" ) {
+ className = getClass( this );
+ if ( className ) {
+
+ // Store className if set
+ dataPriv.set( this, "__className__", className );
+ }
+
+ // If the element has a class name or if we're passed `false`,
+ // then remove the whole classname (if there was one, the above saved it).
+ // Otherwise bring back whatever was previously saved (if anything),
+ // falling back to the empty string if nothing was stored.
+ if ( this.setAttribute ) {
+ this.setAttribute( "class",
+ className || value === false ?
+ "" :
+ dataPriv.get( this, "__className__" ) || ""
+ );
+ }
+ }
+ } );
+ },
+
+ hasClass: function( selector ) {
+ var className, elem,
+ i = 0;
+
+ className = " " + selector + " ";
+ while ( ( elem = this[ i++ ] ) ) {
+ if ( elem.nodeType === 1 &&
+ ( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+} );
+
+
+
+
+var rreturn = /\r/g;
+
+jQuery.fn.extend( {
+ val: function( value ) {
+ var hooks, ret, isFunction,
+ elem = this[ 0 ];
+
+ if ( !arguments.length ) {
+ if ( elem ) {
+ hooks = jQuery.valHooks[ elem.type ] ||
+ jQuery.valHooks[ elem.nodeName.toLowerCase() ];
+
+ if ( hooks &&
+ "get" in hooks &&
+ ( ret = hooks.get( elem, "value" ) ) !== undefined
+ ) {
+ return ret;
+ }
+
+ ret = elem.value;
+
+ // Handle most common string cases
+ if ( typeof ret === "string" ) {
+ return ret.replace( rreturn, "" );
+ }
+
+ // Handle cases where value is null/undef or number
+ return ret == null ? "" : ret;
+ }
+
+ return;
+ }
+
+ isFunction = jQuery.isFunction( value );
+
+ return this.each( function( i ) {
+ var val;
+
+ if ( this.nodeType !== 1 ) {
+ return;
+ }
+
+ if ( isFunction ) {
+ val = value.call( this, i, jQuery( this ).val() );
+ } else {
+ val = value;
+ }
+
+ // Treat null/undefined as ""; convert numbers to string
+ if ( val == null ) {
+ val = "";
+
+ } else if ( typeof val === "number" ) {
+ val += "";
+
+ } else if ( Array.isArray( val ) ) {
+ val = jQuery.map( val, function( value ) {
+ return value == null ? "" : value + "";
+ } );
+ }
+
+ hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
+
+ // If set returns undefined, fall back to normal setting
+ if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) {
+ this.value = val;
+ }
+ } );
+ }
+} );
+
+jQuery.extend( {
+ valHooks: {
+ option: {
+ get: function( elem ) {
+
+ var val = jQuery.find.attr( elem, "value" );
+ return val != null ?
+ val :
+
+ // Support: IE <=10 - 11 only
+ // option.text throws exceptions (#14686, #14858)
+ // Strip and collapse whitespace
+ // https://html.spec.whatwg.org/#strip-and-collapse-whitespace
+ stripAndCollapse( jQuery.text( elem ) );
+ }
+ },
+ select: {
+ get: function( elem ) {
+ var value, option, i,
+ options = elem.options,
+ index = elem.selectedIndex,
+ one = elem.type === "select-one",
+ values = one ? null : [],
+ max = one ? index + 1 : options.length;
+
+ if ( index < 0 ) {
+ i = max;
+
+ } else {
+ i = one ? index : 0;
+ }
+
+ // Loop through all the selected options
+ for ( ; i < max; i++ ) {
+ option = options[ i ];
+
+ // Support: IE <=9 only
+ // IE8-9 doesn't update selected after form reset (#2551)
+ if ( ( option.selected || i === index ) &&
+
+ // Don't return options that are disabled or in a disabled optgroup
+ !option.disabled &&
+ ( !option.parentNode.disabled ||
+ !nodeName( option.parentNode, "optgroup" ) ) ) {
+
+ // Get the specific value for the option
+ value = jQuery( option ).val();
+
+ // We don't need an array for one selects
+ if ( one ) {
+ return value;
+ }
+
+ // Multi-Selects return an array
+ values.push( value );
+ }
+ }
+
+ return values;
+ },
+
+ set: function( elem, value ) {
+ var optionSet, option,
+ options = elem.options,
+ values = jQuery.makeArray( value ),
+ i = options.length;
+
+ while ( i-- ) {
+ option = options[ i ];
+
+ /* eslint-disable no-cond-assign */
+
+ if ( option.selected =
+ jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1
+ ) {
+ optionSet = true;
+ }
+
+ /* eslint-enable no-cond-assign */
+ }
+
+ // Force browsers to behave consistently when non-matching value is set
+ if ( !optionSet ) {
+ elem.selectedIndex = -1;
+ }
+ return values;
+ }
+ }
+ }
+} );
+
+// Radios and checkboxes getter/setter
+jQuery.each( [ "radio", "checkbox" ], function() {
+ jQuery.valHooks[ this ] = {
+ set: function( elem, value ) {
+ if ( Array.isArray( value ) ) {
+ return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );
+ }
+ }
+ };
+ if ( !support.checkOn ) {
+ jQuery.valHooks[ this ].get = function( elem ) {
+ return elem.getAttribute( "value" ) === null ? "on" : elem.value;
+ };
+ }
+} );
+
+
+
+
+// Return jQuery for attributes-only inclusion
+
+
+var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/;
+
+jQuery.extend( jQuery.event, {
+
+ trigger: function( event, data, elem, onlyHandlers ) {
+
+ var i, cur, tmp, bubbleType, ontype, handle, special,
+ eventPath = [ elem || document ],
+ type = hasOwn.call( event, "type" ) ? event.type : event,
+ namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : [];
+
+ cur = tmp = elem = elem || document;
+
+ // Don't do events on text and comment nodes
+ if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
+ return;
+ }
+
+ // focus/blur morphs to focusin/out; ensure we're not firing them right now
+ if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
+ return;
+ }
+
+ if ( type.indexOf( "." ) > -1 ) {
+
+ // Namespaced trigger; create a regexp to match event type in handle()
+ namespaces = type.split( "." );
+ type = namespaces.shift();
+ namespaces.sort();
+ }
+ ontype = type.indexOf( ":" ) < 0 && "on" + type;
+
+ // Caller can pass in a jQuery.Event object, Object, or just an event type string
+ event = event[ jQuery.expando ] ?
+ event :
+ new jQuery.Event( type, typeof event === "object" && event );
+
+ // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
+ event.isTrigger = onlyHandlers ? 2 : 3;
+ event.namespace = namespaces.join( "." );
+ event.rnamespace = event.namespace ?
+ new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) :
+ null;
+
+ // Clean up the event in case it is being reused
+ event.result = undefined;
+ if ( !event.target ) {
+ event.target = elem;
+ }
+
+ // Clone any incoming data and prepend the event, creating the handler arg list
+ data = data == null ?
+ [ event ] :
+ jQuery.makeArray( data, [ event ] );
+
+ // Allow special events to draw outside the lines
+ special = jQuery.event.special[ type ] || {};
+ if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
+ return;
+ }
+
+ // Determine event propagation path in advance, per W3C events spec (#9951)
+ // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
+ if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
+
+ bubbleType = special.delegateType || type;
+ if ( !rfocusMorph.test( bubbleType + type ) ) {
+ cur = cur.parentNode;
+ }
+ for ( ; cur; cur = cur.parentNode ) {
+ eventPath.push( cur );
+ tmp = cur;
+ }
+
+ // Only add window if we got to document (e.g., not plain obj or detached DOM)
+ if ( tmp === ( elem.ownerDocument || document ) ) {
+ eventPath.push( tmp.defaultView || tmp.parentWindow || window );
+ }
+ }
+
+ // Fire handlers on the event path
+ i = 0;
+ while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {
+
+ event.type = i > 1 ?
+ bubbleType :
+ special.bindType || type;
+
+ // jQuery handler
+ handle = ( dataPriv.get( cur, "events" ) || {} )[ event.type ] &&
+ dataPriv.get( cur, "handle" );
+ if ( handle ) {
+ handle.apply( cur, data );
+ }
+
+ // Native handler
+ handle = ontype && cur[ ontype ];
+ if ( handle && handle.apply && acceptData( cur ) ) {
+ event.result = handle.apply( cur, data );
+ if ( event.result === false ) {
+ event.preventDefault();
+ }
+ }
+ }
+ event.type = type;
+
+ // If nobody prevented the default action, do it now
+ if ( !onlyHandlers && !event.isDefaultPrevented() ) {
+
+ if ( ( !special._default ||
+ special._default.apply( eventPath.pop(), data ) === false ) &&
+ acceptData( elem ) ) {
+
+ // Call a native DOM method on the target with the same name as the event.
+ // Don't do default actions on window, that's where global variables be (#6170)
+ if ( ontype && jQuery.isFunction( elem[ type ] ) && !jQuery.isWindow( elem ) ) {
+
+ // Don't re-trigger an onFOO event when we call its FOO() method
+ tmp = elem[ ontype ];
+
+ if ( tmp ) {
+ elem[ ontype ] = null;
+ }
+
+ // Prevent re-triggering of the same event, since we already bubbled it above
+ jQuery.event.triggered = type;
+ elem[ type ]();
+ jQuery.event.triggered = undefined;
+
+ if ( tmp ) {
+ elem[ ontype ] = tmp;
+ }
+ }
+ }
+ }
+
+ return event.result;
+ },
+
+ // Piggyback on a donor event to simulate a different one
+ // Used only for `focus(in | out)` events
+ simulate: function( type, elem, event ) {
+ var e = jQuery.extend(
+ new jQuery.Event(),
+ event,
+ {
+ type: type,
+ isSimulated: true
+ }
+ );
+
+ jQuery.event.trigger( e, null, elem );
+ }
+
+} );
+
+jQuery.fn.extend( {
+
+ trigger: function( type, data ) {
+ return this.each( function() {
+ jQuery.event.trigger( type, data, this );
+ } );
+ },
+ triggerHandler: function( type, data ) {
+ var elem = this[ 0 ];
+ if ( elem ) {
+ return jQuery.event.trigger( type, data, elem, true );
+ }
+ }
+} );
+
+
+jQuery.each( ( "blur focus focusin focusout resize scroll click dblclick " +
+ "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
+ "change select submit keydown keypress keyup contextmenu" ).split( " " ),
+ function( i, name ) {
+
+ // Handle event binding
+ jQuery.fn[ name ] = function( data, fn ) {
+ return arguments.length > 0 ?
+ this.on( name, null, data, fn ) :
+ this.trigger( name );
+ };
+} );
+
+jQuery.fn.extend( {
+ hover: function( fnOver, fnOut ) {
+ return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
+ }
+} );
+
+
+
+
+support.focusin = "onfocusin" in window;
+
+
+// Support: Firefox <=44
+// Firefox doesn't have focus(in | out) events
+// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
+//
+// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1
+// focus(in | out) events fire after focus & blur events,
+// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order
+// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857
+if ( !support.focusin ) {
+ jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) {
+
+ // Attach a single capturing handler on the document while someone wants focusin/focusout
+ var handler = function( event ) {
+ jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) );
+ };
+
+ jQuery.event.special[ fix ] = {
+ setup: function() {
+ var doc = this.ownerDocument || this,
+ attaches = dataPriv.access( doc, fix );
+
+ if ( !attaches ) {
+ doc.addEventListener( orig, handler, true );
+ }
+ dataPriv.access( doc, fix, ( attaches || 0 ) + 1 );
+ },
+ teardown: function() {
+ var doc = this.ownerDocument || this,
+ attaches = dataPriv.access( doc, fix ) - 1;
+
+ if ( !attaches ) {
+ doc.removeEventListener( orig, handler, true );
+ dataPriv.remove( doc, fix );
+
+ } else {
+ dataPriv.access( doc, fix, attaches );
+ }
+ }
+ };
+ } );
+}
+var location = window.location;
+
+var nonce = jQuery.now();
+
+var rquery = ( /\?/ );
+
+
+
+// Cross-browser xml parsing
+jQuery.parseXML = function( data ) {
+ var xml;
+ if ( !data || typeof data !== "string" ) {
+ return null;
+ }
+
+ // Support: IE 9 - 11 only
+ // IE throws on parseFromString with invalid input.
+ try {
+ xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" );
+ } catch ( e ) {
+ xml = undefined;
+ }
+
+ if ( !xml || xml.getElementsByTagName( "parsererror" ).length ) {
+ jQuery.error( "Invalid XML: " + data );
+ }
+ return xml;
+};
+
+
+var
+ rbracket = /\[\]$/,
+ rCRLF = /\r?\n/g,
+ rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
+ rsubmittable = /^(?:input|select|textarea|keygen)/i;
+
+function buildParams( prefix, obj, traditional, add ) {
+ var name;
+
+ if ( Array.isArray( obj ) ) {
+
+ // Serialize array item.
+ jQuery.each( obj, function( i, v ) {
+ if ( traditional || rbracket.test( prefix ) ) {
+
+ // Treat each array item as a scalar.
+ add( prefix, v );
+
+ } else {
+
+ // Item is non-scalar (array or object), encode its numeric index.
+ buildParams(
+ prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]",
+ v,
+ traditional,
+ add
+ );
+ }
+ } );
+
+ } else if ( !traditional && jQuery.type( obj ) === "object" ) {
+
+ // Serialize object item.
+ for ( name in obj ) {
+ buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
+ }
+
+ } else {
+
+ // Serialize scalar item.
+ add( prefix, obj );
+ }
+}
+
+// Serialize an array of form elements or a set of
+// key/values into a query string
+jQuery.param = function( a, traditional ) {
+ var prefix,
+ s = [],
+ add = function( key, valueOrFunction ) {
+
+ // If value is a function, invoke it and use its return value
+ var value = jQuery.isFunction( valueOrFunction ) ?
+ valueOrFunction() :
+ valueOrFunction;
+
+ s[ s.length ] = encodeURIComponent( key ) + "=" +
+ encodeURIComponent( value == null ? "" : value );
+ };
+
+ // If an array was passed in, assume that it is an array of form elements.
+ if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
+
+ // Serialize the form elements
+ jQuery.each( a, function() {
+ add( this.name, this.value );
+ } );
+
+ } else {
+
+ // If traditional, encode the "old" way (the way 1.3.2 or older
+ // did it), otherwise encode params recursively.
+ for ( prefix in a ) {
+ buildParams( prefix, a[ prefix ], traditional, add );
+ }
+ }
+
+ // Return the resulting serialization
+ return s.join( "&" );
+};
+
+jQuery.fn.extend( {
+ serialize: function() {
+ return jQuery.param( this.serializeArray() );
+ },
+ serializeArray: function() {
+ return this.map( function() {
+
+ // Can add propHook for "elements" to filter or add form elements
+ var elements = jQuery.prop( this, "elements" );
+ return elements ? jQuery.makeArray( elements ) : this;
+ } )
+ .filter( function() {
+ var type = this.type;
+
+ // Use .is( ":disabled" ) so that fieldset[disabled] works
+ return this.name && !jQuery( this ).is( ":disabled" ) &&
+ rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&
+ ( this.checked || !rcheckableType.test( type ) );
+ } )
+ .map( function( i, elem ) {
+ var val = jQuery( this ).val();
+
+ if ( val == null ) {
+ return null;
+ }
+
+ if ( Array.isArray( val ) ) {
+ return jQuery.map( val, function( val ) {
+ return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
+ } );
+ }
+
+ return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
+ } ).get();
+ }
+} );
+
+
+var
+ r20 = /%20/g,
+ rhash = /#.*$/,
+ rantiCache = /([?&])_=[^&]*/,
+ rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,
+
+ // #7653, #8125, #8152: local protocol detection
+ rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
+ rnoContent = /^(?:GET|HEAD)$/,
+ rprotocol = /^\/\//,
+
+ /* Prefilters
+ * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
+ * 2) These are called:
+ * - BEFORE asking for a transport
+ * - AFTER param serialization (s.data is a string if s.processData is true)
+ * 3) key is the dataType
+ * 4) the catchall symbol "*" can be used
+ * 5) execution will start with transport dataType and THEN continue down to "*" if needed
+ */
+ prefilters = {},
+
+ /* Transports bindings
+ * 1) key is the dataType
+ * 2) the catchall symbol "*" can be used
+ * 3) selection will start with transport dataType and THEN go to "*" if needed
+ */
+ transports = {},
+
+ // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
+ allTypes = "*/".concat( "*" ),
+
+ // Anchor tag for parsing the document origin
+ originAnchor = document.createElement( "a" );
+ originAnchor.href = location.href;
+
+// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
+function addToPrefiltersOrTransports( structure ) {
+
+ // dataTypeExpression is optional and defaults to "*"
+ return function( dataTypeExpression, func ) {
+
+ if ( typeof dataTypeExpression !== "string" ) {
+ func = dataTypeExpression;
+ dataTypeExpression = "*";
+ }
+
+ var dataType,
+ i = 0,
+ dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];
+
+ if ( jQuery.isFunction( func ) ) {
+
+ // For each dataType in the dataTypeExpression
+ while ( ( dataType = dataTypes[ i++ ] ) ) {
+
+ // Prepend if requested
+ if ( dataType[ 0 ] === "+" ) {
+ dataType = dataType.slice( 1 ) || "*";
+ ( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );
+
+ // Otherwise append
+ } else {
+ ( structure[ dataType ] = structure[ dataType ] || [] ).push( func );
+ }
+ }
+ }
+ };
+}
+
+// Base inspection function for prefilters and transports
+function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {
+
+ var inspected = {},
+ seekingTransport = ( structure === transports );
+
+ function inspect( dataType ) {
+ var selected;
+ inspected[ dataType ] = true;
+ jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
+ var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
+ if ( typeof dataTypeOrTransport === "string" &&
+ !seekingTransport && !inspected[ dataTypeOrTransport ] ) {
+
+ options.dataTypes.unshift( dataTypeOrTransport );
+ inspect( dataTypeOrTransport );
+ return false;
+ } else if ( seekingTransport ) {
+ return !( selected = dataTypeOrTransport );
+ }
+ } );
+ return selected;
+ }
+
+ return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
+}
+
+// A special extend for ajax options
+// that takes "flat" options (not to be deep extended)
+// Fixes #9887
+function ajaxExtend( target, src ) {
+ var key, deep,
+ flatOptions = jQuery.ajaxSettings.flatOptions || {};
+
+ for ( key in src ) {
+ if ( src[ key ] !== undefined ) {
+ ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
+ }
+ }
+ if ( deep ) {
+ jQuery.extend( true, target, deep );
+ }
+
+ return target;
+}
+
+/* Handles responses to an ajax request:
+ * - finds the right dataType (mediates between content-type and expected dataType)
+ * - returns the corresponding response
+ */
+function ajaxHandleResponses( s, jqXHR, responses ) {
+
+ var ct, type, finalDataType, firstDataType,
+ contents = s.contents,
+ dataTypes = s.dataTypes;
+
+ // Remove auto dataType and get content-type in the process
+ while ( dataTypes[ 0 ] === "*" ) {
+ dataTypes.shift();
+ if ( ct === undefined ) {
+ ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" );
+ }
+ }
+
+ // Check if we're dealing with a known content-type
+ if ( ct ) {
+ for ( type in contents ) {
+ if ( contents[ type ] && contents[ type ].test( ct ) ) {
+ dataTypes.unshift( type );
+ break;
+ }
+ }
+ }
+
+ // Check to see if we have a response for the expected dataType
+ if ( dataTypes[ 0 ] in responses ) {
+ finalDataType = dataTypes[ 0 ];
+ } else {
+
+ // Try convertible dataTypes
+ for ( type in responses ) {
+ if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) {
+ finalDataType = type;
+ break;
+ }
+ if ( !firstDataType ) {
+ firstDataType = type;
+ }
+ }
+
+ // Or just use first one
+ finalDataType = finalDataType || firstDataType;
+ }
+
+ // If we found a dataType
+ // We add the dataType to the list if needed
+ // and return the corresponding response
+ if ( finalDataType ) {
+ if ( finalDataType !== dataTypes[ 0 ] ) {
+ dataTypes.unshift( finalDataType );
+ }
+ return responses[ finalDataType ];
+ }
+}
+
+/* Chain conversions given the request and the original response
+ * Also sets the responseXXX fields on the jqXHR instance
+ */
+function ajaxConvert( s, response, jqXHR, isSuccess ) {
+ var conv2, current, conv, tmp, prev,
+ converters = {},
+
+ // Work with a copy of dataTypes in case we need to modify it for conversion
+ dataTypes = s.dataTypes.slice();
+
+ // Create converters map with lowercased keys
+ if ( dataTypes[ 1 ] ) {
+ for ( conv in s.converters ) {
+ converters[ conv.toLowerCase() ] = s.converters[ conv ];
+ }
+ }
+
+ current = dataTypes.shift();
+
+ // Convert to each sequential dataType
+ while ( current ) {
+
+ if ( s.responseFields[ current ] ) {
+ jqXHR[ s.responseFields[ current ] ] = response;
+ }
+
+ // Apply the dataFilter if provided
+ if ( !prev && isSuccess && s.dataFilter ) {
+ response = s.dataFilter( response, s.dataType );
+ }
+
+ prev = current;
+ current = dataTypes.shift();
+
+ if ( current ) {
+
+ // There's only work to do if current dataType is non-auto
+ if ( current === "*" ) {
+
+ current = prev;
+
+ // Convert response if prev dataType is non-auto and differs from current
+ } else if ( prev !== "*" && prev !== current ) {
+
+ // Seek a direct converter
+ conv = converters[ prev + " " + current ] || converters[ "* " + current ];
+
+ // If none found, seek a pair
+ if ( !conv ) {
+ for ( conv2 in converters ) {
+
+ // If conv2 outputs current
+ tmp = conv2.split( " " );
+ if ( tmp[ 1 ] === current ) {
+
+ // If prev can be converted to accepted input
+ conv = converters[ prev + " " + tmp[ 0 ] ] ||
+ converters[ "* " + tmp[ 0 ] ];
+ if ( conv ) {
+
+ // Condense equivalence converters
+ if ( conv === true ) {
+ conv = converters[ conv2 ];
+
+ // Otherwise, insert the intermediate dataType
+ } else if ( converters[ conv2 ] !== true ) {
+ current = tmp[ 0 ];
+ dataTypes.unshift( tmp[ 1 ] );
+ }
+ break;
+ }
+ }
+ }
+ }
+
+ // Apply converter (if not an equivalence)
+ if ( conv !== true ) {
+
+ // Unless errors are allowed to bubble, catch and return them
+ if ( conv && s.throws ) {
+ response = conv( response );
+ } else {
+ try {
+ response = conv( response );
+ } catch ( e ) {
+ return {
+ state: "parsererror",
+ error: conv ? e : "No conversion from " + prev + " to " + current
+ };
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return { state: "success", data: response };
+}
+
+jQuery.extend( {
+
+ // Counter for holding the number of active queries
+ active: 0,
+
+ // Last-Modified header cache for next request
+ lastModified: {},
+ etag: {},
+
+ ajaxSettings: {
+ url: location.href,
+ type: "GET",
+ isLocal: rlocalProtocol.test( location.protocol ),
+ global: true,
+ processData: true,
+ async: true,
+ contentType: "application/x-www-form-urlencoded; charset=UTF-8",
+
+ /*
+ timeout: 0,
+ data: null,
+ dataType: null,
+ username: null,
+ password: null,
+ cache: null,
+ throws: false,
+ traditional: false,
+ headers: {},
+ */
+
+ accepts: {
+ "*": allTypes,
+ text: "text/plain",
+ html: "text/html",
+ xml: "application/xml, text/xml",
+ json: "application/json, text/javascript"
+ },
+
+ contents: {
+ xml: /\bxml\b/,
+ html: /\bhtml/,
+ json: /\bjson\b/
+ },
+
+ responseFields: {
+ xml: "responseXML",
+ text: "responseText",
+ json: "responseJSON"
+ },
+
+ // Data converters
+ // Keys separate source (or catchall "*") and destination types with a single space
+ converters: {
+
+ // Convert anything to text
+ "* text": String,
+
+ // Text to html (true = no transformation)
+ "text html": true,
+
+ // Evaluate text as a json expression
+ "text json": JSON.parse,
+
+ // Parse text as xml
+ "text xml": jQuery.parseXML
+ },
+
+ // For options that shouldn't be deep extended:
+ // you can add your own custom options here if
+ // and when you create one that shouldn't be
+ // deep extended (see ajaxExtend)
+ flatOptions: {
+ url: true,
+ context: true
+ }
+ },
+
+ // Creates a full fledged settings object into target
+ // with both ajaxSettings and settings fields.
+ // If target is omitted, writes into ajaxSettings.
+ ajaxSetup: function( target, settings ) {
+ return settings ?
+
+ // Building a settings object
+ ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :
+
+ // Extending ajaxSettings
+ ajaxExtend( jQuery.ajaxSettings, target );
+ },
+
+ ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
+ ajaxTransport: addToPrefiltersOrTransports( transports ),
+
+ // Main method
+ ajax: function( url, options ) {
+
+ // If url is an object, simulate pre-1.5 signature
+ if ( typeof url === "object" ) {
+ options = url;
+ url = undefined;
+ }
+
+ // Force options to be an object
+ options = options || {};
+
+ var transport,
+
+ // URL without anti-cache param
+ cacheURL,
+
+ // Response headers
+ responseHeadersString,
+ responseHeaders,
+
+ // timeout handle
+ timeoutTimer,
+
+ // Url cleanup var
+ urlAnchor,
+
+ // Request state (becomes false upon send and true upon completion)
+ completed,
+
+ // To know if global events are to be dispatched
+ fireGlobals,
+
+ // Loop variable
+ i,
+
+ // uncached part of the url
+ uncached,
+
+ // Create the final options object
+ s = jQuery.ajaxSetup( {}, options ),
+
+ // Callbacks context
+ callbackContext = s.context || s,
+
+ // Context for global events is callbackContext if it is a DOM node or jQuery collection
+ globalEventContext = s.context &&
+ ( callbackContext.nodeType || callbackContext.jquery ) ?
+ jQuery( callbackContext ) :
+ jQuery.event,
+
+ // Deferreds
+ deferred = jQuery.Deferred(),
+ completeDeferred = jQuery.Callbacks( "once memory" ),
+
+ // Status-dependent callbacks
+ statusCode = s.statusCode || {},
+
+ // Headers (they are sent all at once)
+ requestHeaders = {},
+ requestHeadersNames = {},
+
+ // Default abort message
+ strAbort = "canceled",
+
+ // Fake xhr
+ jqXHR = {
+ readyState: 0,
+
+ // Builds headers hashtable if needed
+ getResponseHeader: function( key ) {
+ var match;
+ if ( completed ) {
+ if ( !responseHeaders ) {
+ responseHeaders = {};
+ while ( ( match = rheaders.exec( responseHeadersString ) ) ) {
+ responseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ];
+ }
+ }
+ match = responseHeaders[ key.toLowerCase() ];
+ }
+ return match == null ? null : match;
+ },
+
+ // Raw string
+ getAllResponseHeaders: function() {
+ return completed ? responseHeadersString : null;
+ },
+
+ // Caches the header
+ setRequestHeader: function( name, value ) {
+ if ( completed == null ) {
+ name = requestHeadersNames[ name.toLowerCase() ] =
+ requestHeadersNames[ name.toLowerCase() ] || name;
+ requestHeaders[ name ] = value;
+ }
+ return this;
+ },
+
+ // Overrides response content-type header
+ overrideMimeType: function( type ) {
+ if ( completed == null ) {
+ s.mimeType = type;
+ }
+ return this;
+ },
+
+ // Status-dependent callbacks
+ statusCode: function( map ) {
+ var code;
+ if ( map ) {
+ if ( completed ) {
+
+ // Execute the appropriate callbacks
+ jqXHR.always( map[ jqXHR.status ] );
+ } else {
+
+ // Lazy-add the new callbacks in a way that preserves old ones
+ for ( code in map ) {
+ statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
+ }
+ }
+ }
+ return this;
+ },
+
+ // Cancel the request
+ abort: function( statusText ) {
+ var finalText = statusText || strAbort;
+ if ( transport ) {
+ transport.abort( finalText );
+ }
+ done( 0, finalText );
+ return this;
+ }
+ };
+
+ // Attach deferreds
+ deferred.promise( jqXHR );
+
+ // Add protocol if not provided (prefilters might expect it)
+ // Handle falsy url in the settings object (#10093: consistency with old signature)
+ // We also use the url parameter if available
+ s.url = ( ( url || s.url || location.href ) + "" )
+ .replace( rprotocol, location.protocol + "//" );
+
+ // Alias method option to type as per ticket #12004
+ s.type = options.method || options.type || s.method || s.type;
+
+ // Extract dataTypes list
+ s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ];
+
+ // A cross-domain request is in order when the origin doesn't match the current origin.
+ if ( s.crossDomain == null ) {
+ urlAnchor = document.createElement( "a" );
+
+ // Support: IE <=8 - 11, Edge 12 - 13
+ // IE throws exception on accessing the href property if url is malformed,
+ // e.g. http://example.com:80x/
+ try {
+ urlAnchor.href = s.url;
+
+ // Support: IE <=8 - 11 only
+ // Anchor's host property isn't correctly set when s.url is relative
+ urlAnchor.href = urlAnchor.href;
+ s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !==
+ urlAnchor.protocol + "//" + urlAnchor.host;
+ } catch ( e ) {
+
+ // If there is an error parsing the URL, assume it is crossDomain,
+ // it can be rejected by the transport if it is invalid
+ s.crossDomain = true;
+ }
+ }
+
+ // Convert data if not already a string
+ if ( s.data && s.processData && typeof s.data !== "string" ) {
+ s.data = jQuery.param( s.data, s.traditional );
+ }
+
+ // Apply prefilters
+ inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
+
+ // If request was aborted inside a prefilter, stop there
+ if ( completed ) {
+ return jqXHR;
+ }
+
+ // We can fire global events as of now if asked to
+ // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)
+ fireGlobals = jQuery.event && s.global;
+
+ // Watch for a new set of requests
+ if ( fireGlobals && jQuery.active++ === 0 ) {
+ jQuery.event.trigger( "ajaxStart" );
+ }
+
+ // Uppercase the type
+ s.type = s.type.toUpperCase();
+
+ // Determine if request has content
+ s.hasContent = !rnoContent.test( s.type );
+
+ // Save the URL in case we're toying with the If-Modified-Since
+ // and/or If-None-Match header later on
+ // Remove hash to simplify url manipulation
+ cacheURL = s.url.replace( rhash, "" );
+
+ // More options handling for requests with no content
+ if ( !s.hasContent ) {
+
+ // Remember the hash so we can put it back
+ uncached = s.url.slice( cacheURL.length );
+
+ // If data is available, append data to url
+ if ( s.data ) {
+ cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data;
+
+ // #9682: remove data so that it's not used in an eventual retry
+ delete s.data;
+ }
+
+ // Add or update anti-cache param if needed
+ if ( s.cache === false ) {
+ cacheURL = cacheURL.replace( rantiCache, "$1" );
+ uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce++ ) + uncached;
+ }
+
+ // Put hash and anti-cache on the URL that will be requested (gh-1732)
+ s.url = cacheURL + uncached;
+
+ // Change '%20' to '+' if this is encoded form body content (gh-2658)
+ } else if ( s.data && s.processData &&
+ ( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) {
+ s.data = s.data.replace( r20, "+" );
+ }
+
+ // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
+ if ( s.ifModified ) {
+ if ( jQuery.lastModified[ cacheURL ] ) {
+ jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );
+ }
+ if ( jQuery.etag[ cacheURL ] ) {
+ jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] );
+ }
+ }
+
+ // Set the correct header, if data is being sent
+ if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
+ jqXHR.setRequestHeader( "Content-Type", s.contentType );
+ }
+
+ // Set the Accepts header for the server, depending on the dataType
+ jqXHR.setRequestHeader(
+ "Accept",
+ s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?
+ s.accepts[ s.dataTypes[ 0 ] ] +
+ ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
+ s.accepts[ "*" ]
+ );
+
+ // Check for headers option
+ for ( i in s.headers ) {
+ jqXHR.setRequestHeader( i, s.headers[ i ] );
+ }
+
+ // Allow custom headers/mimetypes and early abort
+ if ( s.beforeSend &&
+ ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {
+
+ // Abort if not done already and return
+ return jqXHR.abort();
+ }
+
+ // Aborting is no longer a cancellation
+ strAbort = "abort";
+
+ // Install callbacks on deferreds
+ completeDeferred.add( s.complete );
+ jqXHR.done( s.success );
+ jqXHR.fail( s.error );
+
+ // Get transport
+ transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
+
+ // If no transport, we auto-abort
+ if ( !transport ) {
+ done( -1, "No Transport" );
+ } else {
+ jqXHR.readyState = 1;
+
+ // Send global event
+ if ( fireGlobals ) {
+ globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
+ }
+
+ // If request was aborted inside ajaxSend, stop there
+ if ( completed ) {
+ return jqXHR;
+ }
+
+ // Timeout
+ if ( s.async && s.timeout > 0 ) {
+ timeoutTimer = window.setTimeout( function() {
+ jqXHR.abort( "timeout" );
+ }, s.timeout );
+ }
+
+ try {
+ completed = false;
+ transport.send( requestHeaders, done );
+ } catch ( e ) {
+
+ // Rethrow post-completion exceptions
+ if ( completed ) {
+ throw e;
+ }
+
+ // Propagate others as results
+ done( -1, e );
+ }
+ }
+
+ // Callback for when everything is done
+ function done( status, nativeStatusText, responses, headers ) {
+ var isSuccess, success, error, response, modified,
+ statusText = nativeStatusText;
+
+ // Ignore repeat invocations
+ if ( completed ) {
+ return;
+ }
+
+ completed = true;
+
+ // Clear timeout if it exists
+ if ( timeoutTimer ) {
+ window.clearTimeout( timeoutTimer );
+ }
+
+ // Dereference transport for early garbage collection
+ // (no matter how long the jqXHR object will be used)
+ transport = undefined;
+
+ // Cache response headers
+ responseHeadersString = headers || "";
+
+ // Set readyState
+ jqXHR.readyState = status > 0 ? 4 : 0;
+
+ // Determine if successful
+ isSuccess = status >= 200 && status < 300 || status === 304;
+
+ // Get response data
+ if ( responses ) {
+ response = ajaxHandleResponses( s, jqXHR, responses );
+ }
+
+ // Convert no matter what (that way responseXXX fields are always set)
+ response = ajaxConvert( s, response, jqXHR, isSuccess );
+
+ // If successful, handle type chaining
+ if ( isSuccess ) {
+
+ // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
+ if ( s.ifModified ) {
+ modified = jqXHR.getResponseHeader( "Last-Modified" );
+ if ( modified ) {
+ jQuery.lastModified[ cacheURL ] = modified;
+ }
+ modified = jqXHR.getResponseHeader( "etag" );
+ if ( modified ) {
+ jQuery.etag[ cacheURL ] = modified;
+ }
+ }
+
+ // if no content
+ if ( status === 204 || s.type === "HEAD" ) {
+ statusText = "nocontent";
+
+ // if not modified
+ } else if ( status === 304 ) {
+ statusText = "notmodified";
+
+ // If we have data, let's convert it
+ } else {
+ statusText = response.state;
+ success = response.data;
+ error = response.error;
+ isSuccess = !error;
+ }
+ } else {
+
+ // Extract error from statusText and normalize for non-aborts
+ error = statusText;
+ if ( status || !statusText ) {
+ statusText = "error";
+ if ( status < 0 ) {
+ status = 0;
+ }
+ }
+ }
+
+ // Set data for the fake xhr object
+ jqXHR.status = status;
+ jqXHR.statusText = ( nativeStatusText || statusText ) + "";
+
+ // Success/Error
+ if ( isSuccess ) {
+ deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
+ } else {
+ deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
+ }
+
+ // Status-dependent callbacks
+ jqXHR.statusCode( statusCode );
+ statusCode = undefined;
+
+ if ( fireGlobals ) {
+ globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
+ [ jqXHR, s, isSuccess ? success : error ] );
+ }
+
+ // Complete
+ completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
+
+ if ( fireGlobals ) {
+ globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
+
+ // Handle the global AJAX counter
+ if ( !( --jQuery.active ) ) {
+ jQuery.event.trigger( "ajaxStop" );
+ }
+ }
+ }
+
+ return jqXHR;
+ },
+
+ getJSON: function( url, data, callback ) {
+ return jQuery.get( url, data, callback, "json" );
+ },
+
+ getScript: function( url, callback ) {
+ return jQuery.get( url, undefined, callback, "script" );
+ }
+} );
+
+jQuery.each( [ "get", "post" ], function( i, method ) {
+ jQuery[ method ] = function( url, data, callback, type ) {
+
+ // Shift arguments if data argument was omitted
+ if ( jQuery.isFunction( data ) ) {
+ type = type || callback;
+ callback = data;
+ data = undefined;
+ }
+
+ // The url can be an options object (which then must have .url)
+ return jQuery.ajax( jQuery.extend( {
+ url: url,
+ type: method,
+ dataType: type,
+ data: data,
+ success: callback
+ }, jQuery.isPlainObject( url ) && url ) );
+ };
+} );
+
+
+jQuery._evalUrl = function( url ) {
+ return jQuery.ajax( {
+ url: url,
+
+ // Make this explicit, since user can override this through ajaxSetup (#11264)
+ type: "GET",
+ dataType: "script",
+ cache: true,
+ async: false,
+ global: false,
+ "throws": true
+ } );
+};
+
+
+jQuery.fn.extend( {
+ wrapAll: function( html ) {
+ var wrap;
+
+ if ( this[ 0 ] ) {
+ if ( jQuery.isFunction( html ) ) {
+ html = html.call( this[ 0 ] );
+ }
+
+ // The elements to wrap the target around
+ wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );
+
+ if ( this[ 0 ].parentNode ) {
+ wrap.insertBefore( this[ 0 ] );
+ }
+
+ wrap.map( function() {
+ var elem = this;
+
+ while ( elem.firstElementChild ) {
+ elem = elem.firstElementChild;
+ }
+
+ return elem;
+ } ).append( this );
+ }
+
+ return this;
+ },
+
+ wrapInner: function( html ) {
+ if ( jQuery.isFunction( html ) ) {
+ return this.each( function( i ) {
+ jQuery( this ).wrapInner( html.call( this, i ) );
+ } );
+ }
+
+ return this.each( function() {
+ var self = jQuery( this ),
+ contents = self.contents();
+
+ if ( contents.length ) {
+ contents.wrapAll( html );
+
+ } else {
+ self.append( html );
+ }
+ } );
+ },
+
+ wrap: function( html ) {
+ var isFunction = jQuery.isFunction( html );
+
+ return this.each( function( i ) {
+ jQuery( this ).wrapAll( isFunction ? html.call( this, i ) : html );
+ } );
+ },
+
+ unwrap: function( selector ) {
+ this.parent( selector ).not( "body" ).each( function() {
+ jQuery( this ).replaceWith( this.childNodes );
+ } );
+ return this;
+ }
+} );
+
+
+jQuery.expr.pseudos.hidden = function( elem ) {
+ return !jQuery.expr.pseudos.visible( elem );
+};
+jQuery.expr.pseudos.visible = function( elem ) {
+ return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );
+};
+
+
+
+
+jQuery.ajaxSettings.xhr = function() {
+ try {
+ return new window.XMLHttpRequest();
+ } catch ( e ) {}
+};
+
+var xhrSuccessStatus = {
+
+ // File protocol always yields status code 0, assume 200
+ 0: 200,
+
+ // Support: IE <=9 only
+ // #1450: sometimes IE returns 1223 when it should be 204
+ 1223: 204
+ },
+ xhrSupported = jQuery.ajaxSettings.xhr();
+
+support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
+support.ajax = xhrSupported = !!xhrSupported;
+
+jQuery.ajaxTransport( function( options ) {
+ var callback, errorCallback;
+
+ // Cross domain only allowed if supported through XMLHttpRequest
+ if ( support.cors || xhrSupported && !options.crossDomain ) {
+ return {
+ send: function( headers, complete ) {
+ var i,
+ xhr = options.xhr();
+
+ xhr.open(
+ options.type,
+ options.url,
+ options.async,
+ options.username,
+ options.password
+ );
+
+ // Apply custom fields if provided
+ if ( options.xhrFields ) {
+ for ( i in options.xhrFields ) {
+ xhr[ i ] = options.xhrFields[ i ];
+ }
+ }
+
+ // Override mime type if needed
+ if ( options.mimeType && xhr.overrideMimeType ) {
+ xhr.overrideMimeType( options.mimeType );
+ }
+
+ // X-Requested-With header
+ // For cross-domain requests, seeing as conditions for a preflight are
+ // akin to a jigsaw puzzle, we simply never set it to be sure.
+ // (it can always be set on a per-request basis or even using ajaxSetup)
+ // For same-domain requests, won't change header if already provided.
+ if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) {
+ headers[ "X-Requested-With" ] = "XMLHttpRequest";
+ }
+
+ // Set headers
+ for ( i in headers ) {
+ xhr.setRequestHeader( i, headers[ i ] );
+ }
+
+ // Callback
+ callback = function( type ) {
+ return function() {
+ if ( callback ) {
+ callback = errorCallback = xhr.onload =
+ xhr.onerror = xhr.onabort = xhr.onreadystatechange = null;
+
+ if ( type === "abort" ) {
+ xhr.abort();
+ } else if ( type === "error" ) {
+
+ // Support: IE <=9 only
+ // On a manual native abort, IE9 throws
+ // errors on any property access that is not readyState
+ if ( typeof xhr.status !== "number" ) {
+ complete( 0, "error" );
+ } else {
+ complete(
+
+ // File: protocol always yields status 0; see #8605, #14207
+ xhr.status,
+ xhr.statusText
+ );
+ }
+ } else {
+ complete(
+ xhrSuccessStatus[ xhr.status ] || xhr.status,
+ xhr.statusText,
+
+ // Support: IE <=9 only
+ // IE9 has no XHR2 but throws on binary (trac-11426)
+ // For XHR2 non-text, let the caller handle it (gh-2498)
+ ( xhr.responseType || "text" ) !== "text" ||
+ typeof xhr.responseText !== "string" ?
+ { binary: xhr.response } :
+ { text: xhr.responseText },
+ xhr.getAllResponseHeaders()
+ );
+ }
+ }
+ };
+ };
+
+ // Listen to events
+ xhr.onload = callback();
+ errorCallback = xhr.onerror = callback( "error" );
+
+ // Support: IE 9 only
+ // Use onreadystatechange to replace onabort
+ // to handle uncaught aborts
+ if ( xhr.onabort !== undefined ) {
+ xhr.onabort = errorCallback;
+ } else {
+ xhr.onreadystatechange = function() {
+
+ // Check readyState before timeout as it changes
+ if ( xhr.readyState === 4 ) {
+
+ // Allow onerror to be called first,
+ // but that will not handle a native abort
+ // Also, save errorCallback to a variable
+ // as xhr.onerror cannot be accessed
+ window.setTimeout( function() {
+ if ( callback ) {
+ errorCallback();
+ }
+ } );
+ }
+ };
+ }
+
+ // Create the abort callback
+ callback = callback( "abort" );
+
+ try {
+
+ // Do send the request (this may raise an exception)
+ xhr.send( options.hasContent && options.data || null );
+ } catch ( e ) {
+
+ // #14683: Only rethrow if this hasn't been notified as an error yet
+ if ( callback ) {
+ throw e;
+ }
+ }
+ },
+
+ abort: function() {
+ if ( callback ) {
+ callback();
+ }
+ }
+ };
+ }
+} );
+
+
+
+
+// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)
+jQuery.ajaxPrefilter( function( s ) {
+ if ( s.crossDomain ) {
+ s.contents.script = false;
+ }
+} );
+
+// Install script dataType
+jQuery.ajaxSetup( {
+ accepts: {
+ script: "text/javascript, application/javascript, " +
+ "application/ecmascript, application/x-ecmascript"
+ },
+ contents: {
+ script: /\b(?:java|ecma)script\b/
+ },
+ converters: {
+ "text script": function( text ) {
+ jQuery.globalEval( text );
+ return text;
+ }
+ }
+} );
+
+// Handle cache's special case and crossDomain
+jQuery.ajaxPrefilter( "script", function( s ) {
+ if ( s.cache === undefined ) {
+ s.cache = false;
+ }
+ if ( s.crossDomain ) {
+ s.type = "GET";
+ }
+} );
+
+// Bind script tag hack transport
+jQuery.ajaxTransport( "script", function( s ) {
+
+ // This transport only deals with cross domain requests
+ if ( s.crossDomain ) {
+ var script, callback;
+ return {
+ send: function( _, complete ) {
+ script = jQuery( "<script>" ).prop( {
+ charset: s.scriptCharset,
+ src: s.url
+ } ).on(
+ "load error",
+ callback = function( evt ) {
+ script.remove();
+ callback = null;
+ if ( evt ) {
+ complete( evt.type === "error" ? 404 : 200, evt.type );
+ }
+ }
+ );
+
+ // Use native DOM manipulation to avoid our domManip AJAX trickery
+ document.head.appendChild( script[ 0 ] );
+ },
+ abort: function() {
+ if ( callback ) {
+ callback();
+ }
+ }
+ };
+ }
+} );
+
+
+
+
+var oldCallbacks = [],
+ rjsonp = /(=)\?(?=&|$)|\?\?/;
+
+// Default jsonp settings
+jQuery.ajaxSetup( {
+ jsonp: "callback",
+ jsonpCallback: function() {
+ var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) );
+ this[ callback ] = true;
+ return callback;
+ }
+} );
+
+// Detect, normalize options and install callbacks for jsonp requests
+jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
+
+ var callbackName, overwritten, responseContainer,
+ jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?
+ "url" :
+ typeof s.data === "string" &&
+ ( s.contentType || "" )
+ .indexOf( "application/x-www-form-urlencoded" ) === 0 &&
+ rjsonp.test( s.data ) && "data"
+ );
+
+ // Handle iff the expected data type is "jsonp" or we have a parameter to set
+ if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {
+
+ // Get callback name, remembering preexisting value associated with it
+ callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ?
+ s.jsonpCallback() :
+ s.jsonpCallback;
+
+ // Insert callback into url or form data
+ if ( jsonProp ) {
+ s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName );
+ } else if ( s.jsonp !== false ) {
+ s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
+ }
+
+ // Use data converter to retrieve json after script execution
+ s.converters[ "script json" ] = function() {
+ if ( !responseContainer ) {
+ jQuery.error( callbackName + " was not called" );
+ }
+ return responseContainer[ 0 ];
+ };
+
+ // Force json dataType
+ s.dataTypes[ 0 ] = "json";
+
+ // Install callback
+ overwritten = window[ callbackName ];
+ window[ callbackName ] = function() {
+ responseContainer = arguments;
+ };
+
+ // Clean-up function (fires after converters)
+ jqXHR.always( function() {
+
+ // If previous value didn't exist - remove it
+ if ( overwritten === undefined ) {
+ jQuery( window ).removeProp( callbackName );
+
+ // Otherwise restore preexisting value
+ } else {
+ window[ callbackName ] = overwritten;
+ }
+
+ // Save back as free
+ if ( s[ callbackName ] ) {
+
+ // Make sure that re-using the options doesn't screw things around
+ s.jsonpCallback = originalSettings.jsonpCallback;
+
+ // Save the callback name for future use
+ oldCallbacks.push( callbackName );
+ }
+
+ // Call if it was a function and we have a response
+ if ( responseContainer && jQuery.isFunction( overwritten ) ) {
+ overwritten( responseContainer[ 0 ] );
+ }
+
+ responseContainer = overwritten = undefined;
+ } );
+
+ // Delegate to script
+ return "script";
+ }
+} );
+
+
+
+
+// Support: Safari 8 only
+// In Safari 8 documents created via document.implementation.createHTMLDocument
+// collapse sibling forms: the second one becomes a child of the first one.
+// Because of that, this security measure has to be disabled in Safari 8.
+// https://bugs.webkit.org/show_bug.cgi?id=137337
+support.createHTMLDocument = ( function() {
+ var body = document.implementation.createHTMLDocument( "" ).body;
+ body.innerHTML = "<form></form><form></form>";
+ return body.childNodes.length === 2;
+} )();
+
+
+// Argument "data" should be string of html
+// context (optional): If specified, the fragment will be created in this context,
+// defaults to document
+// keepScripts (optional): If true, will include scripts passed in the html string
+jQuery.parseHTML = function( data, context, keepScripts ) {
+ if ( typeof data !== "string" ) {
+ return [];
+ }
+ if ( typeof context === "boolean" ) {
+ keepScripts = context;
+ context = false;
+ }
+
+ var base, parsed, scripts;
+
+ if ( !context ) {
+
+ // Stop scripts or inline event handlers from being executed immediately
+ // by using document.implementation
+ if ( support.createHTMLDocument ) {
+ context = document.implementation.createHTMLDocument( "" );
+
+ // Set the base href for the created document
+ // so any parsed elements with URLs
+ // are based on the document's URL (gh-2965)
+ base = context.createElement( "base" );
+ base.href = document.location.href;
+ context.head.appendChild( base );
+ } else {
+ context = document;
+ }
+ }
+
+ parsed = rsingleTag.exec( data );
+ scripts = !keepScripts && [];
+
+ // Single tag
+ if ( parsed ) {
+ return [ context.createElement( parsed[ 1 ] ) ];
+ }
+
+ parsed = buildFragment( [ data ], context, scripts );
+
+ if ( scripts && scripts.length ) {
+ jQuery( scripts ).remove();
+ }
+
+ return jQuery.merge( [], parsed.childNodes );
+};
+
+
+/**
+ * Load a url into a page
+ */
+jQuery.fn.load = function( url, params, callback ) {
+ var selector, type, response,
+ self = this,
+ off = url.indexOf( " " );
+
+ if ( off > -1 ) {
+ selector = stripAndCollapse( url.slice( off ) );
+ url = url.slice( 0, off );
+ }
+
+ // If it's a function
+ if ( jQuery.isFunction( params ) ) {
+
+ // We assume that it's the callback
+ callback = params;
+ params = undefined;
+
+ // Otherwise, build a param string
+ } else if ( params && typeof params === "object" ) {
+ type = "POST";
+ }
+
+ // If we have elements to modify, make the request
+ if ( self.length > 0 ) {
+ jQuery.ajax( {
+ url: url,
+
+ // If "type" variable is undefined, then "GET" method will be used.
+ // Make value of this field explicit since
+ // user can override it through ajaxSetup method
+ type: type || "GET",
+ dataType: "html",
+ data: params
+ } ).done( function( responseText ) {
+
+ // Save response for use in complete callback
+ response = arguments;
+
+ self.html( selector ?
+
+ // If a selector was specified, locate the right elements in a dummy div
+ // Exclude scripts to avoid IE 'Permission Denied' errors
+ jQuery( "<div>" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :
+
+ // Otherwise use the full result
+ responseText );
+
+ // If the request succeeds, this function gets "data", "status", "jqXHR"
+ // but they are ignored because response was set above.
+ // If it fails, this function gets "jqXHR", "status", "error"
+ } ).always( callback && function( jqXHR, status ) {
+ self.each( function() {
+ callback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );
+ } );
+ } );
+ }
+
+ return this;
+};
+
+
+
+
+// Attach a bunch of functions for handling common AJAX events
+jQuery.each( [
+ "ajaxStart",
+ "ajaxStop",
+ "ajaxComplete",
+ "ajaxError",
+ "ajaxSuccess",
+ "ajaxSend"
+], function( i, type ) {
+ jQuery.fn[ type ] = function( fn ) {
+ return this.on( type, fn );
+ };
+} );
+
+
+
+
+jQuery.expr.pseudos.animated = function( elem ) {
+ return jQuery.grep( jQuery.timers, function( fn ) {
+ return elem === fn.elem;
+ } ).length;
+};
+
+
+
+
+jQuery.offset = {
+ setOffset: function( elem, options, i ) {
+ var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,
+ position = jQuery.css( elem, "position" ),
+ curElem = jQuery( elem ),
+ props = {};
+
+ // Set position first, in-case top/left are set even on static elem
+ if ( position === "static" ) {
+ elem.style.position = "relative";
+ }
+
+ curOffset = curElem.offset();
+ curCSSTop = jQuery.css( elem, "top" );
+ curCSSLeft = jQuery.css( elem, "left" );
+ calculatePosition = ( position === "absolute" || position === "fixed" ) &&
+ ( curCSSTop + curCSSLeft ).indexOf( "auto" ) > -1;
+
+ // Need to be able to calculate position if either
+ // top or left is auto and position is either absolute or fixed
+ if ( calculatePosition ) {
+ curPosition = curElem.position();
+ curTop = curPosition.top;
+ curLeft = curPosition.left;
+
+ } else {
+ curTop = parseFloat( curCSSTop ) || 0;
+ curLeft = parseFloat( curCSSLeft ) || 0;
+ }
+
+ if ( jQuery.isFunction( options ) ) {
+
+ // Use jQuery.extend here to allow modification of coordinates argument (gh-1848)
+ options = options.call( elem, i, jQuery.extend( {}, curOffset ) );
+ }
+
+ if ( options.top != null ) {
+ props.top = ( options.top - curOffset.top ) + curTop;
+ }
+ if ( options.left != null ) {
+ props.left = ( options.left - curOffset.left ) + curLeft;
+ }
+
+ if ( "using" in options ) {
+ options.using.call( elem, props );
+
+ } else {
+ curElem.css( props );
+ }
+ }
+};
+
+jQuery.fn.extend( {
+ offset: function( options ) {
+
+ // Preserve chaining for setter
+ if ( arguments.length ) {
+ return options === undefined ?
+ this :
+ this.each( function( i ) {
+ jQuery.offset.setOffset( this, options, i );
+ } );
+ }
+
+ var doc, docElem, rect, win,
+ elem = this[ 0 ];
+
+ if ( !elem ) {
+ return;
+ }
+
+ // Return zeros for disconnected and hidden (display: none) elements (gh-2310)
+ // Support: IE <=11 only
+ // Running getBoundingClientRect on a
+ // disconnected node in IE throws an error
+ if ( !elem.getClientRects().length ) {
+ return { top: 0, left: 0 };
+ }
+
+ rect = elem.getBoundingClientRect();
+
+ doc = elem.ownerDocument;
+ docElem = doc.documentElement;
+ win = doc.defaultView;
+
+ return {
+ top: rect.top + win.pageYOffset - docElem.clientTop,
+ left: rect.left + win.pageXOffset - docElem.clientLeft
+ };
+ },
+
+ position: function() {
+ if ( !this[ 0 ] ) {
+ return;
+ }
+
+ var offsetParent, offset,
+ elem = this[ 0 ],
+ parentOffset = { top: 0, left: 0 };
+
+ // Fixed elements are offset from window (parentOffset = {top:0, left: 0},
+ // because it is its only offset parent
+ if ( jQuery.css( elem, "position" ) === "fixed" ) {
+
+ // Assume getBoundingClientRect is there when computed position is fixed
+ offset = elem.getBoundingClientRect();
+
+ } else {
+
+ // Get *real* offsetParent
+ offsetParent = this.offsetParent();
+
+ // Get correct offsets
+ offset = this.offset();
+ if ( !nodeName( offsetParent[ 0 ], "html" ) ) {
+ parentOffset = offsetParent.offset();
+ }
+
+ // Add offsetParent borders
+ parentOffset = {
+ top: parentOffset.top + jQuery.css( offsetParent[ 0 ], "borderTopWidth", true ),
+ left: parentOffset.left + jQuery.css( offsetParent[ 0 ], "borderLeftWidth", true )
+ };
+ }
+
+ // Subtract parent offsets and element margins
+ return {
+ top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ),
+ left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true )
+ };
+ },
+
+ // This method will return documentElement in the following cases:
+ // 1) For the element inside the iframe without offsetParent, this method will return
+ // documentElement of the parent window
+ // 2) For the hidden or detached element
+ // 3) For body or html element, i.e. in case of the html node - it will return itself
+ //
+ // but those exceptions were never presented as a real life use-cases
+ // and might be considered as more preferable results.
+ //
+ // This logic, however, is not guaranteed and can change at any point in the future
+ offsetParent: function() {
+ return this.map( function() {
+ var offsetParent = this.offsetParent;
+
+ while ( offsetParent && jQuery.css( offsetParent, "position" ) === "static" ) {
+ offsetParent = offsetParent.offsetParent;
+ }
+
+ return offsetParent || documentElement;
+ } );
+ }
+} );
+
+// Create scrollLeft and scrollTop methods
+jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) {
+ var top = "pageYOffset" === prop;
+
+ jQuery.fn[ method ] = function( val ) {
+ return access( this, function( elem, method, val ) {
+
+ // Coalesce documents and windows
+ var win;
+ if ( jQuery.isWindow( elem ) ) {
+ win = elem;
+ } else if ( elem.nodeType === 9 ) {
+ win = elem.defaultView;
+ }
+
+ if ( val === undefined ) {
+ return win ? win[ prop ] : elem[ method ];
+ }
+
+ if ( win ) {
+ win.scrollTo(
+ !top ? val : win.pageXOffset,
+ top ? val : win.pageYOffset
+ );
+
+ } else {
+ elem[ method ] = val;
+ }
+ }, method, val, arguments.length );
+ };
+} );
+
+// Support: Safari <=7 - 9.1, Chrome <=37 - 49
+// Add the top/left cssHooks using jQuery.fn.position
+// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
+// Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347
+// getComputedStyle returns percent when specified for top/left/bottom/right;
+// rather than make the css module depend on the offset module, just check for it here
+jQuery.each( [ "top", "left" ], function( i, prop ) {
+ jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,
+ function( elem, computed ) {
+ if ( computed ) {
+ computed = curCSS( elem, prop );
+
+ // If curCSS returns percentage, fallback to offset
+ return rnumnonpx.test( computed ) ?
+ jQuery( elem ).position()[ prop ] + "px" :
+ computed;
+ }
+ }
+ );
+} );
+
+
+// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
+jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
+ jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name },
+ function( defaultExtra, funcName ) {
+
+ // Margin is only for outerHeight, outerWidth
+ jQuery.fn[ funcName ] = function( margin, value ) {
+ var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
+ extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );
+
+ return access( this, function( elem, type, value ) {
+ var doc;
+
+ if ( jQuery.isWindow( elem ) ) {
+
+ // $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)
+ return funcName.indexOf( "outer" ) === 0 ?
+ elem[ "inner" + name ] :
+ elem.document.documentElement[ "client" + name ];
+ }
+
+ // Get document width or height
+ if ( elem.nodeType === 9 ) {
+ doc = elem.documentElement;
+
+ // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
+ // whichever is greatest
+ return Math.max(
+ elem.body[ "scroll" + name ], doc[ "scroll" + name ],
+ elem.body[ "offset" + name ], doc[ "offset" + name ],
+ doc[ "client" + name ]
+ );
+ }
+
+ return value === undefined ?
+
+ // Get width or height on the element, requesting but not forcing parseFloat
+ jQuery.css( elem, type, extra ) :
+
+ // Set width or height on the element
+ jQuery.style( elem, type, value, extra );
+ }, type, chainable ? margin : undefined, chainable );
+ };
+ } );
+} );
+
+
+jQuery.fn.extend( {
+
+ bind: function( types, data, fn ) {
+ return this.on( types, null, data, fn );
+ },
+ unbind: function( types, fn ) {
+ return this.off( types, null, fn );
+ },
+
+ delegate: function( selector, types, data, fn ) {
+ return this.on( types, selector, data, fn );
+ },
+ undelegate: function( selector, types, fn ) {
+
+ // ( namespace ) or ( selector, types [, fn] )
+ return arguments.length === 1 ?
+ this.off( selector, "**" ) :
+ this.off( types, selector || "**", fn );
+ }
+} );
+
+jQuery.holdReady = function( hold ) {
+ if ( hold ) {
+ jQuery.readyWait++;
+ } else {
+ jQuery.ready( true );
+ }
+};
+jQuery.isArray = Array.isArray;
+jQuery.parseJSON = JSON.parse;
+jQuery.nodeName = nodeName;
+
+
+
+
+// Register as a named AMD module, since jQuery can be concatenated with other
+// files that may use define, but not via a proper concatenation script that
+// understands anonymous AMD modules. A named AMD is safest and most robust
+// way to register. Lowercase jquery is used because AMD module names are
+// derived from file names, and jQuery is normally delivered in a lowercase
+// file name. Do this after creating the global so that if an AMD module wants
+// to call noConflict to hide this version of jQuery, it will work.
+
+// Note that for maximum portability, libraries that are not jQuery should
+// declare themselves as anonymous modules, and avoid setting a global if an
+// AMD loader is present. jQuery is a special case. For more information, see
+// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon
+
+if ( typeof define === "function" && define.amd ) {
+ define( "jquery", [], function() {
+ return jQuery;
+ } );
+}
+
+
+
+
+var
+
+ // Map over jQuery in case of overwrite
+ _jQuery = window.jQuery,
+
+ // Map over the $ in case of overwrite
+ _$ = window.$;
+
+jQuery.noConflict = function( deep ) {
+ if ( window.$ === jQuery ) {
+ window.$ = _$;
+ }
+
+ if ( deep && window.jQuery === jQuery ) {
+ window.jQuery = _jQuery;
+ }
+
+ return jQuery;
+};
+
+// Expose jQuery and $ identifiers, even in AMD
+// (#7102#comment:10, https://github.com/jquery/jquery/pull/557)
+// and CommonJS for browser emulators (#13566)
+if ( !noGlobal ) {
+ window.jQuery = window.$ = jQuery;
+}
+
+
+
+
+return jQuery;
+} );
diff --git a/docs/html/_static/jquery.js b/docs/html/_static/jquery.js
new file mode 100644
index 0000000..644d35e
--- /dev/null
+++ b/docs/html/_static/jquery.js
@@ -0,0 +1,4 @@
+/*! jQuery v3.2.1 | (c) JS Foundation and other contributors | jquery.org/license */
+!function(a,b){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=a.document?b(a,!0):function(a){if(!a.document)throw new Error("jQuery requires a window with a document");return b(a)}:b(a)}("undefined"!=typeof window?window:this,function(a,b){"use strict";var c=[],d=a.document,e=Object.getPrototypeOf,f=c.slice,g=c.concat,h=c.push,i=c.indexOf,j={},k=j.toString,l=j.hasOwnProperty,m=l.toString,n=m.call(Object),o={};function p(a,b){b=b||d;var c=b.createElement("script");c.text=a,b.head.appendChild(c).parentNode.removeChild(c)}var q="3.2.1",r=function(a,b){return new r.fn.init(a,b)},s=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,t=/^-ms-/,u=/-([a-z])/g,v=function(a,b){return b.toUpperCase()};r.fn=r.prototype={jquery:q,constructor:r,length:0,toArray:function(){return f.call(this)},get:function(a){return null==a?f.call(this):a<0?this[a+this.length]:this[a]},pushStack:function(a){var b=r.merge(this.constructor(),a);return b.prevObject=this,b},each:function(a){return r.each(this,a)},map:function(a){return this.pushStack(r.map(this,function(b,c){return a.call(b,c,b)}))},slice:function(){return this.pushStack(f.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},eq:function(a){var b=this.length,c=+a+(a<0?b:0);return this.pushStack(c>=0&&c<b?[this[c]]:[])},end:function(){return this.prevObject||this.constructor()},push:h,sort:c.sort,splice:c.splice},r.extend=r.fn.extend=function(){var a,b,c,d,e,f,g=arguments[0]||{},h=1,i=arguments.length,j=!1;for("boolean"==typeof g&&(j=g,g=arguments[h]||{},h++),"object"==typeof g||r.isFunction(g)||(g={}),h===i&&(g=this,h--);h<i;h++)if(null!=(a=arguments[h]))for(b in a)c=g[b],d=a[b],g!==d&&(j&&d&&(r.isPlainObject(d)||(e=Array.isArray(d)))?(e?(e=!1,f=c&&Array.isArray(c)?c:[]):f=c&&r.isPlainObject(c)?c:{},g[b]=r.extend(j,f,d)):void 0!==d&&(g[b]=d));return g},r.extend({expando:"jQuery"+(q+Math.random()).replace(/\D/g,""),isReady:!0,error:function(a){throw new Error(a)},noop:function(){},isFunction:function(a){return"function"===r.type(a)},isWindow:function(a){return null!=a&&a===a.window},isNumeric:function(a){var b=r.type(a);return("number"===b||"string"===b)&&!isNaN(a-parseFloat(a))},isPlainObject:function(a){var b,c;return!(!a||"[object Object]"!==k.call(a))&&(!(b=e(a))||(c=l.call(b,"constructor")&&b.constructor,"function"==typeof c&&m.call(c)===n))},isEmptyObject:function(a){var b;for(b in a)return!1;return!0},type:function(a){return null==a?a+"":"object"==typeof a||"function"==typeof a?j[k.call(a)]||"object":typeof a},globalEval:function(a){p(a)},camelCase:function(a){return a.replace(t,"ms-").replace(u,v)},each:function(a,b){var c,d=0;if(w(a)){for(c=a.length;d<c;d++)if(b.call(a[d],d,a[d])===!1)break}else for(d in a)if(b.call(a[d],d,a[d])===!1)break;return a},trim:function(a){return null==a?"":(a+"").replace(s,"")},makeArray:function(a,b){var c=b||[];return null!=a&&(w(Object(a))?r.merge(c,"string"==typeof a?[a]:a):h.call(c,a)),c},inArray:function(a,b,c){return null==b?-1:i.call(b,a,c)},merge:function(a,b){for(var c=+b.length,d=0,e=a.length;d<c;d++)a[e++]=b[d];return a.length=e,a},grep:function(a,b,c){for(var d,e=[],f=0,g=a.length,h=!c;f<g;f++)d=!b(a[f],f),d!==h&&e.push(a[f]);return e},map:function(a,b,c){var d,e,f=0,h=[];if(w(a))for(d=a.length;f<d;f++)e=b(a[f],f,c),null!=e&&h.push(e);else for(f in a)e=b(a[f],f,c),null!=e&&h.push(e);return g.apply([],h)},guid:1,proxy:function(a,b){var c,d,e;if("string"==typeof b&&(c=a[b],b=a,a=c),r.isFunction(a))return d=f.call(arguments,2),e=function(){return a.apply(b||this,d.concat(f.call(arguments)))},e.guid=a.guid=a.guid||r.guid++,e},now:Date.now,support:o}),"function"==typeof Symbol&&(r.fn[Symbol.iterator]=c[Symbol.iterator]),r.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "),function(a,b){j["[object "+b+"]"]=b.toLowerCase()});function w(a){var b=!!a&&"length"in a&&a.length,c=r.type(a);return"function"!==c&&!r.isWindow(a)&&("array"===c||0===b||"number"==typeof b&&b>0&&b-1 in a)}var x=function(a){var b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u="sizzle"+1*new Date,v=a.document,w=0,x=0,y=ha(),z=ha(),A=ha(),B=function(a,b){return a===b&&(l=!0),0},C={}.hasOwnProperty,D=[],E=D.pop,F=D.push,G=D.push,H=D.slice,I=function(a,b){for(var c=0,d=a.length;c<d;c++)if(a[c]===b)return c;return-1},J="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",K="[\\x20\\t\\r\\n\\f]",L="(?:\\\\.|[\\w-]|[^\0-\\xa0])+",M="\\["+K+"*("+L+")(?:"+K+"*([*^$|!~]?=)"+K+"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|("+L+"))|)"+K+"*\\]",N=":("+L+")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|"+M+")*)|.*)\\)|)",O=new RegExp(K+"+","g"),P=new RegExp("^"+K+"+|((?:^|[^\\\\])(?:\\\\.)*)"+K+"+$","g"),Q=new RegExp("^"+K+"*,"+K+"*"),R=new RegExp("^"+K+"*([>+~]|"+K+")"+K+"*"),S=new RegExp("="+K+"*([^\\]'\"]*?)"+K+"*\\]","g"),T=new RegExp(N),U=new RegExp("^"+L+"$"),V={ID:new RegExp("^#("+L+")"),CLASS:new RegExp("^\\.("+L+")"),TAG:new RegExp("^("+L+"|[*])"),ATTR:new RegExp("^"+M),PSEUDO:new RegExp("^"+N),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+K+"*(even|odd|(([+-]|)(\\d*)n|)"+K+"*(?:([+-]|)"+K+"*(\\d+)|))"+K+"*\\)|)","i"),bool:new RegExp("^(?:"+J+")$","i"),needsContext:new RegExp("^"+K+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+K+"*((?:-\\d)?\\d*)"+K+"*\\)|)(?=[^-]|$)","i")},W=/^(?:input|select|textarea|button)$/i,X=/^h\d$/i,Y=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,$=/[+~]/,_=new RegExp("\\\\([\\da-f]{1,6}"+K+"?|("+K+")|.)","ig"),aa=function(a,b,c){var d="0x"+b-65536;return d!==d||c?b:d<0?String.fromCharCode(d+65536):String.fromCharCode(d>>10|55296,1023&d|56320)},ba=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ca=function(a,b){return b?"\0"===a?"\ufffd":a.slice(0,-1)+"\\"+a.charCodeAt(a.length-1).toString(16)+" ":"\\"+a},da=function(){m()},ea=ta(function(a){return a.disabled===!0&&("form"in a||"label"in a)},{dir:"parentNode",next:"legend"});try{G.apply(D=H.call(v.childNodes),v.childNodes),D[v.childNodes.length].nodeType}catch(fa){G={apply:D.length?function(a,b){F.apply(a,H.call(b))}:function(a,b){var c=a.length,d=0;while(a[c++]=b[d++]);a.length=c-1}}}function ga(a,b,d,e){var f,h,j,k,l,o,r,s=b&&b.ownerDocument,w=b?b.nodeType:9;if(d=d||[],"string"!=typeof a||!a||1!==w&&9!==w&&11!==w)return d;if(!e&&((b?b.ownerDocument||b:v)!==n&&m(b),b=b||n,p)){if(11!==w&&(l=Z.exec(a)))if(f=l[1]){if(9===w){if(!(j=b.getElementById(f)))return d;if(j.id===f)return d.push(j),d}else if(s&&(j=s.getElementById(f))&&t(b,j)&&j.id===f)return d.push(j),d}else{if(l[2])return G.apply(d,b.getElementsByTagName(a)),d;if((f=l[3])&&c.getElementsByClassName&&b.getElementsByClassName)return G.apply(d,b.getElementsByClassName(f)),d}if(c.qsa&&!A[a+" "]&&(!q||!q.test(a))){if(1!==w)s=b,r=a;else if("object"!==b.nodeName.toLowerCase()){(k=b.getAttribute("id"))?k=k.replace(ba,ca):b.setAttribute("id",k=u),o=g(a),h=o.length;while(h--)o[h]="#"+k+" "+sa(o[h]);r=o.join(","),s=$.test(a)&&qa(b.parentNode)||b}if(r)try{return G.apply(d,s.querySelectorAll(r)),d}catch(x){}finally{k===u&&b.removeAttribute("id")}}}return i(a.replace(P,"$1"),b,d,e)}function ha(){var a=[];function b(c,e){return a.push(c+" ")>d.cacheLength&&delete b[a.shift()],b[c+" "]=e}return b}function ia(a){return a[u]=!0,a}function ja(a){var b=n.createElement("fieldset");try{return!!a(b)}catch(c){return!1}finally{b.parentNode&&b.parentNode.removeChild(b),b=null}}function ka(a,b){var c=a.split("|"),e=c.length;while(e--)d.attrHandle[c[e]]=b}function la(a,b){var c=b&&a,d=c&&1===a.nodeType&&1===b.nodeType&&a.sourceIndex-b.sourceIndex;if(d)return d;if(c)while(c=c.nextSibling)if(c===b)return-1;return a?1:-1}function ma(a){return function(b){var c=b.nodeName.toLowerCase();return"input"===c&&b.type===a}}function na(a){return function(b){var c=b.nodeName.toLowerCase();return("input"===c||"button"===c)&&b.type===a}}function oa(a){return function(b){return"form"in b?b.parentNode&&b.disabled===!1?"label"in b?"label"in b.parentNode?b.parentNode.disabled===a:b.disabled===a:b.isDisabled===a||b.isDisabled!==!a&&ea(b)===a:b.disabled===a:"label"in b&&b.disabled===a}}function pa(a){return ia(function(b){return b=+b,ia(function(c,d){var e,f=a([],c.length,b),g=f.length;while(g--)c[e=f[g]]&&(c[e]=!(d[e]=c[e]))})})}function qa(a){return a&&"undefined"!=typeof a.getElementsByTagName&&a}c=ga.support={},f=ga.isXML=function(a){var b=a&&(a.ownerDocument||a).documentElement;return!!b&&"HTML"!==b.nodeName},m=ga.setDocument=function(a){var b,e,g=a?a.ownerDocument||a:v;return g!==n&&9===g.nodeType&&g.documentElement?(n=g,o=n.documentElement,p=!f(n),v!==n&&(e=n.defaultView)&&e.top!==e&&(e.addEventListener?e.addEventListener("unload",da,!1):e.attachEvent&&e.attachEvent("onunload",da)),c.attributes=ja(function(a){return a.className="i",!a.getAttribute("className")}),c.getElementsByTagName=ja(function(a){return a.appendChild(n.createComment("")),!a.getElementsByTagName("*").length}),c.getElementsByClassName=Y.test(n.getElementsByClassName),c.getById=ja(function(a){return o.appendChild(a).id=u,!n.getElementsByName||!n.getElementsByName(u).length}),c.getById?(d.filter.ID=function(a){var b=a.replace(_,aa);return function(a){return a.getAttribute("id")===b}},d.find.ID=function(a,b){if("undefined"!=typeof b.getElementById&&p){var c=b.getElementById(a);return c?[c]:[]}}):(d.filter.ID=function(a){var b=a.replace(_,aa);return function(a){var c="undefined"!=typeof a.getAttributeNode&&a.getAttributeNode("id");return c&&c.value===b}},d.find.ID=function(a,b){if("undefined"!=typeof b.getElementById&&p){var c,d,e,f=b.getElementById(a);if(f){if(c=f.getAttributeNode("id"),c&&c.value===a)return[f];e=b.getElementsByName(a),d=0;while(f=e[d++])if(c=f.getAttributeNode("id"),c&&c.value===a)return[f]}return[]}}),d.find.TAG=c.getElementsByTagName?function(a,b){return"undefined"!=typeof b.getElementsByTagName?b.getElementsByTagName(a):c.qsa?b.querySelectorAll(a):void 0}:function(a,b){var c,d=[],e=0,f=b.getElementsByTagName(a);if("*"===a){while(c=f[e++])1===c.nodeType&&d.push(c);return d}return f},d.find.CLASS=c.getElementsByClassName&&function(a,b){if("undefined"!=typeof b.getElementsByClassName&&p)return b.getElementsByClassName(a)},r=[],q=[],(c.qsa=Y.test(n.querySelectorAll))&&(ja(function(a){o.appendChild(a).innerHTML="<a id='"+u+"'></a><select id='"+u+"-\r\\' msallowcapture=''><option selected=''></option></select>",a.querySelectorAll("[msallowcapture^='']").length&&q.push("[*^$]="+K+"*(?:''|\"\")"),a.querySelectorAll("[selected]").length||q.push("\\["+K+"*(?:value|"+J+")"),a.querySelectorAll("[id~="+u+"-]").length||q.push("~="),a.querySelectorAll(":checked").length||q.push(":checked"),a.querySelectorAll("a#"+u+"+*").length||q.push(".#.+[+~]")}),ja(function(a){a.innerHTML="<a href='' disabled='disabled'></a><select disabled='disabled'><option/></select>";var b=n.createElement("input");b.setAttribute("type","hidden"),a.appendChild(b).setAttribute("name","D"),a.querySelectorAll("[name=d]").length&&q.push("name"+K+"*[*^$|!~]?="),2!==a.querySelectorAll(":enabled").length&&q.push(":enabled",":disabled"),o.appendChild(a).disabled=!0,2!==a.querySelectorAll(":disabled").length&&q.push(":enabled",":disabled"),a.querySelectorAll("*,:x"),q.push(",.*:")})),(c.matchesSelector=Y.test(s=o.matches||o.webkitMatchesSelector||o.mozMatchesSelector||o.oMatchesSelector||o.msMatchesSelector))&&ja(function(a){c.disconnectedMatch=s.call(a,"*"),s.call(a,"[s!='']:x"),r.push("!=",N)}),q=q.length&&new RegExp(q.join("|")),r=r.length&&new RegExp(r.join("|")),b=Y.test(o.compareDocumentPosition),t=b||Y.test(o.contains)?function(a,b){var c=9===a.nodeType?a.documentElement:a,d=b&&b.parentNode;return a===d||!(!d||1!==d.nodeType||!(c.contains?c.contains(d):a.compareDocumentPosition&&16&a.compareDocumentPosition(d)))}:function(a,b){if(b)while(b=b.parentNode)if(b===a)return!0;return!1},B=b?function(a,b){if(a===b)return l=!0,0;var d=!a.compareDocumentPosition-!b.compareDocumentPosition;return d?d:(d=(a.ownerDocument||a)===(b.ownerDocument||b)?a.compareDocumentPosition(b):1,1&d||!c.sortDetached&&b.compareDocumentPosition(a)===d?a===n||a.ownerDocument===v&&t(v,a)?-1:b===n||b.ownerDocument===v&&t(v,b)?1:k?I(k,a)-I(k,b):0:4&d?-1:1)}:function(a,b){if(a===b)return l=!0,0;var c,d=0,e=a.parentNode,f=b.parentNode,g=[a],h=[b];if(!e||!f)return a===n?-1:b===n?1:e?-1:f?1:k?I(k,a)-I(k,b):0;if(e===f)return la(a,b);c=a;while(c=c.parentNode)g.unshift(c);c=b;while(c=c.parentNode)h.unshift(c);while(g[d]===h[d])d++;return d?la(g[d],h[d]):g[d]===v?-1:h[d]===v?1:0},n):n},ga.matches=function(a,b){return ga(a,null,null,b)},ga.matchesSelector=function(a,b){if((a.ownerDocument||a)!==n&&m(a),b=b.replace(S,"='$1']"),c.matchesSelector&&p&&!A[b+" "]&&(!r||!r.test(b))&&(!q||!q.test(b)))try{var d=s.call(a,b);if(d||c.disconnectedMatch||a.document&&11!==a.document.nodeType)return d}catch(e){}return ga(b,n,null,[a]).length>0},ga.contains=function(a,b){return(a.ownerDocument||a)!==n&&m(a),t(a,b)},ga.attr=function(a,b){(a.ownerDocument||a)!==n&&m(a);var e=d.attrHandle[b.toLowerCase()],f=e&&C.call(d.attrHandle,b.toLowerCase())?e(a,b,!p):void 0;return void 0!==f?f:c.attributes||!p?a.getAttribute(b):(f=a.getAttributeNode(b))&&f.specified?f.value:null},ga.escape=function(a){return(a+"").replace(ba,ca)},ga.error=function(a){throw new Error("Syntax error, unrecognized expression: "+a)},ga.uniqueSort=function(a){var b,d=[],e=0,f=0;if(l=!c.detectDuplicates,k=!c.sortStable&&a.slice(0),a.sort(B),l){while(b=a[f++])b===a[f]&&(e=d.push(f));while(e--)a.splice(d[e],1)}return k=null,a},e=ga.getText=function(a){var b,c="",d=0,f=a.nodeType;if(f){if(1===f||9===f||11===f){if("string"==typeof a.textContent)return a.textContent;for(a=a.firstChild;a;a=a.nextSibling)c+=e(a)}else if(3===f||4===f)return a.nodeValue}else while(b=a[d++])c+=e(b);return c},d=ga.selectors={cacheLength:50,createPseudo:ia,match:V,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(a){return a[1]=a[1].replace(_,aa),a[3]=(a[3]||a[4]||a[5]||"").replace(_,aa),"~="===a[2]&&(a[3]=" "+a[3]+" "),a.slice(0,4)},CHILD:function(a){return a[1]=a[1].toLowerCase(),"nth"===a[1].slice(0,3)?(a[3]||ga.error(a[0]),a[4]=+(a[4]?a[5]+(a[6]||1):2*("even"===a[3]||"odd"===a[3])),a[5]=+(a[7]+a[8]||"odd"===a[3])):a[3]&&ga.error(a[0]),a},PSEUDO:function(a){var b,c=!a[6]&&a[2];return V.CHILD.test(a[0])?null:(a[3]?a[2]=a[4]||a[5]||"":c&&T.test(c)&&(b=g(c,!0))&&(b=c.indexOf(")",c.length-b)-c.length)&&(a[0]=a[0].slice(0,b),a[2]=c.slice(0,b)),a.slice(0,3))}},filter:{TAG:function(a){var b=a.replace(_,aa).toLowerCase();return"*"===a?function(){return!0}:function(a){return a.nodeName&&a.nodeName.toLowerCase()===b}},CLASS:function(a){var b=y[a+" "];return b||(b=new RegExp("(^|"+K+")"+a+"("+K+"|$)"))&&y(a,function(a){return b.test("string"==typeof a.className&&a.className||"undefined"!=typeof a.getAttribute&&a.getAttribute("class")||"")})},ATTR:function(a,b,c){return function(d){var e=ga.attr(d,a);return null==e?"!="===b:!b||(e+="","="===b?e===c:"!="===b?e!==c:"^="===b?c&&0===e.indexOf(c):"*="===b?c&&e.indexOf(c)>-1:"$="===b?c&&e.slice(-c.length)===c:"~="===b?(" "+e.replace(O," ")+" ").indexOf(c)>-1:"|="===b&&(e===c||e.slice(0,c.length+1)===c+"-"))}},CHILD:function(a,b,c,d,e){var f="nth"!==a.slice(0,3),g="last"!==a.slice(-4),h="of-type"===b;return 1===d&&0===e?function(a){return!!a.parentNode}:function(b,c,i){var j,k,l,m,n,o,p=f!==g?"nextSibling":"previousSibling",q=b.parentNode,r=h&&b.nodeName.toLowerCase(),s=!i&&!h,t=!1;if(q){if(f){while(p){m=b;while(m=m[p])if(h?m.nodeName.toLowerCase()===r:1===m.nodeType)return!1;o=p="only"===a&&!o&&"nextSibling"}return!0}if(o=[g?q.firstChild:q.lastChild],g&&s){m=q,l=m[u]||(m[u]={}),k=l[m.uniqueID]||(l[m.uniqueID]={}),j=k[a]||[],n=j[0]===w&&j[1],t=n&&j[2],m=n&&q.childNodes[n];while(m=++n&&m&&m[p]||(t=n=0)||o.pop())if(1===m.nodeType&&++t&&m===b){k[a]=[w,n,t];break}}else if(s&&(m=b,l=m[u]||(m[u]={}),k=l[m.uniqueID]||(l[m.uniqueID]={}),j=k[a]||[],n=j[0]===w&&j[1],t=n),t===!1)while(m=++n&&m&&m[p]||(t=n=0)||o.pop())if((h?m.nodeName.toLowerCase()===r:1===m.nodeType)&&++t&&(s&&(l=m[u]||(m[u]={}),k=l[m.uniqueID]||(l[m.uniqueID]={}),k[a]=[w,t]),m===b))break;return t-=e,t===d||t%d===0&&t/d>=0}}},PSEUDO:function(a,b){var c,e=d.pseudos[a]||d.setFilters[a.toLowerCase()]||ga.error("unsupported pseudo: "+a);return e[u]?e(b):e.length>1?(c=[a,a,"",b],d.setFilters.hasOwnProperty(a.toLowerCase())?ia(function(a,c){var d,f=e(a,b),g=f.length;while(g--)d=I(a,f[g]),a[d]=!(c[d]=f[g])}):function(a){return e(a,0,c)}):e}},pseudos:{not:ia(function(a){var b=[],c=[],d=h(a.replace(P,"$1"));return d[u]?ia(function(a,b,c,e){var f,g=d(a,null,e,[]),h=a.length;while(h--)(f=g[h])&&(a[h]=!(b[h]=f))}):function(a,e,f){return b[0]=a,d(b,null,f,c),b[0]=null,!c.pop()}}),has:ia(function(a){return function(b){return ga(a,b).length>0}}),contains:ia(function(a){return a=a.replace(_,aa),function(b){return(b.textContent||b.innerText||e(b)).indexOf(a)>-1}}),lang:ia(function(a){return U.test(a||"")||ga.error("unsupported lang: "+a),a=a.replace(_,aa).toLowerCase(),function(b){var c;do if(c=p?b.lang:b.getAttribute("xml:lang")||b.getAttribute("lang"))return c=c.toLowerCase(),c===a||0===c.indexOf(a+"-");while((b=b.parentNode)&&1===b.nodeType);return!1}}),target:function(b){var c=a.location&&a.location.hash;return c&&c.slice(1)===b.id},root:function(a){return a===o},focus:function(a){return a===n.activeElement&&(!n.hasFocus||n.hasFocus())&&!!(a.type||a.href||~a.tabIndex)},enabled:oa(!1),disabled:oa(!0),checked:function(a){var b=a.nodeName.toLowerCase();return"input"===b&&!!a.checked||"option"===b&&!!a.selected},selected:function(a){return a.parentNode&&a.parentNode.selectedIndex,a.selected===!0},empty:function(a){for(a=a.firstChild;a;a=a.nextSibling)if(a.nodeType<6)return!1;return!0},parent:function(a){return!d.pseudos.empty(a)},header:function(a){return X.test(a.nodeName)},input:function(a){return W.test(a.nodeName)},button:function(a){var b=a.nodeName.toLowerCase();return"input"===b&&"button"===a.type||"button"===b},text:function(a){var b;return"input"===a.nodeName.toLowerCase()&&"text"===a.type&&(null==(b=a.getAttribute("type"))||"text"===b.toLowerCase())},first:pa(function(){return[0]}),last:pa(function(a,b){return[b-1]}),eq:pa(function(a,b,c){return[c<0?c+b:c]}),even:pa(function(a,b){for(var c=0;c<b;c+=2)a.push(c);return a}),odd:pa(function(a,b){for(var c=1;c<b;c+=2)a.push(c);return a}),lt:pa(function(a,b,c){for(var d=c<0?c+b:c;--d>=0;)a.push(d);return a}),gt:pa(function(a,b,c){for(var d=c<0?c+b:c;++d<b;)a.push(d);return a})}},d.pseudos.nth=d.pseudos.eq;for(b in{radio:!0,checkbox:!0,file:!0,password:!0,image:!0})d.pseudos[b]=ma(b);for(b in{submit:!0,reset:!0})d.pseudos[b]=na(b);function ra(){}ra.prototype=d.filters=d.pseudos,d.setFilters=new ra,g=ga.tokenize=function(a,b){var c,e,f,g,h,i,j,k=z[a+" "];if(k)return b?0:k.slice(0);h=a,i=[],j=d.preFilter;while(h){c&&!(e=Q.exec(h))||(e&&(h=h.slice(e[0].length)||h),i.push(f=[])),c=!1,(e=R.exec(h))&&(c=e.shift(),f.push({value:c,type:e[0].replace(P," ")}),h=h.slice(c.length));for(g in d.filter)!(e=V[g].exec(h))||j[g]&&!(e=j[g](e))||(c=e.shift(),f.push({value:c,type:g,matches:e}),h=h.slice(c.length));if(!c)break}return b?h.length:h?ga.error(a):z(a,i).slice(0)};function sa(a){for(var b=0,c=a.length,d="";b<c;b++)d+=a[b].value;return d}function ta(a,b,c){var d=b.dir,e=b.next,f=e||d,g=c&&"parentNode"===f,h=x++;return b.first?function(b,c,e){while(b=b[d])if(1===b.nodeType||g)return a(b,c,e);return!1}:function(b,c,i){var j,k,l,m=[w,h];if(i){while(b=b[d])if((1===b.nodeType||g)&&a(b,c,i))return!0}else while(b=b[d])if(1===b.nodeType||g)if(l=b[u]||(b[u]={}),k=l[b.uniqueID]||(l[b.uniqueID]={}),e&&e===b.nodeName.toLowerCase())b=b[d]||b;else{if((j=k[f])&&j[0]===w&&j[1]===h)return m[2]=j[2];if(k[f]=m,m[2]=a(b,c,i))return!0}return!1}}function ua(a){return a.length>1?function(b,c,d){var e=a.length;while(e--)if(!a[e](b,c,d))return!1;return!0}:a[0]}function va(a,b,c){for(var d=0,e=b.length;d<e;d++)ga(a,b[d],c);return c}function wa(a,b,c,d,e){for(var f,g=[],h=0,i=a.length,j=null!=b;h<i;h++)(f=a[h])&&(c&&!c(f,d,e)||(g.push(f),j&&b.push(h)));return g}function xa(a,b,c,d,e,f){return d&&!d[u]&&(d=xa(d)),e&&!e[u]&&(e=xa(e,f)),ia(function(f,g,h,i){var j,k,l,m=[],n=[],o=g.length,p=f||va(b||"*",h.nodeType?[h]:h,[]),q=!a||!f&&b?p:wa(p,m,a,h,i),r=c?e||(f?a:o||d)?[]:g:q;if(c&&c(q,r,h,i),d){j=wa(r,n),d(j,[],h,i),k=j.length;while(k--)(l=j[k])&&(r[n[k]]=!(q[n[k]]=l))}if(f){if(e||a){if(e){j=[],k=r.length;while(k--)(l=r[k])&&j.push(q[k]=l);e(null,r=[],j,i)}k=r.length;while(k--)(l=r[k])&&(j=e?I(f,l):m[k])>-1&&(f[j]=!(g[j]=l))}}else r=wa(r===g?r.splice(o,r.length):r),e?e(null,g,r,i):G.apply(g,r)})}function ya(a){for(var b,c,e,f=a.length,g=d.relative[a[0].type],h=g||d.relative[" "],i=g?1:0,k=ta(function(a){return a===b},h,!0),l=ta(function(a){return I(b,a)>-1},h,!0),m=[function(a,c,d){var e=!g&&(d||c!==j)||((b=c).nodeType?k(a,c,d):l(a,c,d));return b=null,e}];i<f;i++)if(c=d.relative[a[i].type])m=[ta(ua(m),c)];else{if(c=d.filter[a[i].type].apply(null,a[i].matches),c[u]){for(e=++i;e<f;e++)if(d.relative[a[e].type])break;return xa(i>1&&ua(m),i>1&&sa(a.slice(0,i-1).concat({value:" "===a[i-2].type?"*":""})).replace(P,"$1"),c,i<e&&ya(a.slice(i,e)),e<f&&ya(a=a.slice(e)),e<f&&sa(a))}m.push(c)}return ua(m)}function za(a,b){var c=b.length>0,e=a.length>0,f=function(f,g,h,i,k){var l,o,q,r=0,s="0",t=f&&[],u=[],v=j,x=f||e&&d.find.TAG("*",k),y=w+=null==v?1:Math.random()||.1,z=x.length;for(k&&(j=g===n||g||k);s!==z&&null!=(l=x[s]);s++){if(e&&l){o=0,g||l.ownerDocument===n||(m(l),h=!p);while(q=a[o++])if(q(l,g||n,h)){i.push(l);break}k&&(w=y)}c&&((l=!q&&l)&&r--,f&&t.push(l))}if(r+=s,c&&s!==r){o=0;while(q=b[o++])q(t,u,g,h);if(f){if(r>0)while(s--)t[s]||u[s]||(u[s]=E.call(i));u=wa(u)}G.apply(i,u),k&&!f&&u.length>0&&r+b.length>1&&ga.uniqueSort(i)}return k&&(w=y,j=v),t};return c?ia(f):f}return h=ga.compile=function(a,b){var c,d=[],e=[],f=A[a+" "];if(!f){b||(b=g(a)),c=b.length;while(c--)f=ya(b[c]),f[u]?d.push(f):e.push(f);f=A(a,za(e,d)),f.selector=a}return f},i=ga.select=function(a,b,c,e){var f,i,j,k,l,m="function"==typeof a&&a,n=!e&&g(a=m.selector||a);if(c=c||[],1===n.length){if(i=n[0]=n[0].slice(0),i.length>2&&"ID"===(j=i[0]).type&&9===b.nodeType&&p&&d.relative[i[1].type]){if(b=(d.find.ID(j.matches[0].replace(_,aa),b)||[])[0],!b)return c;m&&(b=b.parentNode),a=a.slice(i.shift().value.length)}f=V.needsContext.test(a)?0:i.length;while(f--){if(j=i[f],d.relative[k=j.type])break;if((l=d.find[k])&&(e=l(j.matches[0].replace(_,aa),$.test(i[0].type)&&qa(b.parentNode)||b))){if(i.splice(f,1),a=e.length&&sa(i),!a)return G.apply(c,e),c;break}}}return(m||h(a,n))(e,b,!p,c,!b||$.test(a)&&qa(b.parentNode)||b),c},c.sortStable=u.split("").sort(B).join("")===u,c.detectDuplicates=!!l,m(),c.sortDetached=ja(function(a){return 1&a.compareDocumentPosition(n.createElement("fieldset"))}),ja(function(a){return a.innerHTML="<a href='#'></a>","#"===a.firstChild.getAttribute("href")})||ka("type|href|height|width",function(a,b,c){if(!c)return a.getAttribute(b,"type"===b.toLowerCase()?1:2)}),c.attributes&&ja(function(a){return a.innerHTML="<input/>",a.firstChild.setAttribute("value",""),""===a.firstChild.getAttribute("value")})||ka("value",function(a,b,c){if(!c&&"input"===a.nodeName.toLowerCase())return a.defaultValue}),ja(function(a){return null==a.getAttribute("disabled")})||ka(J,function(a,b,c){var d;if(!c)return a[b]===!0?b.toLowerCase():(d=a.getAttributeNode(b))&&d.specified?d.value:null}),ga}(a);r.find=x,r.expr=x.selectors,r.expr[":"]=r.expr.pseudos,r.uniqueSort=r.unique=x.uniqueSort,r.text=x.getText,r.isXMLDoc=x.isXML,r.contains=x.contains,r.escapeSelector=x.escape;var y=function(a,b,c){var d=[],e=void 0!==c;while((a=a[b])&&9!==a.nodeType)if(1===a.nodeType){if(e&&r(a).is(c))break;d.push(a)}return d},z=function(a,b){for(var c=[];a;a=a.nextSibling)1===a.nodeType&&a!==b&&c.push(a);return c},A=r.expr.match.needsContext;function B(a,b){return a.nodeName&&a.nodeName.toLowerCase()===b.toLowerCase()}var C=/^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i,D=/^.[^:#\[\.,]*$/;function E(a,b,c){return r.isFunction(b)?r.grep(a,function(a,d){return!!b.call(a,d,a)!==c}):b.nodeType?r.grep(a,function(a){return a===b!==c}):"string"!=typeof b?r.grep(a,function(a){return i.call(b,a)>-1!==c}):D.test(b)?r.filter(b,a,c):(b=r.filter(b,a),r.grep(a,function(a){return i.call(b,a)>-1!==c&&1===a.nodeType}))}r.filter=function(a,b,c){var d=b[0];return c&&(a=":not("+a+")"),1===b.length&&1===d.nodeType?r.find.matchesSelector(d,a)?[d]:[]:r.find.matches(a,r.grep(b,function(a){return 1===a.nodeType}))},r.fn.extend({find:function(a){var b,c,d=this.length,e=this;if("string"!=typeof a)return this.pushStack(r(a).filter(function(){for(b=0;b<d;b++)if(r.contains(e[b],this))return!0}));for(c=this.pushStack([]),b=0;b<d;b++)r.find(a,e[b],c);return d>1?r.uniqueSort(c):c},filter:function(a){return this.pushStack(E(this,a||[],!1))},not:function(a){return this.pushStack(E(this,a||[],!0))},is:function(a){return!!E(this,"string"==typeof a&&A.test(a)?r(a):a||[],!1).length}});var F,G=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,H=r.fn.init=function(a,b,c){var e,f;if(!a)return this;if(c=c||F,"string"==typeof a){if(e="<"===a[0]&&">"===a[a.length-1]&&a.length>=3?[null,a,null]:G.exec(a),!e||!e[1]&&b)return!b||b.jquery?(b||c).find(a):this.constructor(b).find(a);if(e[1]){if(b=b instanceof r?b[0]:b,r.merge(this,r.parseHTML(e[1],b&&b.nodeType?b.ownerDocument||b:d,!0)),C.test(e[1])&&r.isPlainObject(b))for(e in b)r.isFunction(this[e])?this[e](b[e]):this.attr(e,b[e]);return this}return f=d.getElementById(e[2]),f&&(this[0]=f,this.length=1),this}return a.nodeType?(this[0]=a,this.length=1,this):r.isFunction(a)?void 0!==c.ready?c.ready(a):a(r):r.makeArray(a,this)};H.prototype=r.fn,F=r(d);var I=/^(?:parents|prev(?:Until|All))/,J={children:!0,contents:!0,next:!0,prev:!0};r.fn.extend({has:function(a){var b=r(a,this),c=b.length;return this.filter(function(){for(var a=0;a<c;a++)if(r.contains(this,b[a]))return!0})},closest:function(a,b){var c,d=0,e=this.length,f=[],g="string"!=typeof a&&r(a);if(!A.test(a))for(;d<e;d++)for(c=this[d];c&&c!==b;c=c.parentNode)if(c.nodeType<11&&(g?g.index(c)>-1:1===c.nodeType&&r.find.matchesSelector(c,a))){f.push(c);break}return this.pushStack(f.length>1?r.uniqueSort(f):f)},index:function(a){return a?"string"==typeof a?i.call(r(a),this[0]):i.call(this,a.jquery?a[0]:a):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(a,b){return this.pushStack(r.uniqueSort(r.merge(this.get(),r(a,b))))},addBack:function(a){return this.add(null==a?this.prevObject:this.prevObject.filter(a))}});function K(a,b){while((a=a[b])&&1!==a.nodeType);return a}r.each({parent:function(a){var b=a.parentNode;return b&&11!==b.nodeType?b:null},parents:function(a){return y(a,"parentNode")},parentsUntil:function(a,b,c){return y(a,"parentNode",c)},next:function(a){return K(a,"nextSibling")},prev:function(a){return K(a,"previousSibling")},nextAll:function(a){return y(a,"nextSibling")},prevAll:function(a){return y(a,"previousSibling")},nextUntil:function(a,b,c){return y(a,"nextSibling",c)},prevUntil:function(a,b,c){return y(a,"previousSibling",c)},siblings:function(a){return z((a.parentNode||{}).firstChild,a)},children:function(a){return z(a.firstChild)},contents:function(a){return B(a,"iframe")?a.contentDocument:(B(a,"template")&&(a=a.content||a),r.merge([],a.childNodes))}},function(a,b){r.fn[a]=function(c,d){var e=r.map(this,b,c);return"Until"!==a.slice(-5)&&(d=c),d&&"string"==typeof d&&(e=r.filter(d,e)),this.length>1&&(J[a]||r.uniqueSort(e),I.test(a)&&e.reverse()),this.pushStack(e)}});var L=/[^\x20\t\r\n\f]+/g;function M(a){var b={};return r.each(a.match(L)||[],function(a,c){b[c]=!0}),b}r.Callbacks=function(a){a="string"==typeof a?M(a):r.extend({},a);var b,c,d,e,f=[],g=[],h=-1,i=function(){for(e=e||a.once,d=b=!0;g.length;h=-1){c=g.shift();while(++h<f.length)f[h].apply(c[0],c[1])===!1&&a.stopOnFalse&&(h=f.length,c=!1)}a.memory||(c=!1),b=!1,e&&(f=c?[]:"")},j={add:function(){return f&&(c&&!b&&(h=f.length-1,g.push(c)),function d(b){r.each(b,function(b,c){r.isFunction(c)?a.unique&&j.has(c)||f.push(c):c&&c.length&&"string"!==r.type(c)&&d(c)})}(arguments),c&&!b&&i()),this},remove:function(){return r.each(arguments,function(a,b){var c;while((c=r.inArray(b,f,c))>-1)f.splice(c,1),c<=h&&h--}),this},has:function(a){return a?r.inArray(a,f)>-1:f.length>0},empty:function(){return f&&(f=[]),this},disable:function(){return e=g=[],f=c="",this},disabled:function(){return!f},lock:function(){return e=g=[],c||b||(f=c=""),this},locked:function(){return!!e},fireWith:function(a,c){return e||(c=c||[],c=[a,c.slice?c.slice():c],g.push(c),b||i()),this},fire:function(){return j.fireWith(this,arguments),this},fired:function(){return!!d}};return j};function N(a){return a}function O(a){throw a}function P(a,b,c,d){var e;try{a&&r.isFunction(e=a.promise)?e.call(a).done(b).fail(c):a&&r.isFunction(e=a.then)?e.call(a,b,c):b.apply(void 0,[a].slice(d))}catch(a){c.apply(void 0,[a])}}r.extend({Deferred:function(b){var c=[["notify","progress",r.Callbacks("memory"),r.Callbacks("memory"),2],["resolve","done",r.Callbacks("once memory"),r.Callbacks("once memory"),0,"resolved"],["reject","fail",r.Callbacks("once memory"),r.Callbacks("once memory"),1,"rejected"]],d="pending",e={state:function(){return d},always:function(){return f.done(arguments).fail(arguments),this},"catch":function(a){return e.then(null,a)},pipe:function(){var a=arguments;return r.Deferred(function(b){r.each(c,function(c,d){var e=r.isFunction(a[d[4]])&&a[d[4]];f[d[1]](function(){var a=e&&e.apply(this,arguments);a&&r.isFunction(a.promise)?a.promise().progress(b.notify).done(b.resolve).fail(b.reject):b[d[0]+"With"](this,e?[a]:arguments)})}),a=null}).promise()},then:function(b,d,e){var f=0;function g(b,c,d,e){return function(){var h=this,i=arguments,j=function(){var a,j;if(!(b<f)){if(a=d.apply(h,i),a===c.promise())throw new TypeError("Thenable self-resolution");j=a&&("object"==typeof a||"function"==typeof a)&&a.then,r.isFunction(j)?e?j.call(a,g(f,c,N,e),g(f,c,O,e)):(f++,j.call(a,g(f,c,N,e),g(f,c,O,e),g(f,c,N,c.notifyWith))):(d!==N&&(h=void 0,i=[a]),(e||c.resolveWith)(h,i))}},k=e?j:function(){try{j()}catch(a){r.Deferred.exceptionHook&&r.Deferred.exceptionHook(a,k.stackTrace),b+1>=f&&(d!==O&&(h=void 0,i=[a]),c.rejectWith(h,i))}};b?k():(r.Deferred.getStackHook&&(k.stackTrace=r.Deferred.getStackHook()),a.setTimeout(k))}}return r.Deferred(function(a){c[0][3].add(g(0,a,r.isFunction(e)?e:N,a.notifyWith)),c[1][3].add(g(0,a,r.isFunction(b)?b:N)),c[2][3].add(g(0,a,r.isFunction(d)?d:O))}).promise()},promise:function(a){return null!=a?r.extend(a,e):e}},f={};return r.each(c,function(a,b){var g=b[2],h=b[5];e[b[1]]=g.add,h&&g.add(function(){d=h},c[3-a][2].disable,c[0][2].lock),g.add(b[3].fire),f[b[0]]=function(){return f[b[0]+"With"](this===f?void 0:this,arguments),this},f[b[0]+"With"]=g.fireWith}),e.promise(f),b&&b.call(f,f),f},when:function(a){var b=arguments.length,c=b,d=Array(c),e=f.call(arguments),g=r.Deferred(),h=function(a){return function(c){d[a]=this,e[a]=arguments.length>1?f.call(arguments):c,--b||g.resolveWith(d,e)}};if(b<=1&&(P(a,g.done(h(c)).resolve,g.reject,!b),"pending"===g.state()||r.isFunction(e[c]&&e[c].then)))return g.then();while(c--)P(e[c],h(c),g.reject);return g.promise()}});var Q=/^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;r.Deferred.exceptionHook=function(b,c){a.console&&a.console.warn&&b&&Q.test(b.name)&&a.console.warn("jQuery.Deferred exception: "+b.message,b.stack,c)},r.readyException=function(b){a.setTimeout(function(){throw b})};var R=r.Deferred();r.fn.ready=function(a){return R.then(a)["catch"](function(a){r.readyException(a)}),this},r.extend({isReady:!1,readyWait:1,ready:function(a){(a===!0?--r.readyWait:r.isReady)||(r.isReady=!0,a!==!0&&--r.readyWait>0||R.resolveWith(d,[r]))}}),r.ready.then=R.then;function S(){d.removeEventListener("DOMContentLoaded",S),
+a.removeEventListener("load",S),r.ready()}"complete"===d.readyState||"loading"!==d.readyState&&!d.documentElement.doScroll?a.setTimeout(r.ready):(d.addEventListener("DOMContentLoaded",S),a.addEventListener("load",S));var T=function(a,b,c,d,e,f,g){var h=0,i=a.length,j=null==c;if("object"===r.type(c)){e=!0;for(h in c)T(a,b,h,c[h],!0,f,g)}else if(void 0!==d&&(e=!0,r.isFunction(d)||(g=!0),j&&(g?(b.call(a,d),b=null):(j=b,b=function(a,b,c){return j.call(r(a),c)})),b))for(;h<i;h++)b(a[h],c,g?d:d.call(a[h],h,b(a[h],c)));return e?a:j?b.call(a):i?b(a[0],c):f},U=function(a){return 1===a.nodeType||9===a.nodeType||!+a.nodeType};function V(){this.expando=r.expando+V.uid++}V.uid=1,V.prototype={cache:function(a){var b=a[this.expando];return b||(b={},U(a)&&(a.nodeType?a[this.expando]=b:Object.defineProperty(a,this.expando,{value:b,configurable:!0}))),b},set:function(a,b,c){var d,e=this.cache(a);if("string"==typeof b)e[r.camelCase(b)]=c;else for(d in b)e[r.camelCase(d)]=b[d];return e},get:function(a,b){return void 0===b?this.cache(a):a[this.expando]&&a[this.expando][r.camelCase(b)]},access:function(a,b,c){return void 0===b||b&&"string"==typeof b&&void 0===c?this.get(a,b):(this.set(a,b,c),void 0!==c?c:b)},remove:function(a,b){var c,d=a[this.expando];if(void 0!==d){if(void 0!==b){Array.isArray(b)?b=b.map(r.camelCase):(b=r.camelCase(b),b=b in d?[b]:b.match(L)||[]),c=b.length;while(c--)delete d[b[c]]}(void 0===b||r.isEmptyObject(d))&&(a.nodeType?a[this.expando]=void 0:delete a[this.expando])}},hasData:function(a){var b=a[this.expando];return void 0!==b&&!r.isEmptyObject(b)}};var W=new V,X=new V,Y=/^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,Z=/[A-Z]/g;function $(a){return"true"===a||"false"!==a&&("null"===a?null:a===+a+""?+a:Y.test(a)?JSON.parse(a):a)}function _(a,b,c){var d;if(void 0===c&&1===a.nodeType)if(d="data-"+b.replace(Z,"-$&").toLowerCase(),c=a.getAttribute(d),"string"==typeof c){try{c=$(c)}catch(e){}X.set(a,b,c)}else c=void 0;return c}r.extend({hasData:function(a){return X.hasData(a)||W.hasData(a)},data:function(a,b,c){return X.access(a,b,c)},removeData:function(a,b){X.remove(a,b)},_data:function(a,b,c){return W.access(a,b,c)},_removeData:function(a,b){W.remove(a,b)}}),r.fn.extend({data:function(a,b){var c,d,e,f=this[0],g=f&&f.attributes;if(void 0===a){if(this.length&&(e=X.get(f),1===f.nodeType&&!W.get(f,"hasDataAttrs"))){c=g.length;while(c--)g[c]&&(d=g[c].name,0===d.indexOf("data-")&&(d=r.camelCase(d.slice(5)),_(f,d,e[d])));W.set(f,"hasDataAttrs",!0)}return e}return"object"==typeof a?this.each(function(){X.set(this,a)}):T(this,function(b){var c;if(f&&void 0===b){if(c=X.get(f,a),void 0!==c)return c;if(c=_(f,a),void 0!==c)return c}else this.each(function(){X.set(this,a,b)})},null,b,arguments.length>1,null,!0)},removeData:function(a){return this.each(function(){X.remove(this,a)})}}),r.extend({queue:function(a,b,c){var d;if(a)return b=(b||"fx")+"queue",d=W.get(a,b),c&&(!d||Array.isArray(c)?d=W.access(a,b,r.makeArray(c)):d.push(c)),d||[]},dequeue:function(a,b){b=b||"fx";var c=r.queue(a,b),d=c.length,e=c.shift(),f=r._queueHooks(a,b),g=function(){r.dequeue(a,b)};"inprogress"===e&&(e=c.shift(),d--),e&&("fx"===b&&c.unshift("inprogress"),delete f.stop,e.call(a,g,f)),!d&&f&&f.empty.fire()},_queueHooks:function(a,b){var c=b+"queueHooks";return W.get(a,c)||W.access(a,c,{empty:r.Callbacks("once memory").add(function(){W.remove(a,[b+"queue",c])})})}}),r.fn.extend({queue:function(a,b){var c=2;return"string"!=typeof a&&(b=a,a="fx",c--),arguments.length<c?r.queue(this[0],a):void 0===b?this:this.each(function(){var c=r.queue(this,a,b);r._queueHooks(this,a),"fx"===a&&"inprogress"!==c[0]&&r.dequeue(this,a)})},dequeue:function(a){return this.each(function(){r.dequeue(this,a)})},clearQueue:function(a){return this.queue(a||"fx",[])},promise:function(a,b){var c,d=1,e=r.Deferred(),f=this,g=this.length,h=function(){--d||e.resolveWith(f,[f])};"string"!=typeof a&&(b=a,a=void 0),a=a||"fx";while(g--)c=W.get(f[g],a+"queueHooks"),c&&c.empty&&(d++,c.empty.add(h));return h(),e.promise(b)}});var aa=/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,ba=new RegExp("^(?:([+-])=|)("+aa+")([a-z%]*)$","i"),ca=["Top","Right","Bottom","Left"],da=function(a,b){return a=b||a,"none"===a.style.display||""===a.style.display&&r.contains(a.ownerDocument,a)&&"none"===r.css(a,"display")},ea=function(a,b,c,d){var e,f,g={};for(f in b)g[f]=a.style[f],a.style[f]=b[f];e=c.apply(a,d||[]);for(f in b)a.style[f]=g[f];return e};function fa(a,b,c,d){var e,f=1,g=20,h=d?function(){return d.cur()}:function(){return r.css(a,b,"")},i=h(),j=c&&c[3]||(r.cssNumber[b]?"":"px"),k=(r.cssNumber[b]||"px"!==j&&+i)&&ba.exec(r.css(a,b));if(k&&k[3]!==j){j=j||k[3],c=c||[],k=+i||1;do f=f||".5",k/=f,r.style(a,b,k+j);while(f!==(f=h()/i)&&1!==f&&--g)}return c&&(k=+k||+i||0,e=c[1]?k+(c[1]+1)*c[2]:+c[2],d&&(d.unit=j,d.start=k,d.end=e)),e}var ga={};function ha(a){var b,c=a.ownerDocument,d=a.nodeName,e=ga[d];return e?e:(b=c.body.appendChild(c.createElement(d)),e=r.css(b,"display"),b.parentNode.removeChild(b),"none"===e&&(e="block"),ga[d]=e,e)}function ia(a,b){for(var c,d,e=[],f=0,g=a.length;f<g;f++)d=a[f],d.style&&(c=d.style.display,b?("none"===c&&(e[f]=W.get(d,"display")||null,e[f]||(d.style.display="")),""===d.style.display&&da(d)&&(e[f]=ha(d))):"none"!==c&&(e[f]="none",W.set(d,"display",c)));for(f=0;f<g;f++)null!=e[f]&&(a[f].style.display=e[f]);return a}r.fn.extend({show:function(){return ia(this,!0)},hide:function(){return ia(this)},toggle:function(a){return"boolean"==typeof a?a?this.show():this.hide():this.each(function(){da(this)?r(this).show():r(this).hide()})}});var ja=/^(?:checkbox|radio)$/i,ka=/<([a-z][^\/\0>\x20\t\r\n\f]+)/i,la=/^$|\/(?:java|ecma)script/i,ma={option:[1,"<select multiple='multiple'>","</select>"],thead:[1,"<table>","</table>"],col:[2,"<table><colgroup>","</colgroup></table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],_default:[0,"",""]};ma.optgroup=ma.option,ma.tbody=ma.tfoot=ma.colgroup=ma.caption=ma.thead,ma.th=ma.td;function na(a,b){var c;return c="undefined"!=typeof a.getElementsByTagName?a.getElementsByTagName(b||"*"):"undefined"!=typeof a.querySelectorAll?a.querySelectorAll(b||"*"):[],void 0===b||b&&B(a,b)?r.merge([a],c):c}function oa(a,b){for(var c=0,d=a.length;c<d;c++)W.set(a[c],"globalEval",!b||W.get(b[c],"globalEval"))}var pa=/<|&#?\w+;/;function qa(a,b,c,d,e){for(var f,g,h,i,j,k,l=b.createDocumentFragment(),m=[],n=0,o=a.length;n<o;n++)if(f=a[n],f||0===f)if("object"===r.type(f))r.merge(m,f.nodeType?[f]:f);else if(pa.test(f)){g=g||l.appendChild(b.createElement("div")),h=(ka.exec(f)||["",""])[1].toLowerCase(),i=ma[h]||ma._default,g.innerHTML=i[1]+r.htmlPrefilter(f)+i[2],k=i[0];while(k--)g=g.lastChild;r.merge(m,g.childNodes),g=l.firstChild,g.textContent=""}else m.push(b.createTextNode(f));l.textContent="",n=0;while(f=m[n++])if(d&&r.inArray(f,d)>-1)e&&e.push(f);else if(j=r.contains(f.ownerDocument,f),g=na(l.appendChild(f),"script"),j&&oa(g),c){k=0;while(f=g[k++])la.test(f.type||"")&&c.push(f)}return l}!function(){var a=d.createDocumentFragment(),b=a.appendChild(d.createElement("div")),c=d.createElement("input");c.setAttribute("type","radio"),c.setAttribute("checked","checked"),c.setAttribute("name","t"),b.appendChild(c),o.checkClone=b.cloneNode(!0).cloneNode(!0).lastChild.checked,b.innerHTML="<textarea>x</textarea>",o.noCloneChecked=!!b.cloneNode(!0).lastChild.defaultValue}();var ra=d.documentElement,sa=/^key/,ta=/^(?:mouse|pointer|contextmenu|drag|drop)|click/,ua=/^([^.]*)(?:\.(.+)|)/;function va(){return!0}function wa(){return!1}function xa(){try{return d.activeElement}catch(a){}}function ya(a,b,c,d,e,f){var g,h;if("object"==typeof b){"string"!=typeof c&&(d=d||c,c=void 0);for(h in b)ya(a,h,c,d,b[h],f);return a}if(null==d&&null==e?(e=c,d=c=void 0):null==e&&("string"==typeof c?(e=d,d=void 0):(e=d,d=c,c=void 0)),e===!1)e=wa;else if(!e)return a;return 1===f&&(g=e,e=function(a){return r().off(a),g.apply(this,arguments)},e.guid=g.guid||(g.guid=r.guid++)),a.each(function(){r.event.add(this,b,e,d,c)})}r.event={global:{},add:function(a,b,c,d,e){var f,g,h,i,j,k,l,m,n,o,p,q=W.get(a);if(q){c.handler&&(f=c,c=f.handler,e=f.selector),e&&r.find.matchesSelector(ra,e),c.guid||(c.guid=r.guid++),(i=q.events)||(i=q.events={}),(g=q.handle)||(g=q.handle=function(b){return"undefined"!=typeof r&&r.event.triggered!==b.type?r.event.dispatch.apply(a,arguments):void 0}),b=(b||"").match(L)||[""],j=b.length;while(j--)h=ua.exec(b[j])||[],n=p=h[1],o=(h[2]||"").split(".").sort(),n&&(l=r.event.special[n]||{},n=(e?l.delegateType:l.bindType)||n,l=r.event.special[n]||{},k=r.extend({type:n,origType:p,data:d,handler:c,guid:c.guid,selector:e,needsContext:e&&r.expr.match.needsContext.test(e),namespace:o.join(".")},f),(m=i[n])||(m=i[n]=[],m.delegateCount=0,l.setup&&l.setup.call(a,d,o,g)!==!1||a.addEventListener&&a.addEventListener(n,g)),l.add&&(l.add.call(a,k),k.handler.guid||(k.handler.guid=c.guid)),e?m.splice(m.delegateCount++,0,k):m.push(k),r.event.global[n]=!0)}},remove:function(a,b,c,d,e){var f,g,h,i,j,k,l,m,n,o,p,q=W.hasData(a)&&W.get(a);if(q&&(i=q.events)){b=(b||"").match(L)||[""],j=b.length;while(j--)if(h=ua.exec(b[j])||[],n=p=h[1],o=(h[2]||"").split(".").sort(),n){l=r.event.special[n]||{},n=(d?l.delegateType:l.bindType)||n,m=i[n]||[],h=h[2]&&new RegExp("(^|\\.)"+o.join("\\.(?:.*\\.|)")+"(\\.|$)"),g=f=m.length;while(f--)k=m[f],!e&&p!==k.origType||c&&c.guid!==k.guid||h&&!h.test(k.namespace)||d&&d!==k.selector&&("**"!==d||!k.selector)||(m.splice(f,1),k.selector&&m.delegateCount--,l.remove&&l.remove.call(a,k));g&&!m.length&&(l.teardown&&l.teardown.call(a,o,q.handle)!==!1||r.removeEvent(a,n,q.handle),delete i[n])}else for(n in i)r.event.remove(a,n+b[j],c,d,!0);r.isEmptyObject(i)&&W.remove(a,"handle events")}},dispatch:function(a){var b=r.event.fix(a),c,d,e,f,g,h,i=new Array(arguments.length),j=(W.get(this,"events")||{})[b.type]||[],k=r.event.special[b.type]||{};for(i[0]=b,c=1;c<arguments.length;c++)i[c]=arguments[c];if(b.delegateTarget=this,!k.preDispatch||k.preDispatch.call(this,b)!==!1){h=r.event.handlers.call(this,b,j),c=0;while((f=h[c++])&&!b.isPropagationStopped()){b.currentTarget=f.elem,d=0;while((g=f.handlers[d++])&&!b.isImmediatePropagationStopped())b.rnamespace&&!b.rnamespace.test(g.namespace)||(b.handleObj=g,b.data=g.data,e=((r.event.special[g.origType]||{}).handle||g.handler).apply(f.elem,i),void 0!==e&&(b.result=e)===!1&&(b.preventDefault(),b.stopPropagation()))}return k.postDispatch&&k.postDispatch.call(this,b),b.result}},handlers:function(a,b){var c,d,e,f,g,h=[],i=b.delegateCount,j=a.target;if(i&&j.nodeType&&!("click"===a.type&&a.button>=1))for(;j!==this;j=j.parentNode||this)if(1===j.nodeType&&("click"!==a.type||j.disabled!==!0)){for(f=[],g={},c=0;c<i;c++)d=b[c],e=d.selector+" ",void 0===g[e]&&(g[e]=d.needsContext?r(e,this).index(j)>-1:r.find(e,this,null,[j]).length),g[e]&&f.push(d);f.length&&h.push({elem:j,handlers:f})}return j=this,i<b.length&&h.push({elem:j,handlers:b.slice(i)}),h},addProp:function(a,b){Object.defineProperty(r.Event.prototype,a,{enumerable:!0,configurable:!0,get:r.isFunction(b)?function(){if(this.originalEvent)return b(this.originalEvent)}:function(){if(this.originalEvent)return this.originalEvent[a]},set:function(b){Object.defineProperty(this,a,{enumerable:!0,configurable:!0,writable:!0,value:b})}})},fix:function(a){return a[r.expando]?a:new r.Event(a)},special:{load:{noBubble:!0},focus:{trigger:function(){if(this!==xa()&&this.focus)return this.focus(),!1},delegateType:"focusin"},blur:{trigger:function(){if(this===xa()&&this.blur)return this.blur(),!1},delegateType:"focusout"},click:{trigger:function(){if("checkbox"===this.type&&this.click&&B(this,"input"))return this.click(),!1},_default:function(a){return B(a.target,"a")}},beforeunload:{postDispatch:function(a){void 0!==a.result&&a.originalEvent&&(a.originalEvent.returnValue=a.result)}}}},r.removeEvent=function(a,b,c){a.removeEventListener&&a.removeEventListener(b,c)},r.Event=function(a,b){return this instanceof r.Event?(a&&a.type?(this.originalEvent=a,this.type=a.type,this.isDefaultPrevented=a.defaultPrevented||void 0===a.defaultPrevented&&a.returnValue===!1?va:wa,this.target=a.target&&3===a.target.nodeType?a.target.parentNode:a.target,this.currentTarget=a.currentTarget,this.relatedTarget=a.relatedTarget):this.type=a,b&&r.extend(this,b),this.timeStamp=a&&a.timeStamp||r.now(),void(this[r.expando]=!0)):new r.Event(a,b)},r.Event.prototype={constructor:r.Event,isDefaultPrevented:wa,isPropagationStopped:wa,isImmediatePropagationStopped:wa,isSimulated:!1,preventDefault:function(){var a=this.originalEvent;this.isDefaultPrevented=va,a&&!this.isSimulated&&a.preventDefault()},stopPropagation:function(){var a=this.originalEvent;this.isPropagationStopped=va,a&&!this.isSimulated&&a.stopPropagation()},stopImmediatePropagation:function(){var a=this.originalEvent;this.isImmediatePropagationStopped=va,a&&!this.isSimulated&&a.stopImmediatePropagation(),this.stopPropagation()}},r.each({altKey:!0,bubbles:!0,cancelable:!0,changedTouches:!0,ctrlKey:!0,detail:!0,eventPhase:!0,metaKey:!0,pageX:!0,pageY:!0,shiftKey:!0,view:!0,"char":!0,charCode:!0,key:!0,keyCode:!0,button:!0,buttons:!0,clientX:!0,clientY:!0,offsetX:!0,offsetY:!0,pointerId:!0,pointerType:!0,screenX:!0,screenY:!0,targetTouches:!0,toElement:!0,touches:!0,which:function(a){var b=a.button;return null==a.which&&sa.test(a.type)?null!=a.charCode?a.charCode:a.keyCode:!a.which&&void 0!==b&&ta.test(a.type)?1&b?1:2&b?3:4&b?2:0:a.which}},r.event.addProp),r.each({mouseenter:"mouseover",mouseleave:"mouseout",pointerenter:"pointerover",pointerleave:"pointerout"},function(a,b){r.event.special[a]={delegateType:b,bindType:b,handle:function(a){var c,d=this,e=a.relatedTarget,f=a.handleObj;return e&&(e===d||r.contains(d,e))||(a.type=f.origType,c=f.handler.apply(this,arguments),a.type=b),c}}}),r.fn.extend({on:function(a,b,c,d){return ya(this,a,b,c,d)},one:function(a,b,c,d){return ya(this,a,b,c,d,1)},off:function(a,b,c){var d,e;if(a&&a.preventDefault&&a.handleObj)return d=a.handleObj,r(a.delegateTarget).off(d.namespace?d.origType+"."+d.namespace:d.origType,d.selector,d.handler),this;if("object"==typeof a){for(e in a)this.off(e,b,a[e]);return this}return b!==!1&&"function"!=typeof b||(c=b,b=void 0),c===!1&&(c=wa),this.each(function(){r.event.remove(this,a,c,b)})}});var za=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi,Aa=/<script|<style|<link/i,Ba=/checked\s*(?:[^=]|=\s*.checked.)/i,Ca=/^true\/(.*)/,Da=/^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;function Ea(a,b){return B(a,"table")&&B(11!==b.nodeType?b:b.firstChild,"tr")?r(">tbody",a)[0]||a:a}function Fa(a){return a.type=(null!==a.getAttribute("type"))+"/"+a.type,a}function Ga(a){var b=Ca.exec(a.type);return b?a.type=b[1]:a.removeAttribute("type"),a}function Ha(a,b){var c,d,e,f,g,h,i,j;if(1===b.nodeType){if(W.hasData(a)&&(f=W.access(a),g=W.set(b,f),j=f.events)){delete g.handle,g.events={};for(e in j)for(c=0,d=j[e].length;c<d;c++)r.event.add(b,e,j[e][c])}X.hasData(a)&&(h=X.access(a),i=r.extend({},h),X.set(b,i))}}function Ia(a,b){var c=b.nodeName.toLowerCase();"input"===c&&ja.test(a.type)?b.checked=a.checked:"input"!==c&&"textarea"!==c||(b.defaultValue=a.defaultValue)}function Ja(a,b,c,d){b=g.apply([],b);var e,f,h,i,j,k,l=0,m=a.length,n=m-1,q=b[0],s=r.isFunction(q);if(s||m>1&&"string"==typeof q&&!o.checkClone&&Ba.test(q))return a.each(function(e){var f=a.eq(e);s&&(b[0]=q.call(this,e,f.html())),Ja(f,b,c,d)});if(m&&(e=qa(b,a[0].ownerDocument,!1,a,d),f=e.firstChild,1===e.childNodes.length&&(e=f),f||d)){for(h=r.map(na(e,"script"),Fa),i=h.length;l<m;l++)j=e,l!==n&&(j=r.clone(j,!0,!0),i&&r.merge(h,na(j,"script"))),c.call(a[l],j,l);if(i)for(k=h[h.length-1].ownerDocument,r.map(h,Ga),l=0;l<i;l++)j=h[l],la.test(j.type||"")&&!W.access(j,"globalEval")&&r.contains(k,j)&&(j.src?r._evalUrl&&r._evalUrl(j.src):p(j.textContent.replace(Da,""),k))}return a}function Ka(a,b,c){for(var d,e=b?r.filter(b,a):a,f=0;null!=(d=e[f]);f++)c||1!==d.nodeType||r.cleanData(na(d)),d.parentNode&&(c&&r.contains(d.ownerDocument,d)&&oa(na(d,"script")),d.parentNode.removeChild(d));return a}r.extend({htmlPrefilter:function(a){return a.replace(za,"<$1></$2>")},clone:function(a,b,c){var d,e,f,g,h=a.cloneNode(!0),i=r.contains(a.ownerDocument,a);if(!(o.noCloneChecked||1!==a.nodeType&&11!==a.nodeType||r.isXMLDoc(a)))for(g=na(h),f=na(a),d=0,e=f.length;d<e;d++)Ia(f[d],g[d]);if(b)if(c)for(f=f||na(a),g=g||na(h),d=0,e=f.length;d<e;d++)Ha(f[d],g[d]);else Ha(a,h);return g=na(h,"script"),g.length>0&&oa(g,!i&&na(a,"script")),h},cleanData:function(a){for(var b,c,d,e=r.event.special,f=0;void 0!==(c=a[f]);f++)if(U(c)){if(b=c[W.expando]){if(b.events)for(d in b.events)e[d]?r.event.remove(c,d):r.removeEvent(c,d,b.handle);c[W.expando]=void 0}c[X.expando]&&(c[X.expando]=void 0)}}}),r.fn.extend({detach:function(a){return Ka(this,a,!0)},remove:function(a){return Ka(this,a)},text:function(a){return T(this,function(a){return void 0===a?r.text(this):this.empty().each(function(){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||(this.textContent=a)})},null,a,arguments.length)},append:function(){return Ja(this,arguments,function(a){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var b=Ea(this,a);b.appendChild(a)}})},prepend:function(){return Ja(this,arguments,function(a){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var b=Ea(this,a);b.insertBefore(a,b.firstChild)}})},before:function(){return Ja(this,arguments,function(a){this.parentNode&&this.parentNode.insertBefore(a,this)})},after:function(){return Ja(this,arguments,function(a){this.parentNode&&this.parentNode.insertBefore(a,this.nextSibling)})},empty:function(){for(var a,b=0;null!=(a=this[b]);b++)1===a.nodeType&&(r.cleanData(na(a,!1)),a.textContent="");return this},clone:function(a,b){return a=null!=a&&a,b=null==b?a:b,this.map(function(){return r.clone(this,a,b)})},html:function(a){return T(this,function(a){var b=this[0]||{},c=0,d=this.length;if(void 0===a&&1===b.nodeType)return b.innerHTML;if("string"==typeof a&&!Aa.test(a)&&!ma[(ka.exec(a)||["",""])[1].toLowerCase()]){a=r.htmlPrefilter(a);try{for(;c<d;c++)b=this[c]||{},1===b.nodeType&&(r.cleanData(na(b,!1)),b.innerHTML=a);b=0}catch(e){}}b&&this.empty().append(a)},null,a,arguments.length)},replaceWith:function(){var a=[];return Ja(this,arguments,function(b){var c=this.parentNode;r.inArray(this,a)<0&&(r.cleanData(na(this)),c&&c.replaceChild(b,this))},a)}}),r.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(a,b){r.fn[a]=function(a){for(var c,d=[],e=r(a),f=e.length-1,g=0;g<=f;g++)c=g===f?this:this.clone(!0),r(e[g])[b](c),h.apply(d,c.get());return this.pushStack(d)}});var La=/^margin/,Ma=new RegExp("^("+aa+")(?!px)[a-z%]+$","i"),Na=function(b){var c=b.ownerDocument.defaultView;return c&&c.opener||(c=a),c.getComputedStyle(b)};!function(){function b(){if(i){i.style.cssText="box-sizing:border-box;position:relative;display:block;margin:auto;border:1px;padding:1px;top:1%;width:50%",i.innerHTML="",ra.appendChild(h);var b=a.getComputedStyle(i);c="1%"!==b.top,g="2px"===b.marginLeft,e="4px"===b.width,i.style.marginRight="50%",f="4px"===b.marginRight,ra.removeChild(h),i=null}}var c,e,f,g,h=d.createElement("div"),i=d.createElement("div");i.style&&(i.style.backgroundClip="content-box",i.cloneNode(!0).style.backgroundClip="",o.clearCloneStyle="content-box"===i.style.backgroundClip,h.style.cssText="border:0;width:8px;height:0;top:0;left:-9999px;padding:0;margin-top:1px;position:absolute",h.appendChild(i),r.extend(o,{pixelPosition:function(){return b(),c},boxSizingReliable:function(){return b(),e},pixelMarginRight:function(){return b(),f},reliableMarginLeft:function(){return b(),g}}))}();function Oa(a,b,c){var d,e,f,g,h=a.style;return c=c||Na(a),c&&(g=c.getPropertyValue(b)||c[b],""!==g||r.contains(a.ownerDocument,a)||(g=r.style(a,b)),!o.pixelMarginRight()&&Ma.test(g)&&La.test(b)&&(d=h.width,e=h.minWidth,f=h.maxWidth,h.minWidth=h.maxWidth=h.width=g,g=c.width,h.width=d,h.minWidth=e,h.maxWidth=f)),void 0!==g?g+"":g}function Pa(a,b){return{get:function(){return a()?void delete this.get:(this.get=b).apply(this,arguments)}}}var Qa=/^(none|table(?!-c[ea]).+)/,Ra=/^--/,Sa={position:"absolute",visibility:"hidden",display:"block"},Ta={letterSpacing:"0",fontWeight:"400"},Ua=["Webkit","Moz","ms"],Va=d.createElement("div").style;function Wa(a){if(a in Va)return a;var b=a[0].toUpperCase()+a.slice(1),c=Ua.length;while(c--)if(a=Ua[c]+b,a in Va)return a}function Xa(a){var b=r.cssProps[a];return b||(b=r.cssProps[a]=Wa(a)||a),b}function Ya(a,b,c){var d=ba.exec(b);return d?Math.max(0,d[2]-(c||0))+(d[3]||"px"):b}function Za(a,b,c,d,e){var f,g=0;for(f=c===(d?"border":"content")?4:"width"===b?1:0;f<4;f+=2)"margin"===c&&(g+=r.css(a,c+ca[f],!0,e)),d?("content"===c&&(g-=r.css(a,"padding"+ca[f],!0,e)),"margin"!==c&&(g-=r.css(a,"border"+ca[f]+"Width",!0,e))):(g+=r.css(a,"padding"+ca[f],!0,e),"padding"!==c&&(g+=r.css(a,"border"+ca[f]+"Width",!0,e)));return g}function $a(a,b,c){var d,e=Na(a),f=Oa(a,b,e),g="border-box"===r.css(a,"boxSizing",!1,e);return Ma.test(f)?f:(d=g&&(o.boxSizingReliable()||f===a.style[b]),"auto"===f&&(f=a["offset"+b[0].toUpperCase()+b.slice(1)]),f=parseFloat(f)||0,f+Za(a,b,c||(g?"border":"content"),d,e)+"px")}r.extend({cssHooks:{opacity:{get:function(a,b){if(b){var c=Oa(a,"opacity");return""===c?"1":c}}}},cssNumber:{animationIterationCount:!0,columnCount:!0,fillOpacity:!0,flexGrow:!0,flexShrink:!0,fontWeight:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{"float":"cssFloat"},style:function(a,b,c,d){if(a&&3!==a.nodeType&&8!==a.nodeType&&a.style){var e,f,g,h=r.camelCase(b),i=Ra.test(b),j=a.style;return i||(b=Xa(h)),g=r.cssHooks[b]||r.cssHooks[h],void 0===c?g&&"get"in g&&void 0!==(e=g.get(a,!1,d))?e:j[b]:(f=typeof c,"string"===f&&(e=ba.exec(c))&&e[1]&&(c=fa(a,b,e),f="number"),null!=c&&c===c&&("number"===f&&(c+=e&&e[3]||(r.cssNumber[h]?"":"px")),o.clearCloneStyle||""!==c||0!==b.indexOf("background")||(j[b]="inherit"),g&&"set"in g&&void 0===(c=g.set(a,c,d))||(i?j.setProperty(b,c):j[b]=c)),void 0)}},css:function(a,b,c,d){var e,f,g,h=r.camelCase(b),i=Ra.test(b);return i||(b=Xa(h)),g=r.cssHooks[b]||r.cssHooks[h],g&&"get"in g&&(e=g.get(a,!0,c)),void 0===e&&(e=Oa(a,b,d)),"normal"===e&&b in Ta&&(e=Ta[b]),""===c||c?(f=parseFloat(e),c===!0||isFinite(f)?f||0:e):e}}),r.each(["height","width"],function(a,b){r.cssHooks[b]={get:function(a,c,d){if(c)return!Qa.test(r.css(a,"display"))||a.getClientRects().length&&a.getBoundingClientRect().width?$a(a,b,d):ea(a,Sa,function(){return $a(a,b,d)})},set:function(a,c,d){var e,f=d&&Na(a),g=d&&Za(a,b,d,"border-box"===r.css(a,"boxSizing",!1,f),f);return g&&(e=ba.exec(c))&&"px"!==(e[3]||"px")&&(a.style[b]=c,c=r.css(a,b)),Ya(a,c,g)}}}),r.cssHooks.marginLeft=Pa(o.reliableMarginLeft,function(a,b){if(b)return(parseFloat(Oa(a,"marginLeft"))||a.getBoundingClientRect().left-ea(a,{marginLeft:0},function(){return a.getBoundingClientRect().left}))+"px"}),r.each({margin:"",padding:"",border:"Width"},function(a,b){r.cssHooks[a+b]={expand:function(c){for(var d=0,e={},f="string"==typeof c?c.split(" "):[c];d<4;d++)e[a+ca[d]+b]=f[d]||f[d-2]||f[0];return e}},La.test(a)||(r.cssHooks[a+b].set=Ya)}),r.fn.extend({css:function(a,b){return T(this,function(a,b,c){var d,e,f={},g=0;if(Array.isArray(b)){for(d=Na(a),e=b.length;g<e;g++)f[b[g]]=r.css(a,b[g],!1,d);return f}return void 0!==c?r.style(a,b,c):r.css(a,b)},a,b,arguments.length>1)}});function _a(a,b,c,d,e){return new _a.prototype.init(a,b,c,d,e)}r.Tween=_a,_a.prototype={constructor:_a,init:function(a,b,c,d,e,f){this.elem=a,this.prop=c,this.easing=e||r.easing._default,this.options=b,this.start=this.now=this.cur(),this.end=d,this.unit=f||(r.cssNumber[c]?"":"px")},cur:function(){var a=_a.propHooks[this.prop];return a&&a.get?a.get(this):_a.propHooks._default.get(this)},run:function(a){var b,c=_a.propHooks[this.prop];return this.options.duration?this.pos=b=r.easing[this.easing](a,this.options.duration*a,0,1,this.options.duration):this.pos=b=a,this.now=(this.end-this.start)*b+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),c&&c.set?c.set(this):_a.propHooks._default.set(this),this}},_a.prototype.init.prototype=_a.prototype,_a.propHooks={_default:{get:function(a){var b;return 1!==a.elem.nodeType||null!=a.elem[a.prop]&&null==a.elem.style[a.prop]?a.elem[a.prop]:(b=r.css(a.elem,a.prop,""),b&&"auto"!==b?b:0)},set:function(a){r.fx.step[a.prop]?r.fx.step[a.prop](a):1!==a.elem.nodeType||null==a.elem.style[r.cssProps[a.prop]]&&!r.cssHooks[a.prop]?a.elem[a.prop]=a.now:r.style(a.elem,a.prop,a.now+a.unit)}}},_a.propHooks.scrollTop=_a.propHooks.scrollLeft={set:function(a){a.elem.nodeType&&a.elem.parentNode&&(a.elem[a.prop]=a.now)}},r.easing={linear:function(a){return a},swing:function(a){return.5-Math.cos(a*Math.PI)/2},_default:"swing"},r.fx=_a.prototype.init,r.fx.step={};var ab,bb,cb=/^(?:toggle|show|hide)$/,db=/queueHooks$/;function eb(){bb&&(d.hidden===!1&&a.requestAnimationFrame?a.requestAnimationFrame(eb):a.setTimeout(eb,r.fx.interval),r.fx.tick())}function fb(){return a.setTimeout(function(){ab=void 0}),ab=r.now()}function gb(a,b){var c,d=0,e={height:a};for(b=b?1:0;d<4;d+=2-b)c=ca[d],e["margin"+c]=e["padding"+c]=a;return b&&(e.opacity=e.width=a),e}function hb(a,b,c){for(var d,e=(kb.tweeners[b]||[]).concat(kb.tweeners["*"]),f=0,g=e.length;f<g;f++)if(d=e[f].call(c,b,a))return d}function ib(a,b,c){var d,e,f,g,h,i,j,k,l="width"in b||"height"in b,m=this,n={},o=a.style,p=a.nodeType&&da(a),q=W.get(a,"fxshow");c.queue||(g=r._queueHooks(a,"fx"),null==g.unqueued&&(g.unqueued=0,h=g.empty.fire,g.empty.fire=function(){g.unqueued||h()}),g.unqueued++,m.always(function(){m.always(function(){g.unqueued--,r.queue(a,"fx").length||g.empty.fire()})}));for(d in b)if(e=b[d],cb.test(e)){if(delete b[d],f=f||"toggle"===e,e===(p?"hide":"show")){if("show"!==e||!q||void 0===q[d])continue;p=!0}n[d]=q&&q[d]||r.style(a,d)}if(i=!r.isEmptyObject(b),i||!r.isEmptyObject(n)){l&&1===a.nodeType&&(c.overflow=[o.overflow,o.overflowX,o.overflowY],j=q&&q.display,null==j&&(j=W.get(a,"display")),k=r.css(a,"display"),"none"===k&&(j?k=j:(ia([a],!0),j=a.style.display||j,k=r.css(a,"display"),ia([a]))),("inline"===k||"inline-block"===k&&null!=j)&&"none"===r.css(a,"float")&&(i||(m.done(function(){o.display=j}),null==j&&(k=o.display,j="none"===k?"":k)),o.display="inline-block")),c.overflow&&(o.overflow="hidden",m.always(function(){o.overflow=c.overflow[0],o.overflowX=c.overflow[1],o.overflowY=c.overflow[2]})),i=!1;for(d in n)i||(q?"hidden"in q&&(p=q.hidden):q=W.access(a,"fxshow",{display:j}),f&&(q.hidden=!p),p&&ia([a],!0),m.done(function(){p||ia([a]),W.remove(a,"fxshow");for(d in n)r.style(a,d,n[d])})),i=hb(p?q[d]:0,d,m),d in q||(q[d]=i.start,p&&(i.end=i.start,i.start=0))}}function jb(a,b){var c,d,e,f,g;for(c in a)if(d=r.camelCase(c),e=b[d],f=a[c],Array.isArray(f)&&(e=f[1],f=a[c]=f[0]),c!==d&&(a[d]=f,delete a[c]),g=r.cssHooks[d],g&&"expand"in g){f=g.expand(f),delete a[d];for(c in f)c in a||(a[c]=f[c],b[c]=e)}else b[d]=e}function kb(a,b,c){var d,e,f=0,g=kb.prefilters.length,h=r.Deferred().always(function(){delete i.elem}),i=function(){if(e)return!1;for(var b=ab||fb(),c=Math.max(0,j.startTime+j.duration-b),d=c/j.duration||0,f=1-d,g=0,i=j.tweens.length;g<i;g++)j.tweens[g].run(f);return h.notifyWith(a,[j,f,c]),f<1&&i?c:(i||h.notifyWith(a,[j,1,0]),h.resolveWith(a,[j]),!1)},j=h.promise({elem:a,props:r.extend({},b),opts:r.extend(!0,{specialEasing:{},easing:r.easing._default},c),originalProperties:b,originalOptions:c,startTime:ab||fb(),duration:c.duration,tweens:[],createTween:function(b,c){var d=r.Tween(a,j.opts,b,c,j.opts.specialEasing[b]||j.opts.easing);return j.tweens.push(d),d},stop:function(b){var c=0,d=b?j.tweens.length:0;if(e)return this;for(e=!0;c<d;c++)j.tweens[c].run(1);return b?(h.notifyWith(a,[j,1,0]),h.resolveWith(a,[j,b])):h.rejectWith(a,[j,b]),this}}),k=j.props;for(jb(k,j.opts.specialEasing);f<g;f++)if(d=kb.prefilters[f].call(j,a,k,j.opts))return r.isFunction(d.stop)&&(r._queueHooks(j.elem,j.opts.queue).stop=r.proxy(d.stop,d)),d;return r.map(k,hb,j),r.isFunction(j.opts.start)&&j.opts.start.call(a,j),j.progress(j.opts.progress).done(j.opts.done,j.opts.complete).fail(j.opts.fail).always(j.opts.always),r.fx.timer(r.extend(i,{elem:a,anim:j,queue:j.opts.queue})),j}r.Animation=r.extend(kb,{tweeners:{"*":[function(a,b){var c=this.createTween(a,b);return fa(c.elem,a,ba.exec(b),c),c}]},tweener:function(a,b){r.isFunction(a)?(b=a,a=["*"]):a=a.match(L);for(var c,d=0,e=a.length;d<e;d++)c=a[d],kb.tweeners[c]=kb.tweeners[c]||[],kb.tweeners[c].unshift(b)},prefilters:[ib],prefilter:function(a,b){b?kb.prefilters.unshift(a):kb.prefilters.push(a)}}),r.speed=function(a,b,c){var d=a&&"object"==typeof a?r.extend({},a):{complete:c||!c&&b||r.isFunction(a)&&a,duration:a,easing:c&&b||b&&!r.isFunction(b)&&b};return r.fx.off?d.duration=0:"number"!=typeof d.duration&&(d.duration in r.fx.speeds?d.duration=r.fx.speeds[d.duration]:d.duration=r.fx.speeds._default),null!=d.queue&&d.queue!==!0||(d.queue="fx"),d.old=d.complete,d.complete=function(){r.isFunction(d.old)&&d.old.call(this),d.queue&&r.dequeue(this,d.queue)},d},r.fn.extend({fadeTo:function(a,b,c,d){return this.filter(da).css("opacity",0).show().end().animate({opacity:b},a,c,d)},animate:function(a,b,c,d){var e=r.isEmptyObject(a),f=r.speed(b,c,d),g=function(){var b=kb(this,r.extend({},a),f);(e||W.get(this,"finish"))&&b.stop(!0)};return g.finish=g,e||f.queue===!1?this.each(g):this.queue(f.queue,g)},stop:function(a,b,c){var d=function(a){var b=a.stop;delete a.stop,b(c)};return"string"!=typeof a&&(c=b,b=a,a=void 0),b&&a!==!1&&this.queue(a||"fx",[]),this.each(function(){var b=!0,e=null!=a&&a+"queueHooks",f=r.timers,g=W.get(this);if(e)g[e]&&g[e].stop&&d(g[e]);else for(e in g)g[e]&&g[e].stop&&db.test(e)&&d(g[e]);for(e=f.length;e--;)f[e].elem!==this||null!=a&&f[e].queue!==a||(f[e].anim.stop(c),b=!1,f.splice(e,1));!b&&c||r.dequeue(this,a)})},finish:function(a){return a!==!1&&(a=a||"fx"),this.each(function(){var b,c=W.get(this),d=c[a+"queue"],e=c[a+"queueHooks"],f=r.timers,g=d?d.length:0;for(c.finish=!0,r.queue(this,a,[]),e&&e.stop&&e.stop.call(this,!0),b=f.length;b--;)f[b].elem===this&&f[b].queue===a&&(f[b].anim.stop(!0),f.splice(b,1));for(b=0;b<g;b++)d[b]&&d[b].finish&&d[b].finish.call(this);delete c.finish})}}),r.each(["toggle","show","hide"],function(a,b){var c=r.fn[b];r.fn[b]=function(a,d,e){return null==a||"boolean"==typeof a?c.apply(this,arguments):this.animate(gb(b,!0),a,d,e)}}),r.each({slideDown:gb("show"),slideUp:gb("hide"),slideToggle:gb("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(a,b){r.fn[a]=function(a,c,d){return this.animate(b,a,c,d)}}),r.timers=[],r.fx.tick=function(){var a,b=0,c=r.timers;for(ab=r.now();b<c.length;b++)a=c[b],a()||c[b]!==a||c.splice(b--,1);c.length||r.fx.stop(),ab=void 0},r.fx.timer=function(a){r.timers.push(a),r.fx.start()},r.fx.interval=13,r.fx.start=function(){bb||(bb=!0,eb())},r.fx.stop=function(){bb=null},r.fx.speeds={slow:600,fast:200,_default:400},r.fn.delay=function(b,c){return b=r.fx?r.fx.speeds[b]||b:b,c=c||"fx",this.queue(c,function(c,d){var e=a.setTimeout(c,b);d.stop=function(){a.clearTimeout(e)}})},function(){var a=d.createElement("input"),b=d.createElement("select"),c=b.appendChild(d.createElement("option"));a.type="checkbox",o.checkOn=""!==a.value,o.optSelected=c.selected,a=d.createElement("input"),a.value="t",a.type="radio",o.radioValue="t"===a.value}();var lb,mb=r.expr.attrHandle;r.fn.extend({attr:function(a,b){return T(this,r.attr,a,b,arguments.length>1)},removeAttr:function(a){return this.each(function(){r.removeAttr(this,a)})}}),r.extend({attr:function(a,b,c){var d,e,f=a.nodeType;if(3!==f&&8!==f&&2!==f)return"undefined"==typeof a.getAttribute?r.prop(a,b,c):(1===f&&r.isXMLDoc(a)||(e=r.attrHooks[b.toLowerCase()]||(r.expr.match.bool.test(b)?lb:void 0)),void 0!==c?null===c?void r.removeAttr(a,b):e&&"set"in e&&void 0!==(d=e.set(a,c,b))?d:(a.setAttribute(b,c+""),c):e&&"get"in e&&null!==(d=e.get(a,b))?d:(d=r.find.attr(a,b),
+null==d?void 0:d))},attrHooks:{type:{set:function(a,b){if(!o.radioValue&&"radio"===b&&B(a,"input")){var c=a.value;return a.setAttribute("type",b),c&&(a.value=c),b}}}},removeAttr:function(a,b){var c,d=0,e=b&&b.match(L);if(e&&1===a.nodeType)while(c=e[d++])a.removeAttribute(c)}}),lb={set:function(a,b,c){return b===!1?r.removeAttr(a,c):a.setAttribute(c,c),c}},r.each(r.expr.match.bool.source.match(/\w+/g),function(a,b){var c=mb[b]||r.find.attr;mb[b]=function(a,b,d){var e,f,g=b.toLowerCase();return d||(f=mb[g],mb[g]=e,e=null!=c(a,b,d)?g:null,mb[g]=f),e}});var nb=/^(?:input|select|textarea|button)$/i,ob=/^(?:a|area)$/i;r.fn.extend({prop:function(a,b){return T(this,r.prop,a,b,arguments.length>1)},removeProp:function(a){return this.each(function(){delete this[r.propFix[a]||a]})}}),r.extend({prop:function(a,b,c){var d,e,f=a.nodeType;if(3!==f&&8!==f&&2!==f)return 1===f&&r.isXMLDoc(a)||(b=r.propFix[b]||b,e=r.propHooks[b]),void 0!==c?e&&"set"in e&&void 0!==(d=e.set(a,c,b))?d:a[b]=c:e&&"get"in e&&null!==(d=e.get(a,b))?d:a[b]},propHooks:{tabIndex:{get:function(a){var b=r.find.attr(a,"tabindex");return b?parseInt(b,10):nb.test(a.nodeName)||ob.test(a.nodeName)&&a.href?0:-1}}},propFix:{"for":"htmlFor","class":"className"}}),o.optSelected||(r.propHooks.selected={get:function(a){var b=a.parentNode;return b&&b.parentNode&&b.parentNode.selectedIndex,null},set:function(a){var b=a.parentNode;b&&(b.selectedIndex,b.parentNode&&b.parentNode.selectedIndex)}}),r.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){r.propFix[this.toLowerCase()]=this});function pb(a){var b=a.match(L)||[];return b.join(" ")}function qb(a){return a.getAttribute&&a.getAttribute("class")||""}r.fn.extend({addClass:function(a){var b,c,d,e,f,g,h,i=0;if(r.isFunction(a))return this.each(function(b){r(this).addClass(a.call(this,b,qb(this)))});if("string"==typeof a&&a){b=a.match(L)||[];while(c=this[i++])if(e=qb(c),d=1===c.nodeType&&" "+pb(e)+" "){g=0;while(f=b[g++])d.indexOf(" "+f+" ")<0&&(d+=f+" ");h=pb(d),e!==h&&c.setAttribute("class",h)}}return this},removeClass:function(a){var b,c,d,e,f,g,h,i=0;if(r.isFunction(a))return this.each(function(b){r(this).removeClass(a.call(this,b,qb(this)))});if(!arguments.length)return this.attr("class","");if("string"==typeof a&&a){b=a.match(L)||[];while(c=this[i++])if(e=qb(c),d=1===c.nodeType&&" "+pb(e)+" "){g=0;while(f=b[g++])while(d.indexOf(" "+f+" ")>-1)d=d.replace(" "+f+" "," ");h=pb(d),e!==h&&c.setAttribute("class",h)}}return this},toggleClass:function(a,b){var c=typeof a;return"boolean"==typeof b&&"string"===c?b?this.addClass(a):this.removeClass(a):r.isFunction(a)?this.each(function(c){r(this).toggleClass(a.call(this,c,qb(this),b),b)}):this.each(function(){var b,d,e,f;if("string"===c){d=0,e=r(this),f=a.match(L)||[];while(b=f[d++])e.hasClass(b)?e.removeClass(b):e.addClass(b)}else void 0!==a&&"boolean"!==c||(b=qb(this),b&&W.set(this,"__className__",b),this.setAttribute&&this.setAttribute("class",b||a===!1?"":W.get(this,"__className__")||""))})},hasClass:function(a){var b,c,d=0;b=" "+a+" ";while(c=this[d++])if(1===c.nodeType&&(" "+pb(qb(c))+" ").indexOf(b)>-1)return!0;return!1}});var rb=/\r/g;r.fn.extend({val:function(a){var b,c,d,e=this[0];{if(arguments.length)return d=r.isFunction(a),this.each(function(c){var e;1===this.nodeType&&(e=d?a.call(this,c,r(this).val()):a,null==e?e="":"number"==typeof e?e+="":Array.isArray(e)&&(e=r.map(e,function(a){return null==a?"":a+""})),b=r.valHooks[this.type]||r.valHooks[this.nodeName.toLowerCase()],b&&"set"in b&&void 0!==b.set(this,e,"value")||(this.value=e))});if(e)return b=r.valHooks[e.type]||r.valHooks[e.nodeName.toLowerCase()],b&&"get"in b&&void 0!==(c=b.get(e,"value"))?c:(c=e.value,"string"==typeof c?c.replace(rb,""):null==c?"":c)}}}),r.extend({valHooks:{option:{get:function(a){var b=r.find.attr(a,"value");return null!=b?b:pb(r.text(a))}},select:{get:function(a){var b,c,d,e=a.options,f=a.selectedIndex,g="select-one"===a.type,h=g?null:[],i=g?f+1:e.length;for(d=f<0?i:g?f:0;d<i;d++)if(c=e[d],(c.selected||d===f)&&!c.disabled&&(!c.parentNode.disabled||!B(c.parentNode,"optgroup"))){if(b=r(c).val(),g)return b;h.push(b)}return h},set:function(a,b){var c,d,e=a.options,f=r.makeArray(b),g=e.length;while(g--)d=e[g],(d.selected=r.inArray(r.valHooks.option.get(d),f)>-1)&&(c=!0);return c||(a.selectedIndex=-1),f}}}}),r.each(["radio","checkbox"],function(){r.valHooks[this]={set:function(a,b){if(Array.isArray(b))return a.checked=r.inArray(r(a).val(),b)>-1}},o.checkOn||(r.valHooks[this].get=function(a){return null===a.getAttribute("value")?"on":a.value})});var sb=/^(?:focusinfocus|focusoutblur)$/;r.extend(r.event,{trigger:function(b,c,e,f){var g,h,i,j,k,m,n,o=[e||d],p=l.call(b,"type")?b.type:b,q=l.call(b,"namespace")?b.namespace.split("."):[];if(h=i=e=e||d,3!==e.nodeType&&8!==e.nodeType&&!sb.test(p+r.event.triggered)&&(p.indexOf(".")>-1&&(q=p.split("."),p=q.shift(),q.sort()),k=p.indexOf(":")<0&&"on"+p,b=b[r.expando]?b:new r.Event(p,"object"==typeof b&&b),b.isTrigger=f?2:3,b.namespace=q.join("."),b.rnamespace=b.namespace?new RegExp("(^|\\.)"+q.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,b.result=void 0,b.target||(b.target=e),c=null==c?[b]:r.makeArray(c,[b]),n=r.event.special[p]||{},f||!n.trigger||n.trigger.apply(e,c)!==!1)){if(!f&&!n.noBubble&&!r.isWindow(e)){for(j=n.delegateType||p,sb.test(j+p)||(h=h.parentNode);h;h=h.parentNode)o.push(h),i=h;i===(e.ownerDocument||d)&&o.push(i.defaultView||i.parentWindow||a)}g=0;while((h=o[g++])&&!b.isPropagationStopped())b.type=g>1?j:n.bindType||p,m=(W.get(h,"events")||{})[b.type]&&W.get(h,"handle"),m&&m.apply(h,c),m=k&&h[k],m&&m.apply&&U(h)&&(b.result=m.apply(h,c),b.result===!1&&b.preventDefault());return b.type=p,f||b.isDefaultPrevented()||n._default&&n._default.apply(o.pop(),c)!==!1||!U(e)||k&&r.isFunction(e[p])&&!r.isWindow(e)&&(i=e[k],i&&(e[k]=null),r.event.triggered=p,e[p](),r.event.triggered=void 0,i&&(e[k]=i)),b.result}},simulate:function(a,b,c){var d=r.extend(new r.Event,c,{type:a,isSimulated:!0});r.event.trigger(d,null,b)}}),r.fn.extend({trigger:function(a,b){return this.each(function(){r.event.trigger(a,b,this)})},triggerHandler:function(a,b){var c=this[0];if(c)return r.event.trigger(a,b,c,!0)}}),r.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(a,b){r.fn[b]=function(a,c){return arguments.length>0?this.on(b,null,a,c):this.trigger(b)}}),r.fn.extend({hover:function(a,b){return this.mouseenter(a).mouseleave(b||a)}}),o.focusin="onfocusin"in a,o.focusin||r.each({focus:"focusin",blur:"focusout"},function(a,b){var c=function(a){r.event.simulate(b,a.target,r.event.fix(a))};r.event.special[b]={setup:function(){var d=this.ownerDocument||this,e=W.access(d,b);e||d.addEventListener(a,c,!0),W.access(d,b,(e||0)+1)},teardown:function(){var d=this.ownerDocument||this,e=W.access(d,b)-1;e?W.access(d,b,e):(d.removeEventListener(a,c,!0),W.remove(d,b))}}});var tb=a.location,ub=r.now(),vb=/\?/;r.parseXML=function(b){var c;if(!b||"string"!=typeof b)return null;try{c=(new a.DOMParser).parseFromString(b,"text/xml")}catch(d){c=void 0}return c&&!c.getElementsByTagName("parsererror").length||r.error("Invalid XML: "+b),c};var wb=/\[\]$/,xb=/\r?\n/g,yb=/^(?:submit|button|image|reset|file)$/i,zb=/^(?:input|select|textarea|keygen)/i;function Ab(a,b,c,d){var e;if(Array.isArray(b))r.each(b,function(b,e){c||wb.test(a)?d(a,e):Ab(a+"["+("object"==typeof e&&null!=e?b:"")+"]",e,c,d)});else if(c||"object"!==r.type(b))d(a,b);else for(e in b)Ab(a+"["+e+"]",b[e],c,d)}r.param=function(a,b){var c,d=[],e=function(a,b){var c=r.isFunction(b)?b():b;d[d.length]=encodeURIComponent(a)+"="+encodeURIComponent(null==c?"":c)};if(Array.isArray(a)||a.jquery&&!r.isPlainObject(a))r.each(a,function(){e(this.name,this.value)});else for(c in a)Ab(c,a[c],b,e);return d.join("&")},r.fn.extend({serialize:function(){return r.param(this.serializeArray())},serializeArray:function(){return this.map(function(){var a=r.prop(this,"elements");return a?r.makeArray(a):this}).filter(function(){var a=this.type;return this.name&&!r(this).is(":disabled")&&zb.test(this.nodeName)&&!yb.test(a)&&(this.checked||!ja.test(a))}).map(function(a,b){var c=r(this).val();return null==c?null:Array.isArray(c)?r.map(c,function(a){return{name:b.name,value:a.replace(xb,"\r\n")}}):{name:b.name,value:c.replace(xb,"\r\n")}}).get()}});var Bb=/%20/g,Cb=/#.*$/,Db=/([?&])_=[^&]*/,Eb=/^(.*?):[ \t]*([^\r\n]*)$/gm,Fb=/^(?:about|app|app-storage|.+-extension|file|res|widget):$/,Gb=/^(?:GET|HEAD)$/,Hb=/^\/\//,Ib={},Jb={},Kb="*/".concat("*"),Lb=d.createElement("a");Lb.href=tb.href;function Mb(a){return function(b,c){"string"!=typeof b&&(c=b,b="*");var d,e=0,f=b.toLowerCase().match(L)||[];if(r.isFunction(c))while(d=f[e++])"+"===d[0]?(d=d.slice(1)||"*",(a[d]=a[d]||[]).unshift(c)):(a[d]=a[d]||[]).push(c)}}function Nb(a,b,c,d){var e={},f=a===Jb;function g(h){var i;return e[h]=!0,r.each(a[h]||[],function(a,h){var j=h(b,c,d);return"string"!=typeof j||f||e[j]?f?!(i=j):void 0:(b.dataTypes.unshift(j),g(j),!1)}),i}return g(b.dataTypes[0])||!e["*"]&&g("*")}function Ob(a,b){var c,d,e=r.ajaxSettings.flatOptions||{};for(c in b)void 0!==b[c]&&((e[c]?a:d||(d={}))[c]=b[c]);return d&&r.extend(!0,a,d),a}function Pb(a,b,c){var d,e,f,g,h=a.contents,i=a.dataTypes;while("*"===i[0])i.shift(),void 0===d&&(d=a.mimeType||b.getResponseHeader("Content-Type"));if(d)for(e in h)if(h[e]&&h[e].test(d)){i.unshift(e);break}if(i[0]in c)f=i[0];else{for(e in c){if(!i[0]||a.converters[e+" "+i[0]]){f=e;break}g||(g=e)}f=f||g}if(f)return f!==i[0]&&i.unshift(f),c[f]}function Qb(a,b,c,d){var e,f,g,h,i,j={},k=a.dataTypes.slice();if(k[1])for(g in a.converters)j[g.toLowerCase()]=a.converters[g];f=k.shift();while(f)if(a.responseFields[f]&&(c[a.responseFields[f]]=b),!i&&d&&a.dataFilter&&(b=a.dataFilter(b,a.dataType)),i=f,f=k.shift())if("*"===f)f=i;else if("*"!==i&&i!==f){if(g=j[i+" "+f]||j["* "+f],!g)for(e in j)if(h=e.split(" "),h[1]===f&&(g=j[i+" "+h[0]]||j["* "+h[0]])){g===!0?g=j[e]:j[e]!==!0&&(f=h[0],k.unshift(h[1]));break}if(g!==!0)if(g&&a["throws"])b=g(b);else try{b=g(b)}catch(l){return{state:"parsererror",error:g?l:"No conversion from "+i+" to "+f}}}return{state:"success",data:b}}r.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:tb.href,type:"GET",isLocal:Fb.test(tb.protocol),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":Kb,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/\bxml\b/,html:/\bhtml/,json:/\bjson\b/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":JSON.parse,"text xml":r.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(a,b){return b?Ob(Ob(a,r.ajaxSettings),b):Ob(r.ajaxSettings,a)},ajaxPrefilter:Mb(Ib),ajaxTransport:Mb(Jb),ajax:function(b,c){"object"==typeof b&&(c=b,b=void 0),c=c||{};var e,f,g,h,i,j,k,l,m,n,o=r.ajaxSetup({},c),p=o.context||o,q=o.context&&(p.nodeType||p.jquery)?r(p):r.event,s=r.Deferred(),t=r.Callbacks("once memory"),u=o.statusCode||{},v={},w={},x="canceled",y={readyState:0,getResponseHeader:function(a){var b;if(k){if(!h){h={};while(b=Eb.exec(g))h[b[1].toLowerCase()]=b[2]}b=h[a.toLowerCase()]}return null==b?null:b},getAllResponseHeaders:function(){return k?g:null},setRequestHeader:function(a,b){return null==k&&(a=w[a.toLowerCase()]=w[a.toLowerCase()]||a,v[a]=b),this},overrideMimeType:function(a){return null==k&&(o.mimeType=a),this},statusCode:function(a){var b;if(a)if(k)y.always(a[y.status]);else for(b in a)u[b]=[u[b],a[b]];return this},abort:function(a){var b=a||x;return e&&e.abort(b),A(0,b),this}};if(s.promise(y),o.url=((b||o.url||tb.href)+"").replace(Hb,tb.protocol+"//"),o.type=c.method||c.type||o.method||o.type,o.dataTypes=(o.dataType||"*").toLowerCase().match(L)||[""],null==o.crossDomain){j=d.createElement("a");try{j.href=o.url,j.href=j.href,o.crossDomain=Lb.protocol+"//"+Lb.host!=j.protocol+"//"+j.host}catch(z){o.crossDomain=!0}}if(o.data&&o.processData&&"string"!=typeof o.data&&(o.data=r.param(o.data,o.traditional)),Nb(Ib,o,c,y),k)return y;l=r.event&&o.global,l&&0===r.active++&&r.event.trigger("ajaxStart"),o.type=o.type.toUpperCase(),o.hasContent=!Gb.test(o.type),f=o.url.replace(Cb,""),o.hasContent?o.data&&o.processData&&0===(o.contentType||"").indexOf("application/x-www-form-urlencoded")&&(o.data=o.data.replace(Bb,"+")):(n=o.url.slice(f.length),o.data&&(f+=(vb.test(f)?"&":"?")+o.data,delete o.data),o.cache===!1&&(f=f.replace(Db,"$1"),n=(vb.test(f)?"&":"?")+"_="+ub++ +n),o.url=f+n),o.ifModified&&(r.lastModified[f]&&y.setRequestHeader("If-Modified-Since",r.lastModified[f]),r.etag[f]&&y.setRequestHeader("If-None-Match",r.etag[f])),(o.data&&o.hasContent&&o.contentType!==!1||c.contentType)&&y.setRequestHeader("Content-Type",o.contentType),y.setRequestHeader("Accept",o.dataTypes[0]&&o.accepts[o.dataTypes[0]]?o.accepts[o.dataTypes[0]]+("*"!==o.dataTypes[0]?", "+Kb+"; q=0.01":""):o.accepts["*"]);for(m in o.headers)y.setRequestHeader(m,o.headers[m]);if(o.beforeSend&&(o.beforeSend.call(p,y,o)===!1||k))return y.abort();if(x="abort",t.add(o.complete),y.done(o.success),y.fail(o.error),e=Nb(Jb,o,c,y)){if(y.readyState=1,l&&q.trigger("ajaxSend",[y,o]),k)return y;o.async&&o.timeout>0&&(i=a.setTimeout(function(){y.abort("timeout")},o.timeout));try{k=!1,e.send(v,A)}catch(z){if(k)throw z;A(-1,z)}}else A(-1,"No Transport");function A(b,c,d,h){var j,m,n,v,w,x=c;k||(k=!0,i&&a.clearTimeout(i),e=void 0,g=h||"",y.readyState=b>0?4:0,j=b>=200&&b<300||304===b,d&&(v=Pb(o,y,d)),v=Qb(o,v,y,j),j?(o.ifModified&&(w=y.getResponseHeader("Last-Modified"),w&&(r.lastModified[f]=w),w=y.getResponseHeader("etag"),w&&(r.etag[f]=w)),204===b||"HEAD"===o.type?x="nocontent":304===b?x="notmodified":(x=v.state,m=v.data,n=v.error,j=!n)):(n=x,!b&&x||(x="error",b<0&&(b=0))),y.status=b,y.statusText=(c||x)+"",j?s.resolveWith(p,[m,x,y]):s.rejectWith(p,[y,x,n]),y.statusCode(u),u=void 0,l&&q.trigger(j?"ajaxSuccess":"ajaxError",[y,o,j?m:n]),t.fireWith(p,[y,x]),l&&(q.trigger("ajaxComplete",[y,o]),--r.active||r.event.trigger("ajaxStop")))}return y},getJSON:function(a,b,c){return r.get(a,b,c,"json")},getScript:function(a,b){return r.get(a,void 0,b,"script")}}),r.each(["get","post"],function(a,b){r[b]=function(a,c,d,e){return r.isFunction(c)&&(e=e||d,d=c,c=void 0),r.ajax(r.extend({url:a,type:b,dataType:e,data:c,success:d},r.isPlainObject(a)&&a))}}),r._evalUrl=function(a){return r.ajax({url:a,type:"GET",dataType:"script",cache:!0,async:!1,global:!1,"throws":!0})},r.fn.extend({wrapAll:function(a){var b;return this[0]&&(r.isFunction(a)&&(a=a.call(this[0])),b=r(a,this[0].ownerDocument).eq(0).clone(!0),this[0].parentNode&&b.insertBefore(this[0]),b.map(function(){var a=this;while(a.firstElementChild)a=a.firstElementChild;return a}).append(this)),this},wrapInner:function(a){return r.isFunction(a)?this.each(function(b){r(this).wrapInner(a.call(this,b))}):this.each(function(){var b=r(this),c=b.contents();c.length?c.wrapAll(a):b.append(a)})},wrap:function(a){var b=r.isFunction(a);return this.each(function(c){r(this).wrapAll(b?a.call(this,c):a)})},unwrap:function(a){return this.parent(a).not("body").each(function(){r(this).replaceWith(this.childNodes)}),this}}),r.expr.pseudos.hidden=function(a){return!r.expr.pseudos.visible(a)},r.expr.pseudos.visible=function(a){return!!(a.offsetWidth||a.offsetHeight||a.getClientRects().length)},r.ajaxSettings.xhr=function(){try{return new a.XMLHttpRequest}catch(b){}};var Rb={0:200,1223:204},Sb=r.ajaxSettings.xhr();o.cors=!!Sb&&"withCredentials"in Sb,o.ajax=Sb=!!Sb,r.ajaxTransport(function(b){var c,d;if(o.cors||Sb&&!b.crossDomain)return{send:function(e,f){var g,h=b.xhr();if(h.open(b.type,b.url,b.async,b.username,b.password),b.xhrFields)for(g in b.xhrFields)h[g]=b.xhrFields[g];b.mimeType&&h.overrideMimeType&&h.overrideMimeType(b.mimeType),b.crossDomain||e["X-Requested-With"]||(e["X-Requested-With"]="XMLHttpRequest");for(g in e)h.setRequestHeader(g,e[g]);c=function(a){return function(){c&&(c=d=h.onload=h.onerror=h.onabort=h.onreadystatechange=null,"abort"===a?h.abort():"error"===a?"number"!=typeof h.status?f(0,"error"):f(h.status,h.statusText):f(Rb[h.status]||h.status,h.statusText,"text"!==(h.responseType||"text")||"string"!=typeof h.responseText?{binary:h.response}:{text:h.responseText},h.getAllResponseHeaders()))}},h.onload=c(),d=h.onerror=c("error"),void 0!==h.onabort?h.onabort=d:h.onreadystatechange=function(){4===h.readyState&&a.setTimeout(function(){c&&d()})},c=c("abort");try{h.send(b.hasContent&&b.data||null)}catch(i){if(c)throw i}},abort:function(){c&&c()}}}),r.ajaxPrefilter(function(a){a.crossDomain&&(a.contents.script=!1)}),r.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/\b(?:java|ecma)script\b/},converters:{"text script":function(a){return r.globalEval(a),a}}}),r.ajaxPrefilter("script",function(a){void 0===a.cache&&(a.cache=!1),a.crossDomain&&(a.type="GET")}),r.ajaxTransport("script",function(a){if(a.crossDomain){var b,c;return{send:function(e,f){b=r("<script>").prop({charset:a.scriptCharset,src:a.url}).on("load error",c=function(a){b.remove(),c=null,a&&f("error"===a.type?404:200,a.type)}),d.head.appendChild(b[0])},abort:function(){c&&c()}}}});var Tb=[],Ub=/(=)\?(?=&|$)|\?\?/;r.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var a=Tb.pop()||r.expando+"_"+ub++;return this[a]=!0,a}}),r.ajaxPrefilter("json jsonp",function(b,c,d){var e,f,g,h=b.jsonp!==!1&&(Ub.test(b.url)?"url":"string"==typeof b.data&&0===(b.contentType||"").indexOf("application/x-www-form-urlencoded")&&Ub.test(b.data)&&"data");if(h||"jsonp"===b.dataTypes[0])return e=b.jsonpCallback=r.isFunction(b.jsonpCallback)?b.jsonpCallback():b.jsonpCallback,h?b[h]=b[h].replace(Ub,"$1"+e):b.jsonp!==!1&&(b.url+=(vb.test(b.url)?"&":"?")+b.jsonp+"="+e),b.converters["script json"]=function(){return g||r.error(e+" was not called"),g[0]},b.dataTypes[0]="json",f=a[e],a[e]=function(){g=arguments},d.always(function(){void 0===f?r(a).removeProp(e):a[e]=f,b[e]&&(b.jsonpCallback=c.jsonpCallback,Tb.push(e)),g&&r.isFunction(f)&&f(g[0]),g=f=void 0}),"script"}),o.createHTMLDocument=function(){var a=d.implementation.createHTMLDocument("").body;return a.innerHTML="<form></form><form></form>",2===a.childNodes.length}(),r.parseHTML=function(a,b,c){if("string"!=typeof a)return[];"boolean"==typeof b&&(c=b,b=!1);var e,f,g;return b||(o.createHTMLDocument?(b=d.implementation.createHTMLDocument(""),e=b.createElement("base"),e.href=d.location.href,b.head.appendChild(e)):b=d),f=C.exec(a),g=!c&&[],f?[b.createElement(f[1])]:(f=qa([a],b,g),g&&g.length&&r(g).remove(),r.merge([],f.childNodes))},r.fn.load=function(a,b,c){var d,e,f,g=this,h=a.indexOf(" ");return h>-1&&(d=pb(a.slice(h)),a=a.slice(0,h)),r.isFunction(b)?(c=b,b=void 0):b&&"object"==typeof b&&(e="POST"),g.length>0&&r.ajax({url:a,type:e||"GET",dataType:"html",data:b}).done(function(a){f=arguments,g.html(d?r("<div>").append(r.parseHTML(a)).find(d):a)}).always(c&&function(a,b){g.each(function(){c.apply(this,f||[a.responseText,b,a])})}),this},r.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(a,b){r.fn[b]=function(a){return this.on(b,a)}}),r.expr.pseudos.animated=function(a){return r.grep(r.timers,function(b){return a===b.elem}).length},r.offset={setOffset:function(a,b,c){var d,e,f,g,h,i,j,k=r.css(a,"position"),l=r(a),m={};"static"===k&&(a.style.position="relative"),h=l.offset(),f=r.css(a,"top"),i=r.css(a,"left"),j=("absolute"===k||"fixed"===k)&&(f+i).indexOf("auto")>-1,j?(d=l.position(),g=d.top,e=d.left):(g=parseFloat(f)||0,e=parseFloat(i)||0),r.isFunction(b)&&(b=b.call(a,c,r.extend({},h))),null!=b.top&&(m.top=b.top-h.top+g),null!=b.left&&(m.left=b.left-h.left+e),"using"in b?b.using.call(a,m):l.css(m)}},r.fn.extend({offset:function(a){if(arguments.length)return void 0===a?this:this.each(function(b){r.offset.setOffset(this,a,b)});var b,c,d,e,f=this[0];if(f)return f.getClientRects().length?(d=f.getBoundingClientRect(),b=f.ownerDocument,c=b.documentElement,e=b.defaultView,{top:d.top+e.pageYOffset-c.clientTop,left:d.left+e.pageXOffset-c.clientLeft}):{top:0,left:0}},position:function(){if(this[0]){var a,b,c=this[0],d={top:0,left:0};return"fixed"===r.css(c,"position")?b=c.getBoundingClientRect():(a=this.offsetParent(),b=this.offset(),B(a[0],"html")||(d=a.offset()),d={top:d.top+r.css(a[0],"borderTopWidth",!0),left:d.left+r.css(a[0],"borderLeftWidth",!0)}),{top:b.top-d.top-r.css(c,"marginTop",!0),left:b.left-d.left-r.css(c,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var a=this.offsetParent;while(a&&"static"===r.css(a,"position"))a=a.offsetParent;return a||ra})}}),r.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(a,b){var c="pageYOffset"===b;r.fn[a]=function(d){return T(this,function(a,d,e){var f;return r.isWindow(a)?f=a:9===a.nodeType&&(f=a.defaultView),void 0===e?f?f[b]:a[d]:void(f?f.scrollTo(c?f.pageXOffset:e,c?e:f.pageYOffset):a[d]=e)},a,d,arguments.length)}}),r.each(["top","left"],function(a,b){r.cssHooks[b]=Pa(o.pixelPosition,function(a,c){if(c)return c=Oa(a,b),Ma.test(c)?r(a).position()[b]+"px":c})}),r.each({Height:"height",Width:"width"},function(a,b){r.each({padding:"inner"+a,content:b,"":"outer"+a},function(c,d){r.fn[d]=function(e,f){var g=arguments.length&&(c||"boolean"!=typeof e),h=c||(e===!0||f===!0?"margin":"border");return T(this,function(b,c,e){var f;return r.isWindow(b)?0===d.indexOf("outer")?b["inner"+a]:b.document.documentElement["client"+a]:9===b.nodeType?(f=b.documentElement,Math.max(b.body["scroll"+a],f["scroll"+a],b.body["offset"+a],f["offset"+a],f["client"+a])):void 0===e?r.css(b,c,h):r.style(b,c,e,h)},b,g?e:void 0,g)}})}),r.fn.extend({bind:function(a,b,c){return this.on(a,null,b,c)},unbind:function(a,b){return this.off(a,null,b)},delegate:function(a,b,c,d){return this.on(b,a,c,d)},undelegate:function(a,b,c){return 1===arguments.length?this.off(a,"**"):this.off(b,a||"**",c)}}),r.holdReady=function(a){a?r.readyWait++:r.ready(!0)},r.isArray=Array.isArray,r.parseJSON=JSON.parse,r.nodeName=B,"function"==typeof define&&define.amd&&define("jquery",[],function(){return r});var Vb=a.jQuery,Wb=a.$;return r.noConflict=function(b){return a.$===r&&(a.$=Wb),b&&a.jQuery===r&&(a.jQuery=Vb),r},b||(a.jQuery=a.$=r),r});
diff --git a/docs/html/_static/language_data.js b/docs/html/_static/language_data.js
new file mode 100644
index 0000000..5266fb1
--- /dev/null
+++ b/docs/html/_static/language_data.js
@@ -0,0 +1,297 @@
+/*
+ * language_data.js
+ * ~~~~~~~~~~~~~~~~
+ *
+ * This script contains the language-specific data used by searchtools.js,
+ * namely the list of stopwords, stemmer, scorer and splitter.
+ *
+ * :copyright: Copyright 2007-2019 by the Sphinx team, see AUTHORS.
+ * :license: BSD, see LICENSE for details.
+ *
+ */
+
+var stopwords = ["a","and","are","as","at","be","but","by","for","if","in","into","is","it","near","no","not","of","on","or","such","that","the","their","then","there","these","they","this","to","was","will","with"];
+
+
+/* Non-minified version JS is _stemmer.js if file is provided */
+/**
+ * Porter Stemmer
+ */
+var Stemmer = function() {
+
+ var step2list = {
+ ational: 'ate',
+ tional: 'tion',
+ enci: 'ence',
+ anci: 'ance',
+ izer: 'ize',
+ bli: 'ble',
+ alli: 'al',
+ entli: 'ent',
+ eli: 'e',
+ ousli: 'ous',
+ ization: 'ize',
+ ation: 'ate',
+ ator: 'ate',
+ alism: 'al',
+ iveness: 'ive',
+ fulness: 'ful',
+ ousness: 'ous',
+ aliti: 'al',
+ iviti: 'ive',
+ biliti: 'ble',
+ logi: 'log'
+ };
+
+ var step3list = {
+ icate: 'ic',
+ ative: '',
+ alize: 'al',
+ iciti: 'ic',
+ ical: 'ic',
+ ful: '',
+ ness: ''
+ };
+
+ var c = "[^aeiou]"; // consonant
+ var v = "[aeiouy]"; // vowel
+ var C = c + "[^aeiouy]*"; // consonant sequence
+ var V = v + "[aeiou]*"; // vowel sequence
+
+ var mgr0 = "^(" + C + ")?" + V + C; // [C]VC... is m>0
+ var meq1 = "^(" + C + ")?" + V + C + "(" + V + ")?$"; // [C]VC[V] is m=1
+ var mgr1 = "^(" + C + ")?" + V + C + V + C; // [C]VCVC... is m>1
+ var s_v = "^(" + C + ")?" + v; // vowel in stem
+
+ this.stemWord = function (w) {
+ var stem;
+ var suffix;
+ var firstch;
+ var origword = w;
+
+ if (w.length < 3)
+ return w;
+
+ var re;
+ var re2;
+ var re3;
+ var re4;
+
+ firstch = w.substr(0,1);
+ if (firstch == "y")
+ w = firstch.toUpperCase() + w.substr(1);
+
+ // Step 1a
+ re = /^(.+?)(ss|i)es$/;
+ re2 = /^(.+?)([^s])s$/;
+
+ if (re.test(w))
+ w = w.replace(re,"$1$2");
+ else if (re2.test(w))
+ w = w.replace(re2,"$1$2");
+
+ // Step 1b
+ re = /^(.+?)eed$/;
+ re2 = /^(.+?)(ed|ing)$/;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ re = new RegExp(mgr0);
+ if (re.test(fp[1])) {
+ re = /.$/;
+ w = w.replace(re,"");
+ }
+ }
+ else if (re2.test(w)) {
+ var fp = re2.exec(w);
+ stem = fp[1];
+ re2 = new RegExp(s_v);
+ if (re2.test(stem)) {
+ w = stem;
+ re2 = /(at|bl|iz)$/;
+ re3 = new RegExp("([^aeiouylsz])\\1$");
+ re4 = new RegExp("^" + C + v + "[^aeiouwxy]$");
+ if (re2.test(w))
+ w = w + "e";
+ else if (re3.test(w)) {
+ re = /.$/;
+ w = w.replace(re,"");
+ }
+ else if (re4.test(w))
+ w = w + "e";
+ }
+ }
+
+ // Step 1c
+ re = /^(.+?)y$/;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ stem = fp[1];
+ re = new RegExp(s_v);
+ if (re.test(stem))
+ w = stem + "i";
+ }
+
+ // Step 2
+ re = /^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ stem = fp[1];
+ suffix = fp[2];
+ re = new RegExp(mgr0);
+ if (re.test(stem))
+ w = stem + step2list[suffix];
+ }
+
+ // Step 3
+ re = /^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ stem = fp[1];
+ suffix = fp[2];
+ re = new RegExp(mgr0);
+ if (re.test(stem))
+ w = stem + step3list[suffix];
+ }
+
+ // Step 4
+ re = /^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/;
+ re2 = /^(.+?)(s|t)(ion)$/;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ stem = fp[1];
+ re = new RegExp(mgr1);
+ if (re.test(stem))
+ w = stem;
+ }
+ else if (re2.test(w)) {
+ var fp = re2.exec(w);
+ stem = fp[1] + fp[2];
+ re2 = new RegExp(mgr1);
+ if (re2.test(stem))
+ w = stem;
+ }
+
+ // Step 5
+ re = /^(.+?)e$/;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ stem = fp[1];
+ re = new RegExp(mgr1);
+ re2 = new RegExp(meq1);
+ re3 = new RegExp("^" + C + v + "[^aeiouwxy]$");
+ if (re.test(stem) || (re2.test(stem) && !(re3.test(stem))))
+ w = stem;
+ }
+ re = /ll$/;
+ re2 = new RegExp(mgr1);
+ if (re.test(w) && re2.test(w)) {
+ re = /.$/;
+ w = w.replace(re,"");
+ }
+
+ // and turn initial Y back to y
+ if (firstch == "y")
+ w = firstch.toLowerCase() + w.substr(1);
+ return w;
+ }
+}
+
+
+
+
+
+var splitChars = (function() {
+ var result = {};
+ var singles = [96, 180, 187, 191, 215, 247, 749, 885, 903, 907, 909, 930, 1014, 1648,
+ 1748, 1809, 2416, 2473, 2481, 2526, 2601, 2609, 2612, 2615, 2653, 2702,
+ 2706, 2729, 2737, 2740, 2857, 2865, 2868, 2910, 2928, 2948, 2961, 2971,
+ 2973, 3085, 3089, 3113, 3124, 3213, 3217, 3241, 3252, 3295, 3341, 3345,
+ 3369, 3506, 3516, 3633, 3715, 3721, 3736, 3744, 3748, 3750, 3756, 3761,
+ 3781, 3912, 4239, 4347, 4681, 4695, 4697, 4745, 4785, 4799, 4801, 4823,
+ 4881, 5760, 5901, 5997, 6313, 7405, 8024, 8026, 8028, 8030, 8117, 8125,
+ 8133, 8181, 8468, 8485, 8487, 8489, 8494, 8527, 11311, 11359, 11687, 11695,
+ 11703, 11711, 11719, 11727, 11735, 12448, 12539, 43010, 43014, 43019, 43587,
+ 43696, 43713, 64286, 64297, 64311, 64317, 64319, 64322, 64325, 65141];
+ var i, j, start, end;
+ for (i = 0; i < singles.length; i++) {
+ result[singles[i]] = true;
+ }
+ var ranges = [[0, 47], [58, 64], [91, 94], [123, 169], [171, 177], [182, 184], [706, 709],
+ [722, 735], [741, 747], [751, 879], [888, 889], [894, 901], [1154, 1161],
+ [1318, 1328], [1367, 1368], [1370, 1376], [1416, 1487], [1515, 1519], [1523, 1568],
+ [1611, 1631], [1642, 1645], [1750, 1764], [1767, 1773], [1789, 1790], [1792, 1807],
+ [1840, 1868], [1958, 1968], [1970, 1983], [2027, 2035], [2038, 2041], [2043, 2047],
+ [2070, 2073], [2075, 2083], [2085, 2087], [2089, 2307], [2362, 2364], [2366, 2383],
+ [2385, 2391], [2402, 2405], [2419, 2424], [2432, 2436], [2445, 2446], [2449, 2450],
+ [2483, 2485], [2490, 2492], [2494, 2509], [2511, 2523], [2530, 2533], [2546, 2547],
+ [2554, 2564], [2571, 2574], [2577, 2578], [2618, 2648], [2655, 2661], [2672, 2673],
+ [2677, 2692], [2746, 2748], [2750, 2767], [2769, 2783], [2786, 2789], [2800, 2820],
+ [2829, 2830], [2833, 2834], [2874, 2876], [2878, 2907], [2914, 2917], [2930, 2946],
+ [2955, 2957], [2966, 2968], [2976, 2978], [2981, 2983], [2987, 2989], [3002, 3023],
+ [3025, 3045], [3059, 3076], [3130, 3132], [3134, 3159], [3162, 3167], [3170, 3173],
+ [3184, 3191], [3199, 3204], [3258, 3260], [3262, 3293], [3298, 3301], [3312, 3332],
+ [3386, 3388], [3390, 3423], [3426, 3429], [3446, 3449], [3456, 3460], [3479, 3481],
+ [3518, 3519], [3527, 3584], [3636, 3647], [3655, 3663], [3674, 3712], [3717, 3718],
+ [3723, 3724], [3726, 3731], [3752, 3753], [3764, 3772], [3774, 3775], [3783, 3791],
+ [3802, 3803], [3806, 3839], [3841, 3871], [3892, 3903], [3949, 3975], [3980, 4095],
+ [4139, 4158], [4170, 4175], [4182, 4185], [4190, 4192], [4194, 4196], [4199, 4205],
+ [4209, 4212], [4226, 4237], [4250, 4255], [4294, 4303], [4349, 4351], [4686, 4687],
+ [4702, 4703], [4750, 4751], [4790, 4791], [4806, 4807], [4886, 4887], [4955, 4968],
+ [4989, 4991], [5008, 5023], [5109, 5120], [5741, 5742], [5787, 5791], [5867, 5869],
+ [5873, 5887], [5906, 5919], [5938, 5951], [5970, 5983], [6001, 6015], [6068, 6102],
+ [6104, 6107], [6109, 6111], [6122, 6127], [6138, 6159], [6170, 6175], [6264, 6271],
+ [6315, 6319], [6390, 6399], [6429, 6469], [6510, 6511], [6517, 6527], [6572, 6592],
+ [6600, 6607], [6619, 6655], [6679, 6687], [6741, 6783], [6794, 6799], [6810, 6822],
+ [6824, 6916], [6964, 6980], [6988, 6991], [7002, 7042], [7073, 7085], [7098, 7167],
+ [7204, 7231], [7242, 7244], [7294, 7400], [7410, 7423], [7616, 7679], [7958, 7959],
+ [7966, 7967], [8006, 8007], [8014, 8015], [8062, 8063], [8127, 8129], [8141, 8143],
+ [8148, 8149], [8156, 8159], [8173, 8177], [8189, 8303], [8306, 8307], [8314, 8318],
+ [8330, 8335], [8341, 8449], [8451, 8454], [8456, 8457], [8470, 8472], [8478, 8483],
+ [8506, 8507], [8512, 8516], [8522, 8525], [8586, 9311], [9372, 9449], [9472, 10101],
+ [10132, 11263], [11493, 11498], [11503, 11516], [11518, 11519], [11558, 11567],
+ [11622, 11630], [11632, 11647], [11671, 11679], [11743, 11822], [11824, 12292],
+ [12296, 12320], [12330, 12336], [12342, 12343], [12349, 12352], [12439, 12444],
+ [12544, 12548], [12590, 12592], [12687, 12689], [12694, 12703], [12728, 12783],
+ [12800, 12831], [12842, 12880], [12896, 12927], [12938, 12976], [12992, 13311],
+ [19894, 19967], [40908, 40959], [42125, 42191], [42238, 42239], [42509, 42511],
+ [42540, 42559], [42592, 42593], [42607, 42622], [42648, 42655], [42736, 42774],
+ [42784, 42785], [42889, 42890], [42893, 43002], [43043, 43055], [43062, 43071],
+ [43124, 43137], [43188, 43215], [43226, 43249], [43256, 43258], [43260, 43263],
+ [43302, 43311], [43335, 43359], [43389, 43395], [43443, 43470], [43482, 43519],
+ [43561, 43583], [43596, 43599], [43610, 43615], [43639, 43641], [43643, 43647],
+ [43698, 43700], [43703, 43704], [43710, 43711], [43715, 43738], [43742, 43967],
+ [44003, 44015], [44026, 44031], [55204, 55215], [55239, 55242], [55292, 55295],
+ [57344, 63743], [64046, 64047], [64110, 64111], [64218, 64255], [64263, 64274],
+ [64280, 64284], [64434, 64466], [64830, 64847], [64912, 64913], [64968, 65007],
+ [65020, 65135], [65277, 65295], [65306, 65312], [65339, 65344], [65371, 65381],
+ [65471, 65473], [65480, 65481], [65488, 65489], [65496, 65497]];
+ for (i = 0; i < ranges.length; i++) {
+ start = ranges[i][0];
+ end = ranges[i][1];
+ for (j = start; j <= end; j++) {
+ result[j] = true;
+ }
+ }
+ return result;
+})();
+
+function splitQuery(query) {
+ var result = [];
+ var start = -1;
+ for (var i = 0; i < query.length; i++) {
+ if (splitChars[query.charCodeAt(i)]) {
+ if (start !== -1) {
+ result.push(query.slice(start, i));
+ start = -1;
+ }
+ } else if (start === -1) {
+ start = i;
+ }
+ }
+ if (start !== -1) {
+ result.push(query.slice(start));
+ }
+ return result;
+}
+
+
diff --git a/docs/html/_static/minus.png b/docs/html/_static/minus.png
new file mode 100644
index 0000000..d96755f
--- /dev/null
+++ b/docs/html/_static/minus.png
Binary files differ
diff --git a/docs/html/_static/plus.png b/docs/html/_static/plus.png
new file mode 100644
index 0000000..7107cec
--- /dev/null
+++ b/docs/html/_static/plus.png
Binary files differ
diff --git a/docs/html/_static/pygments.css b/docs/html/_static/pygments.css
new file mode 100644
index 0000000..20c4814
--- /dev/null
+++ b/docs/html/_static/pygments.css
@@ -0,0 +1,69 @@
+.highlight .hll { background-color: #ffffcc }
+.highlight { background: #eeffcc; }
+.highlight .c { color: #408090; font-style: italic } /* Comment */
+.highlight .err { border: 1px solid #FF0000 } /* Error */
+.highlight .k { color: #007020; font-weight: bold } /* Keyword */
+.highlight .o { color: #666666 } /* Operator */
+.highlight .ch { color: #408090; font-style: italic } /* Comment.Hashbang */
+.highlight .cm { color: #408090; font-style: italic } /* Comment.Multiline */
+.highlight .cp { color: #007020 } /* Comment.Preproc */
+.highlight .cpf { color: #408090; font-style: italic } /* Comment.PreprocFile */
+.highlight .c1 { color: #408090; font-style: italic } /* Comment.Single */
+.highlight .cs { color: #408090; background-color: #fff0f0 } /* Comment.Special */
+.highlight .gd { color: #A00000 } /* Generic.Deleted */
+.highlight .ge { font-style: italic } /* Generic.Emph */
+.highlight .gr { color: #FF0000 } /* Generic.Error */
+.highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */
+.highlight .gi { color: #00A000 } /* Generic.Inserted */
+.highlight .go { color: #333333 } /* Generic.Output */
+.highlight .gp { color: #c65d09; font-weight: bold } /* Generic.Prompt */
+.highlight .gs { font-weight: bold } /* Generic.Strong */
+.highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
+.highlight .gt { color: #0044DD } /* Generic.Traceback */
+.highlight .kc { color: #007020; font-weight: bold } /* Keyword.Constant */
+.highlight .kd { color: #007020; font-weight: bold } /* Keyword.Declaration */
+.highlight .kn { color: #007020; font-weight: bold } /* Keyword.Namespace */
+.highlight .kp { color: #007020 } /* Keyword.Pseudo */
+.highlight .kr { color: #007020; font-weight: bold } /* Keyword.Reserved */
+.highlight .kt { color: #902000 } /* Keyword.Type */
+.highlight .m { color: #208050 } /* Literal.Number */
+.highlight .s { color: #4070a0 } /* Literal.String */
+.highlight .na { color: #4070a0 } /* Name.Attribute */
+.highlight .nb { color: #007020 } /* Name.Builtin */
+.highlight .nc { color: #0e84b5; font-weight: bold } /* Name.Class */
+.highlight .no { color: #60add5 } /* Name.Constant */
+.highlight .nd { color: #555555; font-weight: bold } /* Name.Decorator */
+.highlight .ni { color: #d55537; font-weight: bold } /* Name.Entity */
+.highlight .ne { color: #007020 } /* Name.Exception */
+.highlight .nf { color: #06287e } /* Name.Function */
+.highlight .nl { color: #002070; font-weight: bold } /* Name.Label */
+.highlight .nn { color: #0e84b5; font-weight: bold } /* Name.Namespace */
+.highlight .nt { color: #062873; font-weight: bold } /* Name.Tag */
+.highlight .nv { color: #bb60d5 } /* Name.Variable */
+.highlight .ow { color: #007020; font-weight: bold } /* Operator.Word */
+.highlight .w { color: #bbbbbb } /* Text.Whitespace */
+.highlight .mb { color: #208050 } /* Literal.Number.Bin */
+.highlight .mf { color: #208050 } /* Literal.Number.Float */
+.highlight .mh { color: #208050 } /* Literal.Number.Hex */
+.highlight .mi { color: #208050 } /* Literal.Number.Integer */
+.highlight .mo { color: #208050 } /* Literal.Number.Oct */
+.highlight .sa { color: #4070a0 } /* Literal.String.Affix */
+.highlight .sb { color: #4070a0 } /* Literal.String.Backtick */
+.highlight .sc { color: #4070a0 } /* Literal.String.Char */
+.highlight .dl { color: #4070a0 } /* Literal.String.Delimiter */
+.highlight .sd { color: #4070a0; font-style: italic } /* Literal.String.Doc */
+.highlight .s2 { color: #4070a0 } /* Literal.String.Double */
+.highlight .se { color: #4070a0; font-weight: bold } /* Literal.String.Escape */
+.highlight .sh { color: #4070a0 } /* Literal.String.Heredoc */
+.highlight .si { color: #70a0d0; font-style: italic } /* Literal.String.Interpol */
+.highlight .sx { color: #c65d09 } /* Literal.String.Other */
+.highlight .sr { color: #235388 } /* Literal.String.Regex */
+.highlight .s1 { color: #4070a0 } /* Literal.String.Single */
+.highlight .ss { color: #517918 } /* Literal.String.Symbol */
+.highlight .bp { color: #007020 } /* Name.Builtin.Pseudo */
+.highlight .fm { color: #06287e } /* Name.Function.Magic */
+.highlight .vc { color: #bb60d5 } /* Name.Variable.Class */
+.highlight .vg { color: #bb60d5 } /* Name.Variable.Global */
+.highlight .vi { color: #bb60d5 } /* Name.Variable.Instance */
+.highlight .vm { color: #bb60d5 } /* Name.Variable.Magic */
+.highlight .il { color: #208050 } /* Literal.Number.Integer.Long */
\ No newline at end of file
diff --git a/docs/html/_static/searchtools.js b/docs/html/_static/searchtools.js
new file mode 100644
index 0000000..5ff3180
--- /dev/null
+++ b/docs/html/_static/searchtools.js
@@ -0,0 +1,481 @@
+/*
+ * searchtools.js
+ * ~~~~~~~~~~~~~~~~
+ *
+ * Sphinx JavaScript utilities for the full-text search.
+ *
+ * :copyright: Copyright 2007-2019 by the Sphinx team, see AUTHORS.
+ * :license: BSD, see LICENSE for details.
+ *
+ */
+
+if (!Scorer) {
+ /**
+ * Simple result scoring code.
+ */
+ var Scorer = {
+ // Implement the following function to further tweak the score for each result
+ // The function takes a result array [filename, title, anchor, descr, score]
+ // and returns the new score.
+ /*
+ score: function(result) {
+ return result[4];
+ },
+ */
+
+ // query matches the full name of an object
+ objNameMatch: 11,
+ // or matches in the last dotted part of the object name
+ objPartialMatch: 6,
+ // Additive scores depending on the priority of the object
+ objPrio: {0: 15, // used to be importantResults
+ 1: 5, // used to be objectResults
+ 2: -5}, // used to be unimportantResults
+ // Used when the priority is not in the mapping.
+ objPrioDefault: 0,
+
+ // query found in title
+ title: 15,
+ // query found in terms
+ term: 5
+ };
+}
+
+if (!splitQuery) {
+ function splitQuery(query) {
+ return query.split(/\s+/);
+ }
+}
+
+/**
+ * Search Module
+ */
+var Search = {
+
+ _index : null,
+ _queued_query : null,
+ _pulse_status : -1,
+
+ init : function() {
+ var params = $.getQueryParameters();
+ if (params.q) {
+ var query = params.q[0];
+ $('input[name="q"]')[0].value = query;
+ this.performSearch(query);
+ }
+ },
+
+ loadIndex : function(url) {
+ $.ajax({type: "GET", url: url, data: null,
+ dataType: "script", cache: true,
+ complete: function(jqxhr, textstatus) {
+ if (textstatus != "success") {
+ document.getElementById("searchindexloader").src = url;
+ }
+ }});
+ },
+
+ setIndex : function(index) {
+ var q;
+ this._index = index;
+ if ((q = this._queued_query) !== null) {
+ this._queued_query = null;
+ Search.query(q);
+ }
+ },
+
+ hasIndex : function() {
+ return this._index !== null;
+ },
+
+ deferQuery : function(query) {
+ this._queued_query = query;
+ },
+
+ stopPulse : function() {
+ this._pulse_status = 0;
+ },
+
+ startPulse : function() {
+ if (this._pulse_status >= 0)
+ return;
+ function pulse() {
+ var i;
+ Search._pulse_status = (Search._pulse_status + 1) % 4;
+ var dotString = '';
+ for (i = 0; i < Search._pulse_status; i++)
+ dotString += '.';
+ Search.dots.text(dotString);
+ if (Search._pulse_status > -1)
+ window.setTimeout(pulse, 500);
+ }
+ pulse();
+ },
+
+ /**
+ * perform a search for something (or wait until index is loaded)
+ */
+ performSearch : function(query) {
+ // create the required interface elements
+ this.out = $('#search-results');
+ this.title = $('<h2>' + _('Searching') + '</h2>').appendTo(this.out);
+ this.dots = $('<span></span>').appendTo(this.title);
+ this.status = $('<p style="display: none"></p>').appendTo(this.out);
+ this.output = $('<ul class="search"/>').appendTo(this.out);
+
+ $('#search-progress').text(_('Preparing search...'));
+ this.startPulse();
+
+ // index already loaded, the browser was quick!
+ if (this.hasIndex())
+ this.query(query);
+ else
+ this.deferQuery(query);
+ },
+
+ /**
+ * execute search (requires search index to be loaded)
+ */
+ query : function(query) {
+ var i;
+
+ // stem the searchterms and add them to the correct list
+ var stemmer = new Stemmer();
+ var searchterms = [];
+ var excluded = [];
+ var hlterms = [];
+ var tmp = splitQuery(query);
+ var objectterms = [];
+ for (i = 0; i < tmp.length; i++) {
+ if (tmp[i] !== "") {
+ objectterms.push(tmp[i].toLowerCase());
+ }
+
+ if ($u.indexOf(stopwords, tmp[i].toLowerCase()) != -1 || tmp[i].match(/^\d+$/) ||
+ tmp[i] === "") {
+ // skip this "word"
+ continue;
+ }
+ // stem the word
+ var word = stemmer.stemWord(tmp[i].toLowerCase());
+ // prevent stemmer from cutting word smaller than two chars
+ if(word.length < 3 && tmp[i].length >= 3) {
+ word = tmp[i];
+ }
+ var toAppend;
+ // select the correct list
+ if (word[0] == '-') {
+ toAppend = excluded;
+ word = word.substr(1);
+ }
+ else {
+ toAppend = searchterms;
+ hlterms.push(tmp[i].toLowerCase());
+ }
+ // only add if not already in the list
+ if (!$u.contains(toAppend, word))
+ toAppend.push(word);
+ }
+ var highlightstring = '?highlight=' + $.urlencode(hlterms.join(" "));
+
+ // console.debug('SEARCH: searching for:');
+ // console.info('required: ', searchterms);
+ // console.info('excluded: ', excluded);
+
+ // prepare search
+ var terms = this._index.terms;
+ var titleterms = this._index.titleterms;
+
+ // array of [filename, title, anchor, descr, score]
+ var results = [];
+ $('#search-progress').empty();
+
+ // lookup as object
+ for (i = 0; i < objectterms.length; i++) {
+ var others = [].concat(objectterms.slice(0, i),
+ objectterms.slice(i+1, objectterms.length));
+ results = results.concat(this.performObjectSearch(objectterms[i], others));
+ }
+
+ // lookup as search terms in fulltext
+ results = results.concat(this.performTermsSearch(searchterms, excluded, terms, titleterms));
+
+ // let the scorer override scores with a custom scoring function
+ if (Scorer.score) {
+ for (i = 0; i < results.length; i++)
+ results[i][4] = Scorer.score(results[i]);
+ }
+
+ // now sort the results by score (in opposite order of appearance, since the
+ // display function below uses pop() to retrieve items) and then
+ // alphabetically
+ results.sort(function(a, b) {
+ var left = a[4];
+ var right = b[4];
+ if (left > right) {
+ return 1;
+ } else if (left < right) {
+ return -1;
+ } else {
+ // same score: sort alphabetically
+ left = a[1].toLowerCase();
+ right = b[1].toLowerCase();
+ return (left > right) ? -1 : ((left < right) ? 1 : 0);
+ }
+ });
+
+ // for debugging
+ //Search.lastresults = results.slice(); // a copy
+ //console.info('search results:', Search.lastresults);
+
+ // print the results
+ var resultCount = results.length;
+ function displayNextItem() {
+ // results left, load the summary and display it
+ if (results.length) {
+ var item = results.pop();
+ var listItem = $('<li style="display:none"></li>');
+ if (DOCUMENTATION_OPTIONS.FILE_SUFFIX === '') {
+ // dirhtml builder
+ var dirname = item[0] + '/';
+ if (dirname.match(/\/index\/$/)) {
+ dirname = dirname.substring(0, dirname.length-6);
+ } else if (dirname == 'index/') {
+ dirname = '';
+ }
+ listItem.append($('<a/>').attr('href',
+ DOCUMENTATION_OPTIONS.URL_ROOT + dirname +
+ highlightstring + item[2]).html(item[1]));
+ } else {
+ // normal html builders
+ listItem.append($('<a/>').attr('href',
+ item[0] + DOCUMENTATION_OPTIONS.FILE_SUFFIX +
+ highlightstring + item[2]).html(item[1]));
+ }
+ if (item[3]) {
+ listItem.append($('<span> (' + item[3] + ')</span>'));
+ Search.output.append(listItem);
+ listItem.slideDown(5, function() {
+ displayNextItem();
+ });
+ } else if (DOCUMENTATION_OPTIONS.HAS_SOURCE) {
+ var suffix = DOCUMENTATION_OPTIONS.SOURCELINK_SUFFIX;
+ if (suffix === undefined) {
+ suffix = '.txt';
+ }
+ $.ajax({url: DOCUMENTATION_OPTIONS.URL_ROOT + '_sources/' + item[5] + (item[5].slice(-suffix.length) === suffix ? '' : suffix),
+ dataType: "text",
+ complete: function(jqxhr, textstatus) {
+ var data = jqxhr.responseText;
+ if (data !== '' && data !== undefined) {
+ listItem.append(Search.makeSearchSummary(data, searchterms, hlterms));
+ }
+ Search.output.append(listItem);
+ listItem.slideDown(5, function() {
+ displayNextItem();
+ });
+ }});
+ } else {
+ // no source available, just display title
+ Search.output.append(listItem);
+ listItem.slideDown(5, function() {
+ displayNextItem();
+ });
+ }
+ }
+ // search finished, update title and status message
+ else {
+ Search.stopPulse();
+ Search.title.text(_('Search Results'));
+ if (!resultCount)
+ Search.status.text(_('Your search did not match any documents. Please make sure that all words are spelled correctly and that you\'ve selected enough categories.'));
+ else
+ Search.status.text(_('Search finished, found %s page(s) matching the search query.').replace('%s', resultCount));
+ Search.status.fadeIn(500);
+ }
+ }
+ displayNextItem();
+ },
+
+ /**
+ * search for object names
+ */
+ performObjectSearch : function(object, otherterms) {
+ var filenames = this._index.filenames;
+ var docnames = this._index.docnames;
+ var objects = this._index.objects;
+ var objnames = this._index.objnames;
+ var titles = this._index.titles;
+
+ var i;
+ var results = [];
+
+ for (var prefix in objects) {
+ for (var name in objects[prefix]) {
+ var fullname = (prefix ? prefix + '.' : '') + name;
+ if (fullname.toLowerCase().indexOf(object) > -1) {
+ var score = 0;
+ var parts = fullname.split('.');
+ // check for different match types: exact matches of full name or
+ // "last name" (i.e. last dotted part)
+ if (fullname == object || parts[parts.length - 1] == object) {
+ score += Scorer.objNameMatch;
+ // matches in last name
+ } else if (parts[parts.length - 1].indexOf(object) > -1) {
+ score += Scorer.objPartialMatch;
+ }
+ var match = objects[prefix][name];
+ var objname = objnames[match[1]][2];
+ var title = titles[match[0]];
+ // If more than one term searched for, we require other words to be
+ // found in the name/title/description
+ if (otherterms.length > 0) {
+ var haystack = (prefix + ' ' + name + ' ' +
+ objname + ' ' + title).toLowerCase();
+ var allfound = true;
+ for (i = 0; i < otherterms.length; i++) {
+ if (haystack.indexOf(otherterms[i]) == -1) {
+ allfound = false;
+ break;
+ }
+ }
+ if (!allfound) {
+ continue;
+ }
+ }
+ var descr = objname + _(', in ') + title;
+
+ var anchor = match[3];
+ if (anchor === '')
+ anchor = fullname;
+ else if (anchor == '-')
+ anchor = objnames[match[1]][1] + '-' + fullname;
+ // add custom score for some objects according to scorer
+ if (Scorer.objPrio.hasOwnProperty(match[2])) {
+ score += Scorer.objPrio[match[2]];
+ } else {
+ score += Scorer.objPrioDefault;
+ }
+ results.push([docnames[match[0]], fullname, '#'+anchor, descr, score, filenames[match[0]]]);
+ }
+ }
+ }
+
+ return results;
+ },
+
+ /**
+ * search for full-text terms in the index
+ */
+ performTermsSearch : function(searchterms, excluded, terms, titleterms) {
+ var docnames = this._index.docnames;
+ var filenames = this._index.filenames;
+ var titles = this._index.titles;
+
+ var i, j, file;
+ var fileMap = {};
+ var scoreMap = {};
+ var results = [];
+
+ // perform the search on the required terms
+ for (i = 0; i < searchterms.length; i++) {
+ var word = searchterms[i];
+ var files = [];
+ var _o = [
+ {files: terms[word], score: Scorer.term},
+ {files: titleterms[word], score: Scorer.title}
+ ];
+
+ // no match but word was a required one
+ if ($u.every(_o, function(o){return o.files === undefined;})) {
+ break;
+ }
+ // found search word in contents
+ $u.each(_o, function(o) {
+ var _files = o.files;
+ if (_files === undefined)
+ return
+
+ if (_files.length === undefined)
+ _files = [_files];
+ files = files.concat(_files);
+
+ // set score for the word in each file to Scorer.term
+ for (j = 0; j < _files.length; j++) {
+ file = _files[j];
+ if (!(file in scoreMap))
+ scoreMap[file] = {}
+ scoreMap[file][word] = o.score;
+ }
+ });
+
+ // create the mapping
+ for (j = 0; j < files.length; j++) {
+ file = files[j];
+ if (file in fileMap)
+ fileMap[file].push(word);
+ else
+ fileMap[file] = [word];
+ }
+ }
+
+ // now check if the files don't contain excluded terms
+ for (file in fileMap) {
+ var valid = true;
+
+ // check if all requirements are matched
+ if (fileMap[file].length != searchterms.length)
+ continue;
+
+ // ensure that none of the excluded terms is in the search result
+ for (i = 0; i < excluded.length; i++) {
+ if (terms[excluded[i]] == file ||
+ titleterms[excluded[i]] == file ||
+ $u.contains(terms[excluded[i]] || [], file) ||
+ $u.contains(titleterms[excluded[i]] || [], file)) {
+ valid = false;
+ break;
+ }
+ }
+
+ // if we have still a valid result we can add it to the result list
+ if (valid) {
+ // select one (max) score for the file.
+ // for better ranking, we should calculate ranking by using words statistics like basic tf-idf...
+ var score = $u.max($u.map(fileMap[file], function(w){return scoreMap[file][w]}));
+ results.push([docnames[file], titles[file], '', null, score, filenames[file]]);
+ }
+ }
+ return results;
+ },
+
+ /**
+ * helper function to return a node containing the
+ * search summary for a given text. keywords is a list
+ * of stemmed words, hlwords is the list of normal, unstemmed
+ * words. the first one is used to find the occurrence, the
+ * latter for highlighting it.
+ */
+ makeSearchSummary : function(text, keywords, hlwords) {
+ var textLower = text.toLowerCase();
+ var start = 0;
+ $.each(keywords, function() {
+ var i = textLower.indexOf(this.toLowerCase());
+ if (i > -1)
+ start = i;
+ });
+ start = Math.max(start - 120, 0);
+ var excerpt = ((start > 0) ? '...' : '') +
+ $.trim(text.substr(start, 240)) +
+ ((start + 240 - text.length) ? '...' : '');
+ var rv = $('<div class="context"></div>').text(excerpt);
+ $.each(hlwords, function() {
+ rv = rv.highlightText(this, 'highlighted');
+ });
+ return rv;
+ }
+};
+
+$(document).ready(function() {
+ Search.init();
+});
diff --git a/docs/html/_static/underscore-1.3.1.js b/docs/html/_static/underscore-1.3.1.js
new file mode 100644
index 0000000..208d4cd
--- /dev/null
+++ b/docs/html/_static/underscore-1.3.1.js
@@ -0,0 +1,999 @@
+// Underscore.js 1.3.1
+// (c) 2009-2012 Jeremy Ashkenas, DocumentCloud Inc.
+// Underscore is freely distributable under the MIT license.
+// Portions of Underscore are inspired or borrowed from Prototype,
+// Oliver Steele's Functional, and John Resig's Micro-Templating.
+// For all details and documentation:
+// http://documentcloud.github.com/underscore
+
+(function() {
+
+ // Baseline setup
+ // --------------
+
+ // Establish the root object, `window` in the browser, or `global` on the server.
+ var root = this;
+
+ // Save the previous value of the `_` variable.
+ var previousUnderscore = root._;
+
+ // Establish the object that gets returned to break out of a loop iteration.
+ var breaker = {};
+
+ // Save bytes in the minified (but not gzipped) version:
+ var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;
+
+ // Create quick reference variables for speed access to core prototypes.
+ var slice = ArrayProto.slice,
+ unshift = ArrayProto.unshift,
+ toString = ObjProto.toString,
+ hasOwnProperty = ObjProto.hasOwnProperty;
+
+ // All **ECMAScript 5** native function implementations that we hope to use
+ // are declared here.
+ var
+ nativeForEach = ArrayProto.forEach,
+ nativeMap = ArrayProto.map,
+ nativeReduce = ArrayProto.reduce,
+ nativeReduceRight = ArrayProto.reduceRight,
+ nativeFilter = ArrayProto.filter,
+ nativeEvery = ArrayProto.every,
+ nativeSome = ArrayProto.some,
+ nativeIndexOf = ArrayProto.indexOf,
+ nativeLastIndexOf = ArrayProto.lastIndexOf,
+ nativeIsArray = Array.isArray,
+ nativeKeys = Object.keys,
+ nativeBind = FuncProto.bind;
+
+ // Create a safe reference to the Underscore object for use below.
+ var _ = function(obj) { return new wrapper(obj); };
+
+ // Export the Underscore object for **Node.js**, with
+ // backwards-compatibility for the old `require()` API. If we're in
+ // the browser, add `_` as a global object via a string identifier,
+ // for Closure Compiler "advanced" mode.
+ if (typeof exports !== 'undefined') {
+ if (typeof module !== 'undefined' && module.exports) {
+ exports = module.exports = _;
+ }
+ exports._ = _;
+ } else {
+ root['_'] = _;
+ }
+
+ // Current version.
+ _.VERSION = '1.3.1';
+
+ // Collection Functions
+ // --------------------
+
+ // The cornerstone, an `each` implementation, aka `forEach`.
+ // Handles objects with the built-in `forEach`, arrays, and raw objects.
+ // Delegates to **ECMAScript 5**'s native `forEach` if available.
+ var each = _.each = _.forEach = function(obj, iterator, context) {
+ if (obj == null) return;
+ if (nativeForEach && obj.forEach === nativeForEach) {
+ obj.forEach(iterator, context);
+ } else if (obj.length === +obj.length) {
+ for (var i = 0, l = obj.length; i < l; i++) {
+ if (i in obj && iterator.call(context, obj[i], i, obj) === breaker) return;
+ }
+ } else {
+ for (var key in obj) {
+ if (_.has(obj, key)) {
+ if (iterator.call(context, obj[key], key, obj) === breaker) return;
+ }
+ }
+ }
+ };
+
+ // Return the results of applying the iterator to each element.
+ // Delegates to **ECMAScript 5**'s native `map` if available.
+ _.map = _.collect = function(obj, iterator, context) {
+ var results = [];
+ if (obj == null) return results;
+ if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);
+ each(obj, function(value, index, list) {
+ results[results.length] = iterator.call(context, value, index, list);
+ });
+ if (obj.length === +obj.length) results.length = obj.length;
+ return results;
+ };
+
+ // **Reduce** builds up a single result from a list of values, aka `inject`,
+ // or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available.
+ _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {
+ var initial = arguments.length > 2;
+ if (obj == null) obj = [];
+ if (nativeReduce && obj.reduce === nativeReduce) {
+ if (context) iterator = _.bind(iterator, context);
+ return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);
+ }
+ each(obj, function(value, index, list) {
+ if (!initial) {
+ memo = value;
+ initial = true;
+ } else {
+ memo = iterator.call(context, memo, value, index, list);
+ }
+ });
+ if (!initial) throw new TypeError('Reduce of empty array with no initial value');
+ return memo;
+ };
+
+ // The right-associative version of reduce, also known as `foldr`.
+ // Delegates to **ECMAScript 5**'s native `reduceRight` if available.
+ _.reduceRight = _.foldr = function(obj, iterator, memo, context) {
+ var initial = arguments.length > 2;
+ if (obj == null) obj = [];
+ if (nativeReduceRight && obj.reduceRight === nativeReduceRight) {
+ if (context) iterator = _.bind(iterator, context);
+ return initial ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);
+ }
+ var reversed = _.toArray(obj).reverse();
+ if (context && !initial) iterator = _.bind(iterator, context);
+ return initial ? _.reduce(reversed, iterator, memo, context) : _.reduce(reversed, iterator);
+ };
+
+ // Return the first value which passes a truth test. Aliased as `detect`.
+ _.find = _.detect = function(obj, iterator, context) {
+ var result;
+ any(obj, function(value, index, list) {
+ if (iterator.call(context, value, index, list)) {
+ result = value;
+ return true;
+ }
+ });
+ return result;
+ };
+
+ // Return all the elements that pass a truth test.
+ // Delegates to **ECMAScript 5**'s native `filter` if available.
+ // Aliased as `select`.
+ _.filter = _.select = function(obj, iterator, context) {
+ var results = [];
+ if (obj == null) return results;
+ if (nativeFilter && obj.filter === nativeFilter) return obj.filter(iterator, context);
+ each(obj, function(value, index, list) {
+ if (iterator.call(context, value, index, list)) results[results.length] = value;
+ });
+ return results;
+ };
+
+ // Return all the elements for which a truth test fails.
+ _.reject = function(obj, iterator, context) {
+ var results = [];
+ if (obj == null) return results;
+ each(obj, function(value, index, list) {
+ if (!iterator.call(context, value, index, list)) results[results.length] = value;
+ });
+ return results;
+ };
+
+ // Determine whether all of the elements match a truth test.
+ // Delegates to **ECMAScript 5**'s native `every` if available.
+ // Aliased as `all`.
+ _.every = _.all = function(obj, iterator, context) {
+ var result = true;
+ if (obj == null) return result;
+ if (nativeEvery && obj.every === nativeEvery) return obj.every(iterator, context);
+ each(obj, function(value, index, list) {
+ if (!(result = result && iterator.call(context, value, index, list))) return breaker;
+ });
+ return result;
+ };
+
+ // Determine if at least one element in the object matches a truth test.
+ // Delegates to **ECMAScript 5**'s native `some` if available.
+ // Aliased as `any`.
+ var any = _.some = _.any = function(obj, iterator, context) {
+ iterator || (iterator = _.identity);
+ var result = false;
+ if (obj == null) return result;
+ if (nativeSome && obj.some === nativeSome) return obj.some(iterator, context);
+ each(obj, function(value, index, list) {
+ if (result || (result = iterator.call(context, value, index, list))) return breaker;
+ });
+ return !!result;
+ };
+
+ // Determine if a given value is included in the array or object using `===`.
+ // Aliased as `contains`.
+ _.include = _.contains = function(obj, target) {
+ var found = false;
+ if (obj == null) return found;
+ if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;
+ found = any(obj, function(value) {
+ return value === target;
+ });
+ return found;
+ };
+
+ // Invoke a method (with arguments) on every item in a collection.
+ _.invoke = function(obj, method) {
+ var args = slice.call(arguments, 2);
+ return _.map(obj, function(value) {
+ return (_.isFunction(method) ? method || value : value[method]).apply(value, args);
+ });
+ };
+
+ // Convenience version of a common use case of `map`: fetching a property.
+ _.pluck = function(obj, key) {
+ return _.map(obj, function(value){ return value[key]; });
+ };
+
+ // Return the maximum element or (element-based computation).
+ _.max = function(obj, iterator, context) {
+ if (!iterator && _.isArray(obj)) return Math.max.apply(Math, obj);
+ if (!iterator && _.isEmpty(obj)) return -Infinity;
+ var result = {computed : -Infinity};
+ each(obj, function(value, index, list) {
+ var computed = iterator ? iterator.call(context, value, index, list) : value;
+ computed >= result.computed && (result = {value : value, computed : computed});
+ });
+ return result.value;
+ };
+
+ // Return the minimum element (or element-based computation).
+ _.min = function(obj, iterator, context) {
+ if (!iterator && _.isArray(obj)) return Math.min.apply(Math, obj);
+ if (!iterator && _.isEmpty(obj)) return Infinity;
+ var result = {computed : Infinity};
+ each(obj, function(value, index, list) {
+ var computed = iterator ? iterator.call(context, value, index, list) : value;
+ computed < result.computed && (result = {value : value, computed : computed});
+ });
+ return result.value;
+ };
+
+ // Shuffle an array.
+ _.shuffle = function(obj) {
+ var shuffled = [], rand;
+ each(obj, function(value, index, list) {
+ if (index == 0) {
+ shuffled[0] = value;
+ } else {
+ rand = Math.floor(Math.random() * (index + 1));
+ shuffled[index] = shuffled[rand];
+ shuffled[rand] = value;
+ }
+ });
+ return shuffled;
+ };
+
+ // Sort the object's values by a criterion produced by an iterator.
+ _.sortBy = function(obj, iterator, context) {
+ return _.pluck(_.map(obj, function(value, index, list) {
+ return {
+ value : value,
+ criteria : iterator.call(context, value, index, list)
+ };
+ }).sort(function(left, right) {
+ var a = left.criteria, b = right.criteria;
+ return a < b ? -1 : a > b ? 1 : 0;
+ }), 'value');
+ };
+
+ // Groups the object's values by a criterion. Pass either a string attribute
+ // to group by, or a function that returns the criterion.
+ _.groupBy = function(obj, val) {
+ var result = {};
+ var iterator = _.isFunction(val) ? val : function(obj) { return obj[val]; };
+ each(obj, function(value, index) {
+ var key = iterator(value, index);
+ (result[key] || (result[key] = [])).push(value);
+ });
+ return result;
+ };
+
+ // Use a comparator function to figure out at what index an object should
+ // be inserted so as to maintain order. Uses binary search.
+ _.sortedIndex = function(array, obj, iterator) {
+ iterator || (iterator = _.identity);
+ var low = 0, high = array.length;
+ while (low < high) {
+ var mid = (low + high) >> 1;
+ iterator(array[mid]) < iterator(obj) ? low = mid + 1 : high = mid;
+ }
+ return low;
+ };
+
+ // Safely convert anything iterable into a real, live array.
+ _.toArray = function(iterable) {
+ if (!iterable) return [];
+ if (iterable.toArray) return iterable.toArray();
+ if (_.isArray(iterable)) return slice.call(iterable);
+ if (_.isArguments(iterable)) return slice.call(iterable);
+ return _.values(iterable);
+ };
+
+ // Return the number of elements in an object.
+ _.size = function(obj) {
+ return _.toArray(obj).length;
+ };
+
+ // Array Functions
+ // ---------------
+
+ // Get the first element of an array. Passing **n** will return the first N
+ // values in the array. Aliased as `head`. The **guard** check allows it to work
+ // with `_.map`.
+ _.first = _.head = function(array, n, guard) {
+ return (n != null) && !guard ? slice.call(array, 0, n) : array[0];
+ };
+
+ // Returns everything but the last entry of the array. Especcialy useful on
+ // the arguments object. Passing **n** will return all the values in
+ // the array, excluding the last N. The **guard** check allows it to work with
+ // `_.map`.
+ _.initial = function(array, n, guard) {
+ return slice.call(array, 0, array.length - ((n == null) || guard ? 1 : n));
+ };
+
+ // Get the last element of an array. Passing **n** will return the last N
+ // values in the array. The **guard** check allows it to work with `_.map`.
+ _.last = function(array, n, guard) {
+ if ((n != null) && !guard) {
+ return slice.call(array, Math.max(array.length - n, 0));
+ } else {
+ return array[array.length - 1];
+ }
+ };
+
+ // Returns everything but the first entry of the array. Aliased as `tail`.
+ // Especially useful on the arguments object. Passing an **index** will return
+ // the rest of the values in the array from that index onward. The **guard**
+ // check allows it to work with `_.map`.
+ _.rest = _.tail = function(array, index, guard) {
+ return slice.call(array, (index == null) || guard ? 1 : index);
+ };
+
+ // Trim out all falsy values from an array.
+ _.compact = function(array) {
+ return _.filter(array, function(value){ return !!value; });
+ };
+
+ // Return a completely flattened version of an array.
+ _.flatten = function(array, shallow) {
+ return _.reduce(array, function(memo, value) {
+ if (_.isArray(value)) return memo.concat(shallow ? value : _.flatten(value));
+ memo[memo.length] = value;
+ return memo;
+ }, []);
+ };
+
+ // Return a version of the array that does not contain the specified value(s).
+ _.without = function(array) {
+ return _.difference(array, slice.call(arguments, 1));
+ };
+
+ // Produce a duplicate-free version of the array. If the array has already
+ // been sorted, you have the option of using a faster algorithm.
+ // Aliased as `unique`.
+ _.uniq = _.unique = function(array, isSorted, iterator) {
+ var initial = iterator ? _.map(array, iterator) : array;
+ var result = [];
+ _.reduce(initial, function(memo, el, i) {
+ if (0 == i || (isSorted === true ? _.last(memo) != el : !_.include(memo, el))) {
+ memo[memo.length] = el;
+ result[result.length] = array[i];
+ }
+ return memo;
+ }, []);
+ return result;
+ };
+
+ // Produce an array that contains the union: each distinct element from all of
+ // the passed-in arrays.
+ _.union = function() {
+ return _.uniq(_.flatten(arguments, true));
+ };
+
+ // Produce an array that contains every item shared between all the
+ // passed-in arrays. (Aliased as "intersect" for back-compat.)
+ _.intersection = _.intersect = function(array) {
+ var rest = slice.call(arguments, 1);
+ return _.filter(_.uniq(array), function(item) {
+ return _.every(rest, function(other) {
+ return _.indexOf(other, item) >= 0;
+ });
+ });
+ };
+
+ // Take the difference between one array and a number of other arrays.
+ // Only the elements present in just the first array will remain.
+ _.difference = function(array) {
+ var rest = _.flatten(slice.call(arguments, 1));
+ return _.filter(array, function(value){ return !_.include(rest, value); });
+ };
+
+ // Zip together multiple lists into a single array -- elements that share
+ // an index go together.
+ _.zip = function() {
+ var args = slice.call(arguments);
+ var length = _.max(_.pluck(args, 'length'));
+ var results = new Array(length);
+ for (var i = 0; i < length; i++) results[i] = _.pluck(args, "" + i);
+ return results;
+ };
+
+ // If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**),
+ // we need this function. Return the position of the first occurrence of an
+ // item in an array, or -1 if the item is not included in the array.
+ // Delegates to **ECMAScript 5**'s native `indexOf` if available.
+ // If the array is large and already in sort order, pass `true`
+ // for **isSorted** to use binary search.
+ _.indexOf = function(array, item, isSorted) {
+ if (array == null) return -1;
+ var i, l;
+ if (isSorted) {
+ i = _.sortedIndex(array, item);
+ return array[i] === item ? i : -1;
+ }
+ if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item);
+ for (i = 0, l = array.length; i < l; i++) if (i in array && array[i] === item) return i;
+ return -1;
+ };
+
+ // Delegates to **ECMAScript 5**'s native `lastIndexOf` if available.
+ _.lastIndexOf = function(array, item) {
+ if (array == null) return -1;
+ if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) return array.lastIndexOf(item);
+ var i = array.length;
+ while (i--) if (i in array && array[i] === item) return i;
+ return -1;
+ };
+
+ // Generate an integer Array containing an arithmetic progression. A port of
+ // the native Python `range()` function. See
+ // [the Python documentation](http://docs.python.org/library/functions.html#range).
+ _.range = function(start, stop, step) {
+ if (arguments.length <= 1) {
+ stop = start || 0;
+ start = 0;
+ }
+ step = arguments[2] || 1;
+
+ var len = Math.max(Math.ceil((stop - start) / step), 0);
+ var idx = 0;
+ var range = new Array(len);
+
+ while(idx < len) {
+ range[idx++] = start;
+ start += step;
+ }
+
+ return range;
+ };
+
+ // Function (ahem) Functions
+ // ------------------
+
+ // Reusable constructor function for prototype setting.
+ var ctor = function(){};
+
+ // Create a function bound to a given object (assigning `this`, and arguments,
+ // optionally). Binding with arguments is also known as `curry`.
+ // Delegates to **ECMAScript 5**'s native `Function.bind` if available.
+ // We check for `func.bind` first, to fail fast when `func` is undefined.
+ _.bind = function bind(func, context) {
+ var bound, args;
+ if (func.bind === nativeBind && nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
+ if (!_.isFunction(func)) throw new TypeError;
+ args = slice.call(arguments, 2);
+ return bound = function() {
+ if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments)));
+ ctor.prototype = func.prototype;
+ var self = new ctor;
+ var result = func.apply(self, args.concat(slice.call(arguments)));
+ if (Object(result) === result) return result;
+ return self;
+ };
+ };
+
+ // Bind all of an object's methods to that object. Useful for ensuring that
+ // all callbacks defined on an object belong to it.
+ _.bindAll = function(obj) {
+ var funcs = slice.call(arguments, 1);
+ if (funcs.length == 0) funcs = _.functions(obj);
+ each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); });
+ return obj;
+ };
+
+ // Memoize an expensive function by storing its results.
+ _.memoize = function(func, hasher) {
+ var memo = {};
+ hasher || (hasher = _.identity);
+ return function() {
+ var key = hasher.apply(this, arguments);
+ return _.has(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments));
+ };
+ };
+
+ // Delays a function for the given number of milliseconds, and then calls
+ // it with the arguments supplied.
+ _.delay = function(func, wait) {
+ var args = slice.call(arguments, 2);
+ return setTimeout(function(){ return func.apply(func, args); }, wait);
+ };
+
+ // Defers a function, scheduling it to run after the current call stack has
+ // cleared.
+ _.defer = function(func) {
+ return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));
+ };
+
+ // Returns a function, that, when invoked, will only be triggered at most once
+ // during a given window of time.
+ _.throttle = function(func, wait) {
+ var context, args, timeout, throttling, more;
+ var whenDone = _.debounce(function(){ more = throttling = false; }, wait);
+ return function() {
+ context = this; args = arguments;
+ var later = function() {
+ timeout = null;
+ if (more) func.apply(context, args);
+ whenDone();
+ };
+ if (!timeout) timeout = setTimeout(later, wait);
+ if (throttling) {
+ more = true;
+ } else {
+ func.apply(context, args);
+ }
+ whenDone();
+ throttling = true;
+ };
+ };
+
+ // Returns a function, that, as long as it continues to be invoked, will not
+ // be triggered. The function will be called after it stops being called for
+ // N milliseconds.
+ _.debounce = function(func, wait) {
+ var timeout;
+ return function() {
+ var context = this, args = arguments;
+ var later = function() {
+ timeout = null;
+ func.apply(context, args);
+ };
+ clearTimeout(timeout);
+ timeout = setTimeout(later, wait);
+ };
+ };
+
+ // Returns a function that will be executed at most one time, no matter how
+ // often you call it. Useful for lazy initialization.
+ _.once = function(func) {
+ var ran = false, memo;
+ return function() {
+ if (ran) return memo;
+ ran = true;
+ return memo = func.apply(this, arguments);
+ };
+ };
+
+ // Returns the first function passed as an argument to the second,
+ // allowing you to adjust arguments, run code before and after, and
+ // conditionally execute the original function.
+ _.wrap = function(func, wrapper) {
+ return function() {
+ var args = [func].concat(slice.call(arguments, 0));
+ return wrapper.apply(this, args);
+ };
+ };
+
+ // Returns a function that is the composition of a list of functions, each
+ // consuming the return value of the function that follows.
+ _.compose = function() {
+ var funcs = arguments;
+ return function() {
+ var args = arguments;
+ for (var i = funcs.length - 1; i >= 0; i--) {
+ args = [funcs[i].apply(this, args)];
+ }
+ return args[0];
+ };
+ };
+
+ // Returns a function that will only be executed after being called N times.
+ _.after = function(times, func) {
+ if (times <= 0) return func();
+ return function() {
+ if (--times < 1) { return func.apply(this, arguments); }
+ };
+ };
+
+ // Object Functions
+ // ----------------
+
+ // Retrieve the names of an object's properties.
+ // Delegates to **ECMAScript 5**'s native `Object.keys`
+ _.keys = nativeKeys || function(obj) {
+ if (obj !== Object(obj)) throw new TypeError('Invalid object');
+ var keys = [];
+ for (var key in obj) if (_.has(obj, key)) keys[keys.length] = key;
+ return keys;
+ };
+
+ // Retrieve the values of an object's properties.
+ _.values = function(obj) {
+ return _.map(obj, _.identity);
+ };
+
+ // Return a sorted list of the function names available on the object.
+ // Aliased as `methods`
+ _.functions = _.methods = function(obj) {
+ var names = [];
+ for (var key in obj) {
+ if (_.isFunction(obj[key])) names.push(key);
+ }
+ return names.sort();
+ };
+
+ // Extend a given object with all the properties in passed-in object(s).
+ _.extend = function(obj) {
+ each(slice.call(arguments, 1), function(source) {
+ for (var prop in source) {
+ obj[prop] = source[prop];
+ }
+ });
+ return obj;
+ };
+
+ // Fill in a given object with default properties.
+ _.defaults = function(obj) {
+ each(slice.call(arguments, 1), function(source) {
+ for (var prop in source) {
+ if (obj[prop] == null) obj[prop] = source[prop];
+ }
+ });
+ return obj;
+ };
+
+ // Create a (shallow-cloned) duplicate of an object.
+ _.clone = function(obj) {
+ if (!_.isObject(obj)) return obj;
+ return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
+ };
+
+ // Invokes interceptor with the obj, and then returns obj.
+ // The primary purpose of this method is to "tap into" a method chain, in
+ // order to perform operations on intermediate results within the chain.
+ _.tap = function(obj, interceptor) {
+ interceptor(obj);
+ return obj;
+ };
+
+ // Internal recursive comparison function.
+ function eq(a, b, stack) {
+ // Identical objects are equal. `0 === -0`, but they aren't identical.
+ // See the Harmony `egal` proposal: http://wiki.ecmascript.org/doku.php?id=harmony:egal.
+ if (a === b) return a !== 0 || 1 / a == 1 / b;
+ // A strict comparison is necessary because `null == undefined`.
+ if (a == null || b == null) return a === b;
+ // Unwrap any wrapped objects.
+ if (a._chain) a = a._wrapped;
+ if (b._chain) b = b._wrapped;
+ // Invoke a custom `isEqual` method if one is provided.
+ if (a.isEqual && _.isFunction(a.isEqual)) return a.isEqual(b);
+ if (b.isEqual && _.isFunction(b.isEqual)) return b.isEqual(a);
+ // Compare `[[Class]]` names.
+ var className = toString.call(a);
+ if (className != toString.call(b)) return false;
+ switch (className) {
+ // Strings, numbers, dates, and booleans are compared by value.
+ case '[object String]':
+ // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
+ // equivalent to `new String("5")`.
+ return a == String(b);
+ case '[object Number]':
+ // `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for
+ // other numeric values.
+ return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b);
+ case '[object Date]':
+ case '[object Boolean]':
+ // Coerce dates and booleans to numeric primitive values. Dates are compared by their
+ // millisecond representations. Note that invalid dates with millisecond representations
+ // of `NaN` are not equivalent.
+ return +a == +b;
+ // RegExps are compared by their source patterns and flags.
+ case '[object RegExp]':
+ return a.source == b.source &&
+ a.global == b.global &&
+ a.multiline == b.multiline &&
+ a.ignoreCase == b.ignoreCase;
+ }
+ if (typeof a != 'object' || typeof b != 'object') return false;
+ // Assume equality for cyclic structures. The algorithm for detecting cyclic
+ // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
+ var length = stack.length;
+ while (length--) {
+ // Linear search. Performance is inversely proportional to the number of
+ // unique nested structures.
+ if (stack[length] == a) return true;
+ }
+ // Add the first object to the stack of traversed objects.
+ stack.push(a);
+ var size = 0, result = true;
+ // Recursively compare objects and arrays.
+ if (className == '[object Array]') {
+ // Compare array lengths to determine if a deep comparison is necessary.
+ size = a.length;
+ result = size == b.length;
+ if (result) {
+ // Deep compare the contents, ignoring non-numeric properties.
+ while (size--) {
+ // Ensure commutative equality for sparse arrays.
+ if (!(result = size in a == size in b && eq(a[size], b[size], stack))) break;
+ }
+ }
+ } else {
+ // Objects with different constructors are not equivalent.
+ if ('constructor' in a != 'constructor' in b || a.constructor != b.constructor) return false;
+ // Deep compare objects.
+ for (var key in a) {
+ if (_.has(a, key)) {
+ // Count the expected number of properties.
+ size++;
+ // Deep compare each member.
+ if (!(result = _.has(b, key) && eq(a[key], b[key], stack))) break;
+ }
+ }
+ // Ensure that both objects contain the same number of properties.
+ if (result) {
+ for (key in b) {
+ if (_.has(b, key) && !(size--)) break;
+ }
+ result = !size;
+ }
+ }
+ // Remove the first object from the stack of traversed objects.
+ stack.pop();
+ return result;
+ }
+
+ // Perform a deep comparison to check if two objects are equal.
+ _.isEqual = function(a, b) {
+ return eq(a, b, []);
+ };
+
+ // Is a given array, string, or object empty?
+ // An "empty" object has no enumerable own-properties.
+ _.isEmpty = function(obj) {
+ if (_.isArray(obj) || _.isString(obj)) return obj.length === 0;
+ for (var key in obj) if (_.has(obj, key)) return false;
+ return true;
+ };
+
+ // Is a given value a DOM element?
+ _.isElement = function(obj) {
+ return !!(obj && obj.nodeType == 1);
+ };
+
+ // Is a given value an array?
+ // Delegates to ECMA5's native Array.isArray
+ _.isArray = nativeIsArray || function(obj) {
+ return toString.call(obj) == '[object Array]';
+ };
+
+ // Is a given variable an object?
+ _.isObject = function(obj) {
+ return obj === Object(obj);
+ };
+
+ // Is a given variable an arguments object?
+ _.isArguments = function(obj) {
+ return toString.call(obj) == '[object Arguments]';
+ };
+ if (!_.isArguments(arguments)) {
+ _.isArguments = function(obj) {
+ return !!(obj && _.has(obj, 'callee'));
+ };
+ }
+
+ // Is a given value a function?
+ _.isFunction = function(obj) {
+ return toString.call(obj) == '[object Function]';
+ };
+
+ // Is a given value a string?
+ _.isString = function(obj) {
+ return toString.call(obj) == '[object String]';
+ };
+
+ // Is a given value a number?
+ _.isNumber = function(obj) {
+ return toString.call(obj) == '[object Number]';
+ };
+
+ // Is the given value `NaN`?
+ _.isNaN = function(obj) {
+ // `NaN` is the only value for which `===` is not reflexive.
+ return obj !== obj;
+ };
+
+ // Is a given value a boolean?
+ _.isBoolean = function(obj) {
+ return obj === true || obj === false || toString.call(obj) == '[object Boolean]';
+ };
+
+ // Is a given value a date?
+ _.isDate = function(obj) {
+ return toString.call(obj) == '[object Date]';
+ };
+
+ // Is the given value a regular expression?
+ _.isRegExp = function(obj) {
+ return toString.call(obj) == '[object RegExp]';
+ };
+
+ // Is a given value equal to null?
+ _.isNull = function(obj) {
+ return obj === null;
+ };
+
+ // Is a given variable undefined?
+ _.isUndefined = function(obj) {
+ return obj === void 0;
+ };
+
+ // Has own property?
+ _.has = function(obj, key) {
+ return hasOwnProperty.call(obj, key);
+ };
+
+ // Utility Functions
+ // -----------------
+
+ // Run Underscore.js in *noConflict* mode, returning the `_` variable to its
+ // previous owner. Returns a reference to the Underscore object.
+ _.noConflict = function() {
+ root._ = previousUnderscore;
+ return this;
+ };
+
+ // Keep the identity function around for default iterators.
+ _.identity = function(value) {
+ return value;
+ };
+
+ // Run a function **n** times.
+ _.times = function (n, iterator, context) {
+ for (var i = 0; i < n; i++) iterator.call(context, i);
+ };
+
+ // Escape a string for HTML interpolation.
+ _.escape = function(string) {
+ return (''+string).replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>').replace(/"/g, '"').replace(/'/g, ''').replace(/\//g,'/');
+ };
+
+ // Add your own custom functions to the Underscore object, ensuring that
+ // they're correctly added to the OOP wrapper as well.
+ _.mixin = function(obj) {
+ each(_.functions(obj), function(name){
+ addToWrapper(name, _[name] = obj[name]);
+ });
+ };
+
+ // Generate a unique integer id (unique within the entire client session).
+ // Useful for temporary DOM ids.
+ var idCounter = 0;
+ _.uniqueId = function(prefix) {
+ var id = idCounter++;
+ return prefix ? prefix + id : id;
+ };
+
+ // By default, Underscore uses ERB-style template delimiters, change the
+ // following template settings to use alternative delimiters.
+ _.templateSettings = {
+ evaluate : /<%([\s\S]+?)%>/g,
+ interpolate : /<%=([\s\S]+?)%>/g,
+ escape : /<%-([\s\S]+?)%>/g
+ };
+
+ // When customizing `templateSettings`, if you don't want to define an
+ // interpolation, evaluation or escaping regex, we need one that is
+ // guaranteed not to match.
+ var noMatch = /.^/;
+
+ // Within an interpolation, evaluation, or escaping, remove HTML escaping
+ // that had been previously added.
+ var unescape = function(code) {
+ return code.replace(/\\\\/g, '\\').replace(/\\'/g, "'");
+ };
+
+ // JavaScript micro-templating, similar to John Resig's implementation.
+ // Underscore templating handles arbitrary delimiters, preserves whitespace,
+ // and correctly escapes quotes within interpolated code.
+ _.template = function(str, data) {
+ var c = _.templateSettings;
+ var tmpl = 'var __p=[],print=function(){__p.push.apply(__p,arguments);};' +
+ 'with(obj||{}){__p.push(\'' +
+ str.replace(/\\/g, '\\\\')
+ .replace(/'/g, "\\'")
+ .replace(c.escape || noMatch, function(match, code) {
+ return "',_.escape(" + unescape(code) + "),'";
+ })
+ .replace(c.interpolate || noMatch, function(match, code) {
+ return "'," + unescape(code) + ",'";
+ })
+ .replace(c.evaluate || noMatch, function(match, code) {
+ return "');" + unescape(code).replace(/[\r\n\t]/g, ' ') + ";__p.push('";
+ })
+ .replace(/\r/g, '\\r')
+ .replace(/\n/g, '\\n')
+ .replace(/\t/g, '\\t')
+ + "');}return __p.join('');";
+ var func = new Function('obj', '_', tmpl);
+ if (data) return func(data, _);
+ return function(data) {
+ return func.call(this, data, _);
+ };
+ };
+
+ // Add a "chain" function, which will delegate to the wrapper.
+ _.chain = function(obj) {
+ return _(obj).chain();
+ };
+
+ // The OOP Wrapper
+ // ---------------
+
+ // If Underscore is called as a function, it returns a wrapped object that
+ // can be used OO-style. This wrapper holds altered versions of all the
+ // underscore functions. Wrapped objects may be chained.
+ var wrapper = function(obj) { this._wrapped = obj; };
+
+ // Expose `wrapper.prototype` as `_.prototype`
+ _.prototype = wrapper.prototype;
+
+ // Helper function to continue chaining intermediate results.
+ var result = function(obj, chain) {
+ return chain ? _(obj).chain() : obj;
+ };
+
+ // A method to easily add functions to the OOP wrapper.
+ var addToWrapper = function(name, func) {
+ wrapper.prototype[name] = function() {
+ var args = slice.call(arguments);
+ unshift.call(args, this._wrapped);
+ return result(func.apply(_, args), this._chain);
+ };
+ };
+
+ // Add all of the Underscore functions to the wrapper object.
+ _.mixin(_);
+
+ // Add all mutator Array functions to the wrapper.
+ each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
+ var method = ArrayProto[name];
+ wrapper.prototype[name] = function() {
+ var wrapped = this._wrapped;
+ method.apply(wrapped, arguments);
+ var length = wrapped.length;
+ if ((name == 'shift' || name == 'splice') && length === 0) delete wrapped[0];
+ return result(wrapped, this._chain);
+ };
+ });
+
+ // Add all accessor Array functions to the wrapper.
+ each(['concat', 'join', 'slice'], function(name) {
+ var method = ArrayProto[name];
+ wrapper.prototype[name] = function() {
+ return result(method.apply(this._wrapped, arguments), this._chain);
+ };
+ });
+
+ // Start chaining a wrapped Underscore object.
+ wrapper.prototype.chain = function() {
+ this._chain = true;
+ return this;
+ };
+
+ // Extracts the result from a wrapped and chained object.
+ wrapper.prototype.value = function() {
+ return this._wrapped;
+ };
+
+}).call(this);
diff --git a/docs/html/_static/underscore.js b/docs/html/_static/underscore.js
new file mode 100644
index 0000000..5b55f32
--- /dev/null
+++ b/docs/html/_static/underscore.js
@@ -0,0 +1,31 @@
+// Underscore.js 1.3.1
+// (c) 2009-2012 Jeremy Ashkenas, DocumentCloud Inc.
+// Underscore is freely distributable under the MIT license.
+// Portions of Underscore are inspired or borrowed from Prototype,
+// Oliver Steele's Functional, and John Resig's Micro-Templating.
+// For all details and documentation:
+// http://documentcloud.github.com/underscore
+(function(){function q(a,c,d){if(a===c)return a!==0||1/a==1/c;if(a==null||c==null)return a===c;if(a._chain)a=a._wrapped;if(c._chain)c=c._wrapped;if(a.isEqual&&b.isFunction(a.isEqual))return a.isEqual(c);if(c.isEqual&&b.isFunction(c.isEqual))return c.isEqual(a);var e=l.call(a);if(e!=l.call(c))return false;switch(e){case "[object String]":return a==String(c);case "[object Number]":return a!=+a?c!=+c:a==0?1/a==1/c:a==+c;case "[object Date]":case "[object Boolean]":return+a==+c;case "[object RegExp]":return a.source==
+c.source&&a.global==c.global&&a.multiline==c.multiline&&a.ignoreCase==c.ignoreCase}if(typeof a!="object"||typeof c!="object")return false;for(var f=d.length;f--;)if(d[f]==a)return true;d.push(a);var f=0,g=true;if(e=="[object Array]"){if(f=a.length,g=f==c.length)for(;f--;)if(!(g=f in a==f in c&&q(a[f],c[f],d)))break}else{if("constructor"in a!="constructor"in c||a.constructor!=c.constructor)return false;for(var h in a)if(b.has(a,h)&&(f++,!(g=b.has(c,h)&&q(a[h],c[h],d))))break;if(g){for(h in c)if(b.has(c,
+h)&&!f--)break;g=!f}}d.pop();return g}var r=this,G=r._,n={},k=Array.prototype,o=Object.prototype,i=k.slice,H=k.unshift,l=o.toString,I=o.hasOwnProperty,w=k.forEach,x=k.map,y=k.reduce,z=k.reduceRight,A=k.filter,B=k.every,C=k.some,p=k.indexOf,D=k.lastIndexOf,o=Array.isArray,J=Object.keys,s=Function.prototype.bind,b=function(a){return new m(a)};if(typeof exports!=="undefined"){if(typeof module!=="undefined"&&module.exports)exports=module.exports=b;exports._=b}else r._=b;b.VERSION="1.3.1";var j=b.each=
+b.forEach=function(a,c,d){if(a!=null)if(w&&a.forEach===w)a.forEach(c,d);else if(a.length===+a.length)for(var e=0,f=a.length;e<f;e++){if(e in a&&c.call(d,a[e],e,a)===n)break}else for(e in a)if(b.has(a,e)&&c.call(d,a[e],e,a)===n)break};b.map=b.collect=function(a,c,b){var e=[];if(a==null)return e;if(x&&a.map===x)return a.map(c,b);j(a,function(a,g,h){e[e.length]=c.call(b,a,g,h)});if(a.length===+a.length)e.length=a.length;return e};b.reduce=b.foldl=b.inject=function(a,c,d,e){var f=arguments.length>2;a==
+null&&(a=[]);if(y&&a.reduce===y)return e&&(c=b.bind(c,e)),f?a.reduce(c,d):a.reduce(c);j(a,function(a,b,i){f?d=c.call(e,d,a,b,i):(d=a,f=true)});if(!f)throw new TypeError("Reduce of empty array with no initial value");return d};b.reduceRight=b.foldr=function(a,c,d,e){var f=arguments.length>2;a==null&&(a=[]);if(z&&a.reduceRight===z)return e&&(c=b.bind(c,e)),f?a.reduceRight(c,d):a.reduceRight(c);var g=b.toArray(a).reverse();e&&!f&&(c=b.bind(c,e));return f?b.reduce(g,c,d,e):b.reduce(g,c)};b.find=b.detect=
+function(a,c,b){var e;E(a,function(a,g,h){if(c.call(b,a,g,h))return e=a,true});return e};b.filter=b.select=function(a,c,b){var e=[];if(a==null)return e;if(A&&a.filter===A)return a.filter(c,b);j(a,function(a,g,h){c.call(b,a,g,h)&&(e[e.length]=a)});return e};b.reject=function(a,c,b){var e=[];if(a==null)return e;j(a,function(a,g,h){c.call(b,a,g,h)||(e[e.length]=a)});return e};b.every=b.all=function(a,c,b){var e=true;if(a==null)return e;if(B&&a.every===B)return a.every(c,b);j(a,function(a,g,h){if(!(e=
+e&&c.call(b,a,g,h)))return n});return e};var E=b.some=b.any=function(a,c,d){c||(c=b.identity);var e=false;if(a==null)return e;if(C&&a.some===C)return a.some(c,d);j(a,function(a,b,h){if(e||(e=c.call(d,a,b,h)))return n});return!!e};b.include=b.contains=function(a,c){var b=false;if(a==null)return b;return p&&a.indexOf===p?a.indexOf(c)!=-1:b=E(a,function(a){return a===c})};b.invoke=function(a,c){var d=i.call(arguments,2);return b.map(a,function(a){return(b.isFunction(c)?c||a:a[c]).apply(a,d)})};b.pluck=
+function(a,c){return b.map(a,function(a){return a[c]})};b.max=function(a,c,d){if(!c&&b.isArray(a))return Math.max.apply(Math,a);if(!c&&b.isEmpty(a))return-Infinity;var e={computed:-Infinity};j(a,function(a,b,h){b=c?c.call(d,a,b,h):a;b>=e.computed&&(e={value:a,computed:b})});return e.value};b.min=function(a,c,d){if(!c&&b.isArray(a))return Math.min.apply(Math,a);if(!c&&b.isEmpty(a))return Infinity;var e={computed:Infinity};j(a,function(a,b,h){b=c?c.call(d,a,b,h):a;b<e.computed&&(e={value:a,computed:b})});
+return e.value};b.shuffle=function(a){var b=[],d;j(a,function(a,f){f==0?b[0]=a:(d=Math.floor(Math.random()*(f+1)),b[f]=b[d],b[d]=a)});return b};b.sortBy=function(a,c,d){return b.pluck(b.map(a,function(a,b,g){return{value:a,criteria:c.call(d,a,b,g)}}).sort(function(a,b){var c=a.criteria,d=b.criteria;return c<d?-1:c>d?1:0}),"value")};b.groupBy=function(a,c){var d={},e=b.isFunction(c)?c:function(a){return a[c]};j(a,function(a,b){var c=e(a,b);(d[c]||(d[c]=[])).push(a)});return d};b.sortedIndex=function(a,
+c,d){d||(d=b.identity);for(var e=0,f=a.length;e<f;){var g=e+f>>1;d(a[g])<d(c)?e=g+1:f=g}return e};b.toArray=function(a){return!a?[]:a.toArray?a.toArray():b.isArray(a)?i.call(a):b.isArguments(a)?i.call(a):b.values(a)};b.size=function(a){return b.toArray(a).length};b.first=b.head=function(a,b,d){return b!=null&&!d?i.call(a,0,b):a[0]};b.initial=function(a,b,d){return i.call(a,0,a.length-(b==null||d?1:b))};b.last=function(a,b,d){return b!=null&&!d?i.call(a,Math.max(a.length-b,0)):a[a.length-1]};b.rest=
+b.tail=function(a,b,d){return i.call(a,b==null||d?1:b)};b.compact=function(a){return b.filter(a,function(a){return!!a})};b.flatten=function(a,c){return b.reduce(a,function(a,e){if(b.isArray(e))return a.concat(c?e:b.flatten(e));a[a.length]=e;return a},[])};b.without=function(a){return b.difference(a,i.call(arguments,1))};b.uniq=b.unique=function(a,c,d){var d=d?b.map(a,d):a,e=[];b.reduce(d,function(d,g,h){if(0==h||(c===true?b.last(d)!=g:!b.include(d,g)))d[d.length]=g,e[e.length]=a[h];return d},[]);
+return e};b.union=function(){return b.uniq(b.flatten(arguments,true))};b.intersection=b.intersect=function(a){var c=i.call(arguments,1);return b.filter(b.uniq(a),function(a){return b.every(c,function(c){return b.indexOf(c,a)>=0})})};b.difference=function(a){var c=b.flatten(i.call(arguments,1));return b.filter(a,function(a){return!b.include(c,a)})};b.zip=function(){for(var a=i.call(arguments),c=b.max(b.pluck(a,"length")),d=Array(c),e=0;e<c;e++)d[e]=b.pluck(a,""+e);return d};b.indexOf=function(a,c,
+d){if(a==null)return-1;var e;if(d)return d=b.sortedIndex(a,c),a[d]===c?d:-1;if(p&&a.indexOf===p)return a.indexOf(c);for(d=0,e=a.length;d<e;d++)if(d in a&&a[d]===c)return d;return-1};b.lastIndexOf=function(a,b){if(a==null)return-1;if(D&&a.lastIndexOf===D)return a.lastIndexOf(b);for(var d=a.length;d--;)if(d in a&&a[d]===b)return d;return-1};b.range=function(a,b,d){arguments.length<=1&&(b=a||0,a=0);for(var d=arguments[2]||1,e=Math.max(Math.ceil((b-a)/d),0),f=0,g=Array(e);f<e;)g[f++]=a,a+=d;return g};
+var F=function(){};b.bind=function(a,c){var d,e;if(a.bind===s&&s)return s.apply(a,i.call(arguments,1));if(!b.isFunction(a))throw new TypeError;e=i.call(arguments,2);return d=function(){if(!(this instanceof d))return a.apply(c,e.concat(i.call(arguments)));F.prototype=a.prototype;var b=new F,g=a.apply(b,e.concat(i.call(arguments)));return Object(g)===g?g:b}};b.bindAll=function(a){var c=i.call(arguments,1);c.length==0&&(c=b.functions(a));j(c,function(c){a[c]=b.bind(a[c],a)});return a};b.memoize=function(a,
+c){var d={};c||(c=b.identity);return function(){var e=c.apply(this,arguments);return b.has(d,e)?d[e]:d[e]=a.apply(this,arguments)}};b.delay=function(a,b){var d=i.call(arguments,2);return setTimeout(function(){return a.apply(a,d)},b)};b.defer=function(a){return b.delay.apply(b,[a,1].concat(i.call(arguments,1)))};b.throttle=function(a,c){var d,e,f,g,h,i=b.debounce(function(){h=g=false},c);return function(){d=this;e=arguments;var b;f||(f=setTimeout(function(){f=null;h&&a.apply(d,e);i()},c));g?h=true:
+a.apply(d,e);i();g=true}};b.debounce=function(a,b){var d;return function(){var e=this,f=arguments;clearTimeout(d);d=setTimeout(function(){d=null;a.apply(e,f)},b)}};b.once=function(a){var b=false,d;return function(){if(b)return d;b=true;return d=a.apply(this,arguments)}};b.wrap=function(a,b){return function(){var d=[a].concat(i.call(arguments,0));return b.apply(this,d)}};b.compose=function(){var a=arguments;return function(){for(var b=arguments,d=a.length-1;d>=0;d--)b=[a[d].apply(this,b)];return b[0]}};
+b.after=function(a,b){return a<=0?b():function(){if(--a<1)return b.apply(this,arguments)}};b.keys=J||function(a){if(a!==Object(a))throw new TypeError("Invalid object");var c=[],d;for(d in a)b.has(a,d)&&(c[c.length]=d);return c};b.values=function(a){return b.map(a,b.identity)};b.functions=b.methods=function(a){var c=[],d;for(d in a)b.isFunction(a[d])&&c.push(d);return c.sort()};b.extend=function(a){j(i.call(arguments,1),function(b){for(var d in b)a[d]=b[d]});return a};b.defaults=function(a){j(i.call(arguments,
+1),function(b){for(var d in b)a[d]==null&&(a[d]=b[d])});return a};b.clone=function(a){return!b.isObject(a)?a:b.isArray(a)?a.slice():b.extend({},a)};b.tap=function(a,b){b(a);return a};b.isEqual=function(a,b){return q(a,b,[])};b.isEmpty=function(a){if(b.isArray(a)||b.isString(a))return a.length===0;for(var c in a)if(b.has(a,c))return false;return true};b.isElement=function(a){return!!(a&&a.nodeType==1)};b.isArray=o||function(a){return l.call(a)=="[object Array]"};b.isObject=function(a){return a===Object(a)};
+b.isArguments=function(a){return l.call(a)=="[object Arguments]"};if(!b.isArguments(arguments))b.isArguments=function(a){return!(!a||!b.has(a,"callee"))};b.isFunction=function(a){return l.call(a)=="[object Function]"};b.isString=function(a){return l.call(a)=="[object String]"};b.isNumber=function(a){return l.call(a)=="[object Number]"};b.isNaN=function(a){return a!==a};b.isBoolean=function(a){return a===true||a===false||l.call(a)=="[object Boolean]"};b.isDate=function(a){return l.call(a)=="[object Date]"};
+b.isRegExp=function(a){return l.call(a)=="[object RegExp]"};b.isNull=function(a){return a===null};b.isUndefined=function(a){return a===void 0};b.has=function(a,b){return I.call(a,b)};b.noConflict=function(){r._=G;return this};b.identity=function(a){return a};b.times=function(a,b,d){for(var e=0;e<a;e++)b.call(d,e)};b.escape=function(a){return(""+a).replace(/&/g,"&").replace(/</g,"<").replace(/>/g,">").replace(/"/g,""").replace(/'/g,"'").replace(/\//g,"/")};b.mixin=function(a){j(b.functions(a),
+function(c){K(c,b[c]=a[c])})};var L=0;b.uniqueId=function(a){var b=L++;return a?a+b:b};b.templateSettings={evaluate:/<%([\s\S]+?)%>/g,interpolate:/<%=([\s\S]+?)%>/g,escape:/<%-([\s\S]+?)%>/g};var t=/.^/,u=function(a){return a.replace(/\\\\/g,"\\").replace(/\\'/g,"'")};b.template=function(a,c){var d=b.templateSettings,d="var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('"+a.replace(/\\/g,"\\\\").replace(/'/g,"\\'").replace(d.escape||t,function(a,b){return"',_.escape("+
+u(b)+"),'"}).replace(d.interpolate||t,function(a,b){return"',"+u(b)+",'"}).replace(d.evaluate||t,function(a,b){return"');"+u(b).replace(/[\r\n\t]/g," ")+";__p.push('"}).replace(/\r/g,"\\r").replace(/\n/g,"\\n").replace(/\t/g,"\\t")+"');}return __p.join('');",e=new Function("obj","_",d);return c?e(c,b):function(a){return e.call(this,a,b)}};b.chain=function(a){return b(a).chain()};var m=function(a){this._wrapped=a};b.prototype=m.prototype;var v=function(a,c){return c?b(a).chain():a},K=function(a,c){m.prototype[a]=
+function(){var a=i.call(arguments);H.call(a,this._wrapped);return v(c.apply(b,a),this._chain)}};b.mixin(b);j("pop,push,reverse,shift,sort,splice,unshift".split(","),function(a){var b=k[a];m.prototype[a]=function(){var d=this._wrapped;b.apply(d,arguments);var e=d.length;(a=="shift"||a=="splice")&&e===0&&delete d[0];return v(d,this._chain)}});j(["concat","join","slice"],function(a){var b=k[a];m.prototype[a]=function(){return v(b.apply(this._wrapped,arguments),this._chain)}});m.prototype.chain=function(){this._chain=
+true;return this};m.prototype.value=function(){return this._wrapped}}).call(this);
diff --git a/docs/html/_static/up-pressed.png b/docs/html/_static/up-pressed.png
new file mode 100644
index 0000000..acee3b6
--- /dev/null
+++ b/docs/html/_static/up-pressed.png
Binary files differ
diff --git a/docs/html/_static/up.png b/docs/html/_static/up.png
new file mode 100644
index 0000000..2a940a7
--- /dev/null
+++ b/docs/html/_static/up.png
Binary files differ
diff --git a/docs/html/_static/websupport.js b/docs/html/_static/websupport.js
new file mode 100644
index 0000000..3b4999e
--- /dev/null
+++ b/docs/html/_static/websupport.js
@@ -0,0 +1,808 @@
+/*
+ * websupport.js
+ * ~~~~~~~~~~~~~
+ *
+ * sphinx.websupport utilities for all documentation.
+ *
+ * :copyright: Copyright 2007-2019 by the Sphinx team, see AUTHORS.
+ * :license: BSD, see LICENSE for details.
+ *
+ */
+
+(function($) {
+ $.fn.autogrow = function() {
+ return this.each(function() {
+ var textarea = this;
+
+ $.fn.autogrow.resize(textarea);
+
+ $(textarea)
+ .focus(function() {
+ textarea.interval = setInterval(function() {
+ $.fn.autogrow.resize(textarea);
+ }, 500);
+ })
+ .blur(function() {
+ clearInterval(textarea.interval);
+ });
+ });
+ };
+
+ $.fn.autogrow.resize = function(textarea) {
+ var lineHeight = parseInt($(textarea).css('line-height'), 10);
+ var lines = textarea.value.split('\n');
+ var columns = textarea.cols;
+ var lineCount = 0;
+ $.each(lines, function() {
+ lineCount += Math.ceil(this.length / columns) || 1;
+ });
+ var height = lineHeight * (lineCount + 1);
+ $(textarea).css('height', height);
+ };
+})(jQuery);
+
+(function($) {
+ var comp, by;
+
+ function init() {
+ initEvents();
+ initComparator();
+ }
+
+ function initEvents() {
+ $(document).on("click", 'a.comment-close', function(event) {
+ event.preventDefault();
+ hide($(this).attr('id').substring(2));
+ });
+ $(document).on("click", 'a.vote', function(event) {
+ event.preventDefault();
+ handleVote($(this));
+ });
+ $(document).on("click", 'a.reply', function(event) {
+ event.preventDefault();
+ openReply($(this).attr('id').substring(2));
+ });
+ $(document).on("click", 'a.close-reply', function(event) {
+ event.preventDefault();
+ closeReply($(this).attr('id').substring(2));
+ });
+ $(document).on("click", 'a.sort-option', function(event) {
+ event.preventDefault();
+ handleReSort($(this));
+ });
+ $(document).on("click", 'a.show-proposal', function(event) {
+ event.preventDefault();
+ showProposal($(this).attr('id').substring(2));
+ });
+ $(document).on("click", 'a.hide-proposal', function(event) {
+ event.preventDefault();
+ hideProposal($(this).attr('id').substring(2));
+ });
+ $(document).on("click", 'a.show-propose-change', function(event) {
+ event.preventDefault();
+ showProposeChange($(this).attr('id').substring(2));
+ });
+ $(document).on("click", 'a.hide-propose-change', function(event) {
+ event.preventDefault();
+ hideProposeChange($(this).attr('id').substring(2));
+ });
+ $(document).on("click", 'a.accept-comment', function(event) {
+ event.preventDefault();
+ acceptComment($(this).attr('id').substring(2));
+ });
+ $(document).on("click", 'a.delete-comment', function(event) {
+ event.preventDefault();
+ deleteComment($(this).attr('id').substring(2));
+ });
+ $(document).on("click", 'a.comment-markup', function(event) {
+ event.preventDefault();
+ toggleCommentMarkupBox($(this).attr('id').substring(2));
+ });
+ }
+
+ /**
+ * Set comp, which is a comparator function used for sorting and
+ * inserting comments into the list.
+ */
+ function setComparator() {
+ // If the first three letters are "asc", sort in ascending order
+ // and remove the prefix.
+ if (by.substring(0,3) == 'asc') {
+ var i = by.substring(3);
+ comp = function(a, b) { return a[i] - b[i]; };
+ } else {
+ // Otherwise sort in descending order.
+ comp = function(a, b) { return b[by] - a[by]; };
+ }
+
+ // Reset link styles and format the selected sort option.
+ $('a.sel').attr('href', '#').removeClass('sel');
+ $('a.by' + by).removeAttr('href').addClass('sel');
+ }
+
+ /**
+ * Create a comp function. If the user has preferences stored in
+ * the sortBy cookie, use those, otherwise use the default.
+ */
+ function initComparator() {
+ by = 'rating'; // Default to sort by rating.
+ // If the sortBy cookie is set, use that instead.
+ if (document.cookie.length > 0) {
+ var start = document.cookie.indexOf('sortBy=');
+ if (start != -1) {
+ start = start + 7;
+ var end = document.cookie.indexOf(";", start);
+ if (end == -1) {
+ end = document.cookie.length;
+ by = unescape(document.cookie.substring(start, end));
+ }
+ }
+ }
+ setComparator();
+ }
+
+ /**
+ * Show a comment div.
+ */
+ function show(id) {
+ $('#ao' + id).hide();
+ $('#ah' + id).show();
+ var context = $.extend({id: id}, opts);
+ var popup = $(renderTemplate(popupTemplate, context)).hide();
+ popup.find('textarea[name="proposal"]').hide();
+ popup.find('a.by' + by).addClass('sel');
+ var form = popup.find('#cf' + id);
+ form.submit(function(event) {
+ event.preventDefault();
+ addComment(form);
+ });
+ $('#s' + id).after(popup);
+ popup.slideDown('fast', function() {
+ getComments(id);
+ });
+ }
+
+ /**
+ * Hide a comment div.
+ */
+ function hide(id) {
+ $('#ah' + id).hide();
+ $('#ao' + id).show();
+ var div = $('#sc' + id);
+ div.slideUp('fast', function() {
+ div.remove();
+ });
+ }
+
+ /**
+ * Perform an ajax request to get comments for a node
+ * and insert the comments into the comments tree.
+ */
+ function getComments(id) {
+ $.ajax({
+ type: 'GET',
+ url: opts.getCommentsURL,
+ data: {node: id},
+ success: function(data, textStatus, request) {
+ var ul = $('#cl' + id);
+ var speed = 100;
+ $('#cf' + id)
+ .find('textarea[name="proposal"]')
+ .data('source', data.source);
+
+ if (data.comments.length === 0) {
+ ul.html('<li>No comments yet.</li>');
+ ul.data('empty', true);
+ } else {
+ // If there are comments, sort them and put them in the list.
+ var comments = sortComments(data.comments);
+ speed = data.comments.length * 100;
+ appendComments(comments, ul);
+ ul.data('empty', false);
+ }
+ $('#cn' + id).slideUp(speed + 200);
+ ul.slideDown(speed);
+ },
+ error: function(request, textStatus, error) {
+ showError('Oops, there was a problem retrieving the comments.');
+ },
+ dataType: 'json'
+ });
+ }
+
+ /**
+ * Add a comment via ajax and insert the comment into the comment tree.
+ */
+ function addComment(form) {
+ var node_id = form.find('input[name="node"]').val();
+ var parent_id = form.find('input[name="parent"]').val();
+ var text = form.find('textarea[name="comment"]').val();
+ var proposal = form.find('textarea[name="proposal"]').val();
+
+ if (text == '') {
+ showError('Please enter a comment.');
+ return;
+ }
+
+ // Disable the form that is being submitted.
+ form.find('textarea,input').attr('disabled', 'disabled');
+
+ // Send the comment to the server.
+ $.ajax({
+ type: "POST",
+ url: opts.addCommentURL,
+ dataType: 'json',
+ data: {
+ node: node_id,
+ parent: parent_id,
+ text: text,
+ proposal: proposal
+ },
+ success: function(data, textStatus, error) {
+ // Reset the form.
+ if (node_id) {
+ hideProposeChange(node_id);
+ }
+ form.find('textarea')
+ .val('')
+ .add(form.find('input'))
+ .removeAttr('disabled');
+ var ul = $('#cl' + (node_id || parent_id));
+ if (ul.data('empty')) {
+ $(ul).empty();
+ ul.data('empty', false);
+ }
+ insertComment(data.comment);
+ var ao = $('#ao' + node_id);
+ ao.find('img').attr({'src': opts.commentBrightImage});
+ if (node_id) {
+ // if this was a "root" comment, remove the commenting box
+ // (the user can get it back by reopening the comment popup)
+ $('#ca' + node_id).slideUp();
+ }
+ },
+ error: function(request, textStatus, error) {
+ form.find('textarea,input').removeAttr('disabled');
+ showError('Oops, there was a problem adding the comment.');
+ }
+ });
+ }
+
+ /**
+ * Recursively append comments to the main comment list and children
+ * lists, creating the comment tree.
+ */
+ function appendComments(comments, ul) {
+ $.each(comments, function() {
+ var div = createCommentDiv(this);
+ ul.append($(document.createElement('li')).html(div));
+ appendComments(this.children, div.find('ul.comment-children'));
+ // To avoid stagnating data, don't store the comments children in data.
+ this.children = null;
+ div.data('comment', this);
+ });
+ }
+
+ /**
+ * After adding a new comment, it must be inserted in the correct
+ * location in the comment tree.
+ */
+ function insertComment(comment) {
+ var div = createCommentDiv(comment);
+
+ // To avoid stagnating data, don't store the comments children in data.
+ comment.children = null;
+ div.data('comment', comment);
+
+ var ul = $('#cl' + (comment.node || comment.parent));
+ var siblings = getChildren(ul);
+
+ var li = $(document.createElement('li'));
+ li.hide();
+
+ // Determine where in the parents children list to insert this comment.
+ for(var i=0; i < siblings.length; i++) {
+ if (comp(comment, siblings[i]) <= 0) {
+ $('#cd' + siblings[i].id)
+ .parent()
+ .before(li.html(div));
+ li.slideDown('fast');
+ return;
+ }
+ }
+
+ // If we get here, this comment rates lower than all the others,
+ // or it is the only comment in the list.
+ ul.append(li.html(div));
+ li.slideDown('fast');
+ }
+
+ function acceptComment(id) {
+ $.ajax({
+ type: 'POST',
+ url: opts.acceptCommentURL,
+ data: {id: id},
+ success: function(data, textStatus, request) {
+ $('#cm' + id).fadeOut('fast');
+ $('#cd' + id).removeClass('moderate');
+ },
+ error: function(request, textStatus, error) {
+ showError('Oops, there was a problem accepting the comment.');
+ }
+ });
+ }
+
+ function deleteComment(id) {
+ $.ajax({
+ type: 'POST',
+ url: opts.deleteCommentURL,
+ data: {id: id},
+ success: function(data, textStatus, request) {
+ var div = $('#cd' + id);
+ if (data == 'delete') {
+ // Moderator mode: remove the comment and all children immediately
+ div.slideUp('fast', function() {
+ div.remove();
+ });
+ return;
+ }
+ // User mode: only mark the comment as deleted
+ div
+ .find('span.user-id:first')
+ .text('[deleted]').end()
+ .find('div.comment-text:first')
+ .text('[deleted]').end()
+ .find('#cm' + id + ', #dc' + id + ', #ac' + id + ', #rc' + id +
+ ', #sp' + id + ', #hp' + id + ', #cr' + id + ', #rl' + id)
+ .remove();
+ var comment = div.data('comment');
+ comment.username = '[deleted]';
+ comment.text = '[deleted]';
+ div.data('comment', comment);
+ },
+ error: function(request, textStatus, error) {
+ showError('Oops, there was a problem deleting the comment.');
+ }
+ });
+ }
+
+ function showProposal(id) {
+ $('#sp' + id).hide();
+ $('#hp' + id).show();
+ $('#pr' + id).slideDown('fast');
+ }
+
+ function hideProposal(id) {
+ $('#hp' + id).hide();
+ $('#sp' + id).show();
+ $('#pr' + id).slideUp('fast');
+ }
+
+ function showProposeChange(id) {
+ $('#pc' + id).hide();
+ $('#hc' + id).show();
+ var textarea = $('#pt' + id);
+ textarea.val(textarea.data('source'));
+ $.fn.autogrow.resize(textarea[0]);
+ textarea.slideDown('fast');
+ }
+
+ function hideProposeChange(id) {
+ $('#hc' + id).hide();
+ $('#pc' + id).show();
+ var textarea = $('#pt' + id);
+ textarea.val('').removeAttr('disabled');
+ textarea.slideUp('fast');
+ }
+
+ function toggleCommentMarkupBox(id) {
+ $('#mb' + id).toggle();
+ }
+
+ /** Handle when the user clicks on a sort by link. */
+ function handleReSort(link) {
+ var classes = link.attr('class').split(/\s+/);
+ for (var i=0; i<classes.length; i++) {
+ if (classes[i] != 'sort-option') {
+ by = classes[i].substring(2);
+ }
+ }
+ setComparator();
+ // Save/update the sortBy cookie.
+ var expiration = new Date();
+ expiration.setDate(expiration.getDate() + 365);
+ document.cookie= 'sortBy=' + escape(by) +
+ ';expires=' + expiration.toUTCString();
+ $('ul.comment-ul').each(function(index, ul) {
+ var comments = getChildren($(ul), true);
+ comments = sortComments(comments);
+ appendComments(comments, $(ul).empty());
+ });
+ }
+
+ /**
+ * Function to process a vote when a user clicks an arrow.
+ */
+ function handleVote(link) {
+ if (!opts.voting) {
+ showError("You'll need to login to vote.");
+ return;
+ }
+
+ var id = link.attr('id');
+ if (!id) {
+ // Didn't click on one of the voting arrows.
+ return;
+ }
+ // If it is an unvote, the new vote value is 0,
+ // Otherwise it's 1 for an upvote, or -1 for a downvote.
+ var value = 0;
+ if (id.charAt(1) != 'u') {
+ value = id.charAt(0) == 'u' ? 1 : -1;
+ }
+ // The data to be sent to the server.
+ var d = {
+ comment_id: id.substring(2),
+ value: value
+ };
+
+ // Swap the vote and unvote links.
+ link.hide();
+ $('#' + id.charAt(0) + (id.charAt(1) == 'u' ? 'v' : 'u') + d.comment_id)
+ .show();
+
+ // The div the comment is displayed in.
+ var div = $('div#cd' + d.comment_id);
+ var data = div.data('comment');
+
+ // If this is not an unvote, and the other vote arrow has
+ // already been pressed, unpress it.
+ if ((d.value !== 0) && (data.vote === d.value * -1)) {
+ $('#' + (d.value == 1 ? 'd' : 'u') + 'u' + d.comment_id).hide();
+ $('#' + (d.value == 1 ? 'd' : 'u') + 'v' + d.comment_id).show();
+ }
+
+ // Update the comments rating in the local data.
+ data.rating += (data.vote === 0) ? d.value : (d.value - data.vote);
+ data.vote = d.value;
+ div.data('comment', data);
+
+ // Change the rating text.
+ div.find('.rating:first')
+ .text(data.rating + ' point' + (data.rating == 1 ? '' : 's'));
+
+ // Send the vote information to the server.
+ $.ajax({
+ type: "POST",
+ url: opts.processVoteURL,
+ data: d,
+ error: function(request, textStatus, error) {
+ showError('Oops, there was a problem casting that vote.');
+ }
+ });
+ }
+
+ /**
+ * Open a reply form used to reply to an existing comment.
+ */
+ function openReply(id) {
+ // Swap out the reply link for the hide link
+ $('#rl' + id).hide();
+ $('#cr' + id).show();
+
+ // Add the reply li to the children ul.
+ var div = $(renderTemplate(replyTemplate, {id: id})).hide();
+ $('#cl' + id)
+ .prepend(div)
+ // Setup the submit handler for the reply form.
+ .find('#rf' + id)
+ .submit(function(event) {
+ event.preventDefault();
+ addComment($('#rf' + id));
+ closeReply(id);
+ })
+ .find('input[type=button]')
+ .click(function() {
+ closeReply(id);
+ });
+ div.slideDown('fast', function() {
+ $('#rf' + id).find('textarea').focus();
+ });
+ }
+
+ /**
+ * Close the reply form opened with openReply.
+ */
+ function closeReply(id) {
+ // Remove the reply div from the DOM.
+ $('#rd' + id).slideUp('fast', function() {
+ $(this).remove();
+ });
+
+ // Swap out the hide link for the reply link
+ $('#cr' + id).hide();
+ $('#rl' + id).show();
+ }
+
+ /**
+ * Recursively sort a tree of comments using the comp comparator.
+ */
+ function sortComments(comments) {
+ comments.sort(comp);
+ $.each(comments, function() {
+ this.children = sortComments(this.children);
+ });
+ return comments;
+ }
+
+ /**
+ * Get the children comments from a ul. If recursive is true,
+ * recursively include childrens' children.
+ */
+ function getChildren(ul, recursive) {
+ var children = [];
+ ul.children().children("[id^='cd']")
+ .each(function() {
+ var comment = $(this).data('comment');
+ if (recursive)
+ comment.children = getChildren($(this).find('#cl' + comment.id), true);
+ children.push(comment);
+ });
+ return children;
+ }
+
+ /** Create a div to display a comment in. */
+ function createCommentDiv(comment) {
+ if (!comment.displayed && !opts.moderator) {
+ return $('<div class="moderate">Thank you! Your comment will show up '
+ + 'once it is has been approved by a moderator.</div>');
+ }
+ // Prettify the comment rating.
+ comment.pretty_rating = comment.rating + ' point' +
+ (comment.rating == 1 ? '' : 's');
+ // Make a class (for displaying not yet moderated comments differently)
+ comment.css_class = comment.displayed ? '' : ' moderate';
+ // Create a div for this comment.
+ var context = $.extend({}, opts, comment);
+ var div = $(renderTemplate(commentTemplate, context));
+
+ // If the user has voted on this comment, highlight the correct arrow.
+ if (comment.vote) {
+ var direction = (comment.vote == 1) ? 'u' : 'd';
+ div.find('#' + direction + 'v' + comment.id).hide();
+ div.find('#' + direction + 'u' + comment.id).show();
+ }
+
+ if (opts.moderator || comment.text != '[deleted]') {
+ div.find('a.reply').show();
+ if (comment.proposal_diff)
+ div.find('#sp' + comment.id).show();
+ if (opts.moderator && !comment.displayed)
+ div.find('#cm' + comment.id).show();
+ if (opts.moderator || (opts.username == comment.username))
+ div.find('#dc' + comment.id).show();
+ }
+ return div;
+ }
+
+ /**
+ * A simple template renderer. Placeholders such as <%id%> are replaced
+ * by context['id'] with items being escaped. Placeholders such as <#id#>
+ * are not escaped.
+ */
+ function renderTemplate(template, context) {
+ var esc = $(document.createElement('div'));
+
+ function handle(ph, escape) {
+ var cur = context;
+ $.each(ph.split('.'), function() {
+ cur = cur[this];
+ });
+ return escape ? esc.text(cur || "").html() : cur;
+ }
+
+ return template.replace(/<([%#])([\w\.]*)\1>/g, function() {
+ return handle(arguments[2], arguments[1] == '%' ? true : false);
+ });
+ }
+
+ /** Flash an error message briefly. */
+ function showError(message) {
+ $(document.createElement('div')).attr({'class': 'popup-error'})
+ .append($(document.createElement('div'))
+ .attr({'class': 'error-message'}).text(message))
+ .appendTo('body')
+ .fadeIn("slow")
+ .delay(2000)
+ .fadeOut("slow");
+ }
+
+ /** Add a link the user uses to open the comments popup. */
+ $.fn.comment = function() {
+ return this.each(function() {
+ var id = $(this).attr('id').substring(1);
+ var count = COMMENT_METADATA[id];
+ var title = count + ' comment' + (count == 1 ? '' : 's');
+ var image = count > 0 ? opts.commentBrightImage : opts.commentImage;
+ var addcls = count == 0 ? ' nocomment' : '';
+ $(this)
+ .append(
+ $(document.createElement('a')).attr({
+ href: '#',
+ 'class': 'sphinx-comment-open' + addcls,
+ id: 'ao' + id
+ })
+ .append($(document.createElement('img')).attr({
+ src: image,
+ alt: 'comment',
+ title: title
+ }))
+ .click(function(event) {
+ event.preventDefault();
+ show($(this).attr('id').substring(2));
+ })
+ )
+ .append(
+ $(document.createElement('a')).attr({
+ href: '#',
+ 'class': 'sphinx-comment-close hidden',
+ id: 'ah' + id
+ })
+ .append($(document.createElement('img')).attr({
+ src: opts.closeCommentImage,
+ alt: 'close',
+ title: 'close'
+ }))
+ .click(function(event) {
+ event.preventDefault();
+ hide($(this).attr('id').substring(2));
+ })
+ );
+ });
+ };
+
+ var opts = {
+ processVoteURL: '/_process_vote',
+ addCommentURL: '/_add_comment',
+ getCommentsURL: '/_get_comments',
+ acceptCommentURL: '/_accept_comment',
+ deleteCommentURL: '/_delete_comment',
+ commentImage: '/static/_static/comment.png',
+ closeCommentImage: '/static/_static/comment-close.png',
+ loadingImage: '/static/_static/ajax-loader.gif',
+ commentBrightImage: '/static/_static/comment-bright.png',
+ upArrow: '/static/_static/up.png',
+ downArrow: '/static/_static/down.png',
+ upArrowPressed: '/static/_static/up-pressed.png',
+ downArrowPressed: '/static/_static/down-pressed.png',
+ voting: false,
+ moderator: false
+ };
+
+ if (typeof COMMENT_OPTIONS != "undefined") {
+ opts = jQuery.extend(opts, COMMENT_OPTIONS);
+ }
+
+ var popupTemplate = '\
+ <div class="sphinx-comments" id="sc<%id%>">\
+ <p class="sort-options">\
+ Sort by:\
+ <a href="#" class="sort-option byrating">best rated</a>\
+ <a href="#" class="sort-option byascage">newest</a>\
+ <a href="#" class="sort-option byage">oldest</a>\
+ </p>\
+ <div class="comment-header">Comments</div>\
+ <div class="comment-loading" id="cn<%id%>">\
+ loading comments... <img src="<%loadingImage%>" alt="" /></div>\
+ <ul id="cl<%id%>" class="comment-ul"></ul>\
+ <div id="ca<%id%>">\
+ <p class="add-a-comment">Add a comment\
+ (<a href="#" class="comment-markup" id="ab<%id%>">markup</a>):</p>\
+ <div class="comment-markup-box" id="mb<%id%>">\
+ reStructured text markup: <i>*emph*</i>, <b>**strong**</b>, \
+ <code>``code``</code>, \
+ code blocks: <code>::</code> and an indented block after blank line</div>\
+ <form method="post" id="cf<%id%>" class="comment-form" action="">\
+ <textarea name="comment" cols="80"></textarea>\
+ <p class="propose-button">\
+ <a href="#" id="pc<%id%>" class="show-propose-change">\
+ Propose a change ▹\
+ </a>\
+ <a href="#" id="hc<%id%>" class="hide-propose-change">\
+ Propose a change ▿\
+ </a>\
+ </p>\
+ <textarea name="proposal" id="pt<%id%>" cols="80"\
+ spellcheck="false"></textarea>\
+ <input type="submit" value="Add comment" />\
+ <input type="hidden" name="node" value="<%id%>" />\
+ <input type="hidden" name="parent" value="" />\
+ </form>\
+ </div>\
+ </div>';
+
+ var commentTemplate = '\
+ <div id="cd<%id%>" class="sphinx-comment<%css_class%>">\
+ <div class="vote">\
+ <div class="arrow">\
+ <a href="#" id="uv<%id%>" class="vote" title="vote up">\
+ <img src="<%upArrow%>" />\
+ </a>\
+ <a href="#" id="uu<%id%>" class="un vote" title="vote up">\
+ <img src="<%upArrowPressed%>" />\
+ </a>\
+ </div>\
+ <div class="arrow">\
+ <a href="#" id="dv<%id%>" class="vote" title="vote down">\
+ <img src="<%downArrow%>" id="da<%id%>" />\
+ </a>\
+ <a href="#" id="du<%id%>" class="un vote" title="vote down">\
+ <img src="<%downArrowPressed%>" />\
+ </a>\
+ </div>\
+ </div>\
+ <div class="comment-content">\
+ <p class="tagline comment">\
+ <span class="user-id"><%username%></span>\
+ <span class="rating"><%pretty_rating%></span>\
+ <span class="delta"><%time.delta%></span>\
+ </p>\
+ <div class="comment-text comment"><#text#></div>\
+ <p class="comment-opts comment">\
+ <a href="#" class="reply hidden" id="rl<%id%>">reply ▹</a>\
+ <a href="#" class="close-reply" id="cr<%id%>">reply ▿</a>\
+ <a href="#" id="sp<%id%>" class="show-proposal">proposal ▹</a>\
+ <a href="#" id="hp<%id%>" class="hide-proposal">proposal ▿</a>\
+ <a href="#" id="dc<%id%>" class="delete-comment hidden">delete</a>\
+ <span id="cm<%id%>" class="moderation hidden">\
+ <a href="#" id="ac<%id%>" class="accept-comment">accept</a>\
+ </span>\
+ </p>\
+ <pre class="proposal" id="pr<%id%>">\
+<#proposal_diff#>\
+ </pre>\
+ <ul class="comment-children" id="cl<%id%>"></ul>\
+ </div>\
+ <div class="clearleft"></div>\
+ </div>\
+ </div>';
+
+ var replyTemplate = '\
+ <li>\
+ <div class="reply-div" id="rd<%id%>">\
+ <form id="rf<%id%>">\
+ <textarea name="comment" cols="80"></textarea>\
+ <input type="submit" value="Add reply" />\
+ <input type="button" value="Cancel" />\
+ <input type="hidden" name="parent" value="<%id%>" />\
+ <input type="hidden" name="node" value="" />\
+ </form>\
+ </div>\
+ </li>';
+
+ $(document).ready(function() {
+ init();
+ });
+})(jQuery);
+
+$(document).ready(function() {
+ // add comment anchors for all paragraphs that are commentable
+ $('.sphinx-has-comment').comment();
+
+ // highlight search words in search results
+ $("div.context").each(function() {
+ var params = $.getQueryParameters();
+ var terms = (params.q) ? params.q[0].split(/\s+/) : [];
+ var result = $(this);
+ $.each(terms, function() {
+ result.highlightText(this.toLowerCase(), 'highlighted');
+ });
+ });
+
+ // directly open comment window if requested
+ var anchor = document.location.hash;
+ if (anchor.substring(0, 9) == '#comment-') {
+ $('#ao' + anchor.substring(9)).click();
+ document.location.hash = '#s' + anchor.substring(9);
+ }
+});
diff --git a/docs/html/annotated.html b/docs/html/annotated.html
deleted file mode 100644
index ea8766a..0000000
--- a/docs/html/annotated.html
+++ /dev/null
@@ -1,103 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: Class List</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li><a href="modules.html"><span>Modules</span></a></li>
- <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
- <li><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
- <div id="navrow2" class="tabs2">
- <ul class="tablist">
- <li class="current"><a href="annotated.html"><span>Class List</span></a></li>
- <li><a href="classes.html"><span>Class Index</span></a></li>
- <li><a href="functions.html"><span>Class Members</span></a></li>
- </ul>
- </div>
-</div><!-- top -->
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div class="header">
- <div class="headertitle">
-<div class="title">Class List</div> </div>
-</div><!--header-->
-<div class="contents">
-<div class="textblock">Here are the classes, structs, unions and interfaces with brief descriptions:</div><div class="directory">
-<table class="directory">
-<tr id="row_0_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structpsa__generate__key__extra__rsa.html" target="_self">psa_generate_key_extra_rsa</a></td><td class="desc"></td></tr>
-</table>
-</div><!-- directory -->
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/arrowdown.png b/docs/html/arrowdown.png
deleted file mode 100644
index 0b63f6d..0000000
--- a/docs/html/arrowdown.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/arrowright.png b/docs/html/arrowright.png
deleted file mode 100644
index c6ee22f..0000000
--- a/docs/html/arrowright.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/bc_s.png b/docs/html/bc_s.png
deleted file mode 100644
index 224b29a..0000000
--- a/docs/html/bc_s.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/bdwn.png b/docs/html/bdwn.png
deleted file mode 100644
index 940a0b9..0000000
--- a/docs/html/bdwn.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/classes.html b/docs/html/classes.html
deleted file mode 100644
index 8382069..0000000
--- a/docs/html/classes.html
+++ /dev/null
@@ -1,107 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: Class Index</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li><a href="modules.html"><span>Modules</span></a></li>
- <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
- <li><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
- <div id="navrow2" class="tabs2">
- <ul class="tablist">
- <li><a href="annotated.html"><span>Class List</span></a></li>
- <li class="current"><a href="classes.html"><span>Class Index</span></a></li>
- <li><a href="functions.html"><span>Class Members</span></a></li>
- </ul>
- </div>
-</div><!-- top -->
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div class="header">
- <div class="headertitle">
-<div class="title">Class Index</div> </div>
-</div><!--header-->
-<div class="contents">
-<div class="qindex"><a class="qindex" href="#letter_P">P</a></div>
-<table class="classindex">
-<tr><td rowspan="2" valign="bottom"><a name="letter_p"></a><table border="0" cellspacing="0" cellpadding="0"><tr><td><div class="ah">  p  </div></td></tr></table>
-</td><td></td></tr>
-<tr><td></td></tr>
-<tr><td valign="top"><a class="el" href="structpsa__generate__key__extra__rsa.html">psa_generate_key_extra_rsa</a>   </td><td></td></tr>
-<tr><td></td><td></td></tr>
-</table>
-<div class="qindex"><a class="qindex" href="#letter_P">P</a></div>
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/closed.png b/docs/html/closed.png
deleted file mode 100644
index 98cc2c9..0000000
--- a/docs/html/closed.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/crypto_8h.html b/docs/html/crypto_8h.html
deleted file mode 100644
index 0734526..0000000
--- a/docs/html/crypto_8h.html
+++ /dev/null
@@ -1,338 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: psa/crypto.h File Reference</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li class="current"><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
- <div id="navrow2" class="tabs2">
- <ul class="tablist">
- <li><a href="files.html"><span>File List</span></a></li>
- <li><a href="globals.html"><span>File Members</span></a></li>
- </ul>
- </div>
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div id="nav-path" class="navpath">
- <ul>
-<li class="navelem"><a class="el" href="dir_7dae9cfde651cd3cb034485ce5e391b9.html">psa</a></li> </ul>
-</div>
-</div><!-- top -->
-<div class="header">
- <div class="summary">
-<a href="#nested-classes">Classes</a> |
-<a href="#define-members">Macros</a> |
-<a href="#typedef-members">Typedefs</a> |
-<a href="#func-members">Functions</a> </div>
- <div class="headertitle">
-<div class="title">crypto.h File Reference</div> </div>
-</div><!--header-->
-<div class="contents">
-
-<p>Platform Security Architecture cryptography module.
-<a href="#details">More...</a></p>
-<div class="textblock"><code>#include "crypto_platform.h"</code><br />
-<code>#include <stddef.h></code><br />
-<code>#include "<a class="el" href="crypto__types_8h_source.html">crypto_types.h</a>"</code><br />
-<code>#include "<a class="el" href="crypto__values_8h_source.html">crypto_values.h</a>"</code><br />
-<code>#include "<a class="el" href="crypto__sizes_8h_source.html">crypto_sizes.h</a>"</code><br />
-<code>#include "crypto_struct.h"</code><br />
-<code>#include "crypto_extra.h"</code><br />
-</div><div class="textblock"><div class="dynheader">
-Include dependency graph for crypto.h:</div>
-<div class="dyncontent">
-<div class="center"><img src="crypto_8h__incl.png" border="0" usemap="#psa_2crypto_8h" alt=""/></div>
-<map name="psa_2crypto_8h" id="psa_2crypto_8h">
-<area shape="rect" id="node8" href="crypto__types_8h.html" title="PSA cryptography module: type aliases. " alt="" coords="763,102,871,129"/>
-<area shape="rect" id="node9" href="crypto__values_8h.html" title="PSA cryptography module: macros to build and analyze integer values. " alt="" coords="896,102,1011,129"/>
-<area shape="rect" id="node10" href="crypto__sizes_8h.html" title="PSA cryptography module: Mbed TLS buffer size macros. " alt="" coords="1035,102,1141,129"/>
-</map>
-</div>
-</div>
-<p><a href="crypto_8h_source.html">Go to the source code of this file.</a></p>
-<table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
-Classes</h2></td></tr>
-<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structpsa__generate__key__extra__rsa.html">psa_generate_key_extra_rsa</a></td></tr>
-<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
-</table><table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="define-members"></a>
-Macros</h2></td></tr>
-<tr class="memitem:ga5e6bc5f550e88fdc7790f2a75e79f7c5"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#ga5e6bc5f550e88fdc7790f2a75e79f7c5">PSA_KEY_POLICY_INIT</a>   {0}</td></tr>
-<tr class="separator:ga5e6bc5f550e88fdc7790f2a75e79f7c5"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6ab7fe8d3500bc2f21be840b4f4f8d1d"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__hash.html#ga6ab7fe8d3500bc2f21be840b4f4f8d1d">PSA_HASH_OPERATION_INIT</a>   {0}</td></tr>
-<tr class="separator:ga6ab7fe8d3500bc2f21be840b4f4f8d1d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga441b6efc161a4573d06465bd22d9dc2d"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__MAC.html#ga441b6efc161a4573d06465bd22d9dc2d">PSA_MAC_OPERATION_INIT</a>   {0}</td></tr>
-<tr class="separator:ga441b6efc161a4573d06465bd22d9dc2d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga2da0541aabf9a4995cf2004e36311919"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__cipher.html#ga2da0541aabf9a4995cf2004e36311919">PSA_CIPHER_OPERATION_INIT</a>   {0}</td></tr>
-<tr class="separator:ga2da0541aabf9a4995cf2004e36311919"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaf52e036794c0dc6fbadd93a2b990f366"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__aead.html#gaf52e036794c0dc6fbadd93a2b990f366">PSA_AEAD_OPERATION_INIT</a>   {0}</td></tr>
-<tr class="separator:gaf52e036794c0dc6fbadd93a2b990f366"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4788b471385fc667876fbd8a0d3fe062"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__generators.html#ga4788b471385fc667876fbd8a0d3fe062">PSA_CRYPTO_GENERATOR_INIT</a>   {0}</td></tr>
-<tr class="separator:ga4788b471385fc667876fbd8a0d3fe062"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac3222df9b9ecca4d33ae56a7b8fbb1c9"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__generators.html#gac3222df9b9ecca4d33ae56a7b8fbb1c9">PSA_GENERATOR_UNBRIDLED_CAPACITY</a>   ((size_t)(-1))</td></tr>
-<tr class="separator:gac3222df9b9ecca4d33ae56a7b8fbb1c9"><td class="memSeparator" colspan="2"> </td></tr>
-</table><table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="typedef-members"></a>
-Typedefs</h2></td></tr>
-<tr class="memitem:gabf6d5fd4e2ea89ecd425c88f057e7f75"><td class="memItemLeft" align="right" valign="top">typedef _unsigned_integral_type_ </td><td class="memItemRight" valign="bottom"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a></td></tr>
-<tr class="memdesc:gabf6d5fd4e2ea89ecd425c88f057e7f75"><td class="mdescLeft"> </td><td class="mdescRight">Key handle. <a href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">More...</a><br /></td></tr>
-<tr class="separator:gabf6d5fd4e2ea89ecd425c88f057e7f75"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaf553efd409845b6d09ff25ce2ba36607"><td class="memItemLeft" align="right" valign="top">typedef struct psa_key_policy_s </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a></td></tr>
-<tr class="separator:gaf553efd409845b6d09ff25ce2ba36607"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga3c4205d2ce66c4095fc5c78c25273fab"><td class="memItemLeft" align="right" valign="top">typedef struct psa_hash_operation_s </td><td class="memItemRight" valign="bottom"><a class="el" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a></td></tr>
-<tr class="separator:ga3c4205d2ce66c4095fc5c78c25273fab"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga78f0838b0c4e3db28b26355624d4bd37"><td class="memItemLeft" align="right" valign="top">typedef struct psa_mac_operation_s </td><td class="memItemRight" valign="bottom"><a class="el" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a></td></tr>
-<tr class="separator:ga78f0838b0c4e3db28b26355624d4bd37"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1399de29db657e3737bb09927aae51fa"><td class="memItemLeft" align="right" valign="top">typedef struct psa_cipher_operation_s </td><td class="memItemRight" valign="bottom"><a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a></td></tr>
-<tr class="separator:ga1399de29db657e3737bb09927aae51fa"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga14f6a01afbaa8c5b3d8c5d345cbaa3ed"><td class="memItemLeft" align="right" valign="top">typedef struct psa_aead_operation_s </td><td class="memItemRight" valign="bottom"><a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a></td></tr>
-<tr class="separator:ga14f6a01afbaa8c5b3d8c5d345cbaa3ed"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1f894c4fba202ef8e307d72caf489e3b"><td class="memItemLeft" align="right" valign="top">typedef struct psa_crypto_generator_s </td><td class="memItemRight" valign="bottom"><a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a></td></tr>
-<tr class="separator:ga1f894c4fba202ef8e307d72caf489e3b"><td class="memSeparator" colspan="2"> </td></tr>
-</table><table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="func-members"></a>
-Functions</h2></td></tr>
-<tr class="memitem:ga2de150803fc2f7dc6101d5af7e921dd9"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9">psa_crypto_init</a> (void)</td></tr>
-<tr class="memdesc:ga2de150803fc2f7dc6101d5af7e921dd9"><td class="mdescLeft"> </td><td class="mdescRight">Library initialization. <a href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9">More...</a><br /></td></tr>
-<tr class="separator:ga2de150803fc2f7dc6101d5af7e921dd9"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac16792fd6d375a5f76d372090df40607"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#gac16792fd6d375a5f76d372090df40607">psa_key_policy_set_usage</a> (<a class="el" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a> *policy, <a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a> usage, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg)</td></tr>
-<tr class="memdesc:gac16792fd6d375a5f76d372090df40607"><td class="mdescLeft"> </td><td class="mdescRight">Set the standard fields of a policy structure. <a href="group__policy.html#gac16792fd6d375a5f76d372090df40607">More...</a><br /></td></tr>
-<tr class="separator:gac16792fd6d375a5f76d372090df40607"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga7746662b7503e484774d0ecb5d8ac2ab"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#ga7746662b7503e484774d0ecb5d8ac2ab">psa_key_policy_get_usage</a> (const <a class="el" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a> *policy)</td></tr>
-<tr class="memdesc:ga7746662b7503e484774d0ecb5d8ac2ab"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the usage field of a policy structure. <a href="group__policy.html#ga7746662b7503e484774d0ecb5d8ac2ab">More...</a><br /></td></tr>
-<tr class="separator:ga7746662b7503e484774d0ecb5d8ac2ab"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaadf16b89ace53e1d2cb5bcb0aef24c86"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#gaadf16b89ace53e1d2cb5bcb0aef24c86">psa_key_policy_get_algorithm</a> (const <a class="el" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a> *policy)</td></tr>
-<tr class="memdesc:gaadf16b89ace53e1d2cb5bcb0aef24c86"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the algorithm field of a policy structure. <a href="group__policy.html#gaadf16b89ace53e1d2cb5bcb0aef24c86">More...</a><br /></td></tr>
-<tr class="separator:gaadf16b89ace53e1d2cb5bcb0aef24c86"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1e2a6e50b621864f95d438222a3c640b"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#ga1e2a6e50b621864f95d438222a3c640b">psa_set_key_policy</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, const <a class="el" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a> *policy)</td></tr>
-<tr class="memdesc:ga1e2a6e50b621864f95d438222a3c640b"><td class="mdescLeft"> </td><td class="mdescRight">Set the usage policy on a key slot. <a href="group__policy.html#ga1e2a6e50b621864f95d438222a3c640b">More...</a><br /></td></tr>
-<tr class="separator:ga1e2a6e50b621864f95d438222a3c640b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaed087d1386b807edee66b2e445ba9111"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#gaed087d1386b807edee66b2e445ba9111">psa_get_key_policy</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a> *policy)</td></tr>
-<tr class="memdesc:gaed087d1386b807edee66b2e445ba9111"><td class="mdescLeft"> </td><td class="mdescRight">Get the usage policy for a key slot. <a href="group__policy.html#gaed087d1386b807edee66b2e445ba9111">More...</a><br /></td></tr>
-<tr class="separator:gaed087d1386b807edee66b2e445ba9111"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1e4825ab59260aeb3bdbb3ff07210022"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__key__management.html#ga1e4825ab59260aeb3bdbb3ff07210022">psa_get_key_lifetime</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">psa_key_lifetime_t</a> *lifetime)</td></tr>
-<tr class="memdesc:ga1e4825ab59260aeb3bdbb3ff07210022"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the lifetime of an open key. <a href="group__key__management.html#ga1e4825ab59260aeb3bdbb3ff07210022">More...</a><br /></td></tr>
-<tr class="separator:ga1e4825ab59260aeb3bdbb3ff07210022"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga40094b77b7a42b9c8e158395113f1a35"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__key__management.html#ga40094b77b7a42b9c8e158395113f1a35">psa_allocate_key</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> *handle)</td></tr>
-<tr class="separator:ga40094b77b7a42b9c8e158395113f1a35"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa9f1c848cf78b80fe2a7b18bb7ccec50"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__key__management.html#gaa9f1c848cf78b80fe2a7b18bb7ccec50">psa_open_key</a> (<a class="el" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">psa_key_lifetime_t</a> lifetime, <a class="el" href="group__key__lifetimes.html#ga11e986351c65bd3dc3c0fe2cd9926e4b">psa_key_id_t</a> id, <a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> *handle)</td></tr>
-<tr class="separator:gaa9f1c848cf78b80fe2a7b18bb7ccec50"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4108f255d3eaa6d23a7a14b684af8d7c"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__key__management.html#ga4108f255d3eaa6d23a7a14b684af8d7c">psa_create_key</a> (<a class="el" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">psa_key_lifetime_t</a> lifetime, <a class="el" href="group__key__lifetimes.html#ga11e986351c65bd3dc3c0fe2cd9926e4b">psa_key_id_t</a> id, <a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> *handle)</td></tr>
-<tr class="separator:ga4108f255d3eaa6d23a7a14b684af8d7c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa09b720d299dfe6b9f41c36e448078eb"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__key__management.html#gaa09b720d299dfe6b9f41c36e448078eb">psa_close_key</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle)</td></tr>
-<tr class="separator:gaa09b720d299dfe6b9f41c36e448078eb"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac9f999cb4d098663d56095afe81a453a"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__import__export.html#gac9f999cb4d098663d56095afe81a453a">psa_import_key</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a> type, const uint8_t *data, size_t data_length)</td></tr>
-<tr class="memdesc:gac9f999cb4d098663d56095afe81a453a"><td class="mdescLeft"> </td><td class="mdescRight">Import a key in binary format. <a href="group__import__export.html#gac9f999cb4d098663d56095afe81a453a">More...</a><br /></td></tr>
-<tr class="separator:gac9f999cb4d098663d56095afe81a453a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga165085fc1bc7a78b91792fdd94ae102c"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__import__export.html#ga165085fc1bc7a78b91792fdd94ae102c">psa_destroy_key</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle)</td></tr>
-<tr class="memdesc:ga165085fc1bc7a78b91792fdd94ae102c"><td class="mdescLeft"> </td><td class="mdescRight">Destroy a key. <a href="group__import__export.html#ga165085fc1bc7a78b91792fdd94ae102c">More...</a><br /></td></tr>
-<tr class="separator:ga165085fc1bc7a78b91792fdd94ae102c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae8939902d6977ea8ad13eb7b4db9a042"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__import__export.html#gae8939902d6977ea8ad13eb7b4db9a042">psa_get_key_information</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a> *type, size_t *bits)</td></tr>
-<tr class="memdesc:gae8939902d6977ea8ad13eb7b4db9a042"><td class="mdescLeft"> </td><td class="mdescRight">Get basic metadata about a key. <a href="group__import__export.html#gae8939902d6977ea8ad13eb7b4db9a042">More...</a><br /></td></tr>
-<tr class="separator:gae8939902d6977ea8ad13eb7b4db9a042"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga091da8d3d39137fd6ad59f2b10234300"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__import__export.html#ga091da8d3d39137fd6ad59f2b10234300">psa_set_key_domain_parameters</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a> type, const uint8_t *data, size_t data_length)</td></tr>
-<tr class="memdesc:ga091da8d3d39137fd6ad59f2b10234300"><td class="mdescLeft"> </td><td class="mdescRight">Set domain parameters for a key. <a href="group__import__export.html#ga091da8d3d39137fd6ad59f2b10234300">More...</a><br /></td></tr>
-<tr class="separator:ga091da8d3d39137fd6ad59f2b10234300"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae260b92e32ac5d63f7dfc6ffdf6536f7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__import__export.html#gae260b92e32ac5d63f7dfc6ffdf6536f7">psa_get_key_domain_parameters</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, uint8_t *data, size_t data_size, size_t *data_length)</td></tr>
-<tr class="memdesc:gae260b92e32ac5d63f7dfc6ffdf6536f7"><td class="mdescLeft"> </td><td class="mdescRight">Get domain parameters for a key. <a href="group__import__export.html#gae260b92e32ac5d63f7dfc6ffdf6536f7">More...</a><br /></td></tr>
-<tr class="separator:gae260b92e32ac5d63f7dfc6ffdf6536f7"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga902b9a7a6cf34d6111668be777b05eaf"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__import__export.html#ga902b9a7a6cf34d6111668be777b05eaf">psa_export_key</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, uint8_t *data, size_t data_size, size_t *data_length)</td></tr>
-<tr class="memdesc:ga902b9a7a6cf34d6111668be777b05eaf"><td class="mdescLeft"> </td><td class="mdescRight">Export a key in binary format. <a href="group__import__export.html#ga902b9a7a6cf34d6111668be777b05eaf">More...</a><br /></td></tr>
-<tr class="separator:ga902b9a7a6cf34d6111668be777b05eaf"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gad760d1f0d4e60972c78cbb4c8a528256"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__import__export.html#gad760d1f0d4e60972c78cbb4c8a528256">psa_export_public_key</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, uint8_t *data, size_t data_size, size_t *data_length)</td></tr>
-<tr class="memdesc:gad760d1f0d4e60972c78cbb4c8a528256"><td class="mdescLeft"> </td><td class="mdescRight">Export a public key or the public part of a key pair in binary format. <a href="group__import__export.html#gad760d1f0d4e60972c78cbb4c8a528256">More...</a><br /></td></tr>
-<tr class="separator:gad760d1f0d4e60972c78cbb4c8a528256"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga5c1c24176cfb1517a8806235b3162a9d"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__import__export.html#ga5c1c24176cfb1517a8806235b3162a9d">psa_copy_key</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> source_handle, <a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> target_handle, const <a class="el" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a> *constraint)</td></tr>
-<tr class="separator:ga5c1c24176cfb1517a8806235b3162a9d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac69f7f19d96a56c28cf3799d11b12156"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__hash.html#gac69f7f19d96a56c28cf3799d11b12156">psa_hash_compute</a> (<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg, const uint8_t *input, size_t input_length, uint8_t *hash, size_t hash_size, size_t *hash_length)</td></tr>
-<tr class="separator:gac69f7f19d96a56c28cf3799d11b12156"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga0bb6dbd3c310648c3cf7d202413ff0bc"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__hash.html#ga0bb6dbd3c310648c3cf7d202413ff0bc">psa_hash_compare</a> (<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg, const uint8_t *input, size_t input_length, const uint8_t *hash, const size_t hash_length)</td></tr>
-<tr class="separator:ga0bb6dbd3c310648c3cf7d202413ff0bc"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga8d72896cf70fc4d514c5c6b978912515"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__hash.html#ga8d72896cf70fc4d514c5c6b978912515">psa_hash_setup</a> (<a class="el" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> *operation, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg)</td></tr>
-<tr class="separator:ga8d72896cf70fc4d514c5c6b978912515"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga65b16ef97d7f650899b7db4b7d1112ff"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__hash.html#ga65b16ef97d7f650899b7db4b7d1112ff">psa_hash_update</a> (<a class="el" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> *operation, const uint8_t *input, size_t input_length)</td></tr>
-<tr class="separator:ga65b16ef97d7f650899b7db4b7d1112ff"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4795fd06a0067b0adcd92e9627b8c97e"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__hash.html#ga4795fd06a0067b0adcd92e9627b8c97e">psa_hash_finish</a> (<a class="el" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> *operation, uint8_t *hash, size_t hash_size, size_t *hash_length)</td></tr>
-<tr class="separator:ga4795fd06a0067b0adcd92e9627b8c97e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga7be923c5700c9c70ef77ee9b76d1a5c0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__hash.html#ga7be923c5700c9c70ef77ee9b76d1a5c0">psa_hash_verify</a> (<a class="el" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> *operation, const uint8_t *hash, size_t hash_length)</td></tr>
-<tr class="separator:ga7be923c5700c9c70ef77ee9b76d1a5c0"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab0b4d5f9912a615559497a467b532928"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__hash.html#gab0b4d5f9912a615559497a467b532928">psa_hash_abort</a> (<a class="el" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> *operation)</td></tr>
-<tr class="separator:gab0b4d5f9912a615559497a467b532928"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga39673348f3302b4646bd780034a5aeda"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__hash.html#ga39673348f3302b4646bd780034a5aeda">psa_hash_clone</a> (const <a class="el" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> *source_operation, <a class="el" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> *target_operation)</td></tr>
-<tr class="separator:ga39673348f3302b4646bd780034a5aeda"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gace78d9b51394f9d4f77952963665897a"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__MAC.html#gace78d9b51394f9d4f77952963665897a">psa_mac_compute</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg, const uint8_t *input, size_t input_length, uint8_t *mac, size_t mac_size, size_t *mac_length)</td></tr>
-<tr class="separator:gace78d9b51394f9d4f77952963665897a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga08e2e8c21bfe762a907266f3bdd1d07c"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__MAC.html#ga08e2e8c21bfe762a907266f3bdd1d07c">psa_mac_verify</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg, const uint8_t *input, size_t input_length, const uint8_t *mac, const size_t mac_length)</td></tr>
-<tr class="separator:ga08e2e8c21bfe762a907266f3bdd1d07c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gad33f2b15119593571ca6b8e7c757ab0e"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__MAC.html#gad33f2b15119593571ca6b8e7c757ab0e">psa_mac_sign_setup</a> (<a class="el" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a> *operation, <a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg)</td></tr>
-<tr class="separator:gad33f2b15119593571ca6b8e7c757ab0e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa721a59ae6d085ec90c7dc918879a027"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__MAC.html#gaa721a59ae6d085ec90c7dc918879a027">psa_mac_verify_setup</a> (<a class="el" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a> *operation, <a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg)</td></tr>
-<tr class="separator:gaa721a59ae6d085ec90c7dc918879a027"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga5560af371497babefe03c9da4e8a1c05"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__MAC.html#ga5560af371497babefe03c9da4e8a1c05">psa_mac_update</a> (<a class="el" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a> *operation, const uint8_t *input, size_t input_length)</td></tr>
-<tr class="separator:ga5560af371497babefe03c9da4e8a1c05"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac22bc0125580c96724a09226cfbc97f2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__MAC.html#gac22bc0125580c96724a09226cfbc97f2">psa_mac_sign_finish</a> (<a class="el" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a> *operation, uint8_t *mac, size_t mac_size, size_t *mac_length)</td></tr>
-<tr class="separator:gac22bc0125580c96724a09226cfbc97f2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac92b2930d6728e1be4d011c05d485822"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__MAC.html#gac92b2930d6728e1be4d011c05d485822">psa_mac_verify_finish</a> (<a class="el" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a> *operation, const uint8_t *mac, size_t mac_length)</td></tr>
-<tr class="separator:gac92b2930d6728e1be4d011c05d485822"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gacd8dd54855ba1bc0a03f104f252884fd"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__MAC.html#gacd8dd54855ba1bc0a03f104f252884fd">psa_mac_abort</a> (<a class="el" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a> *operation)</td></tr>
-<tr class="separator:gacd8dd54855ba1bc0a03f104f252884fd"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac76dda492d9a1ba6b327bff610ec17b2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__cipher.html#gac76dda492d9a1ba6b327bff610ec17b2">psa_cipher_encrypt</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg, const uint8_t *input, size_t input_length, uint8_t *output, size_t output_size, size_t *output_length)</td></tr>
-<tr class="separator:gac76dda492d9a1ba6b327bff610ec17b2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga43d5991711ec45c98af0c1d99f6e0216"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__cipher.html#ga43d5991711ec45c98af0c1d99f6e0216">psa_cipher_decrypt</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg, const uint8_t *input, size_t input_length, uint8_t *output, size_t output_size, size_t *output_length)</td></tr>
-<tr class="separator:ga43d5991711ec45c98af0c1d99f6e0216"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga2a7fc79a9d150d42dba99f40ee3a185e"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__cipher.html#ga2a7fc79a9d150d42dba99f40ee3a185e">psa_cipher_encrypt_setup</a> (<a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> *operation, <a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg)</td></tr>
-<tr class="separator:ga2a7fc79a9d150d42dba99f40ee3a185e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaddf8504e5367cd0efb4415bdec004f44"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__cipher.html#gaddf8504e5367cd0efb4415bdec004f44">psa_cipher_decrypt_setup</a> (<a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> *operation, <a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg)</td></tr>
-<tr class="separator:gaddf8504e5367cd0efb4415bdec004f44"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga44857cf5e0c3d134a3c560f8ff5b50aa"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__cipher.html#ga44857cf5e0c3d134a3c560f8ff5b50aa">psa_cipher_generate_iv</a> (<a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> *operation, unsigned char *iv, size_t iv_size, size_t *iv_length)</td></tr>
-<tr class="separator:ga44857cf5e0c3d134a3c560f8ff5b50aa"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1359b2101f31637496ce7cc36c6e3d42"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__cipher.html#ga1359b2101f31637496ce7cc36c6e3d42">psa_cipher_set_iv</a> (<a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> *operation, const unsigned char *iv, size_t iv_length)</td></tr>
-<tr class="separator:ga1359b2101f31637496ce7cc36c6e3d42"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gafd0caea99cf1052527e4089d37f5ab91"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__cipher.html#gafd0caea99cf1052527e4089d37f5ab91">psa_cipher_update</a> (<a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> *operation, const uint8_t *input, size_t input_length, unsigned char *output, size_t output_size, size_t *output_length)</td></tr>
-<tr class="separator:gafd0caea99cf1052527e4089d37f5ab91"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1dcb58b8befe23f8a4d7a1d49c99249b"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__cipher.html#ga1dcb58b8befe23f8a4d7a1d49c99249b">psa_cipher_finish</a> (<a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> *operation, uint8_t *output, size_t output_size, size_t *output_length)</td></tr>
-<tr class="separator:ga1dcb58b8befe23f8a4d7a1d49c99249b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaad482cdca2098bca0620596aaa02eaa4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__cipher.html#gaad482cdca2098bca0620596aaa02eaa4">psa_cipher_abort</a> (<a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> *operation)</td></tr>
-<tr class="separator:gaad482cdca2098bca0620596aaa02eaa4"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga44de092cf58bb6c820c5c80a6c51610d"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__aead.html#ga44de092cf58bb6c820c5c80a6c51610d">psa_aead_encrypt</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg, const uint8_t *nonce, size_t nonce_length, const uint8_t *additional_data, size_t additional_data_length, const uint8_t *plaintext, size_t plaintext_length, uint8_t *ciphertext, size_t ciphertext_size, size_t *ciphertext_length)</td></tr>
-<tr class="separator:ga44de092cf58bb6c820c5c80a6c51610d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa8ce6527f2e227f1071fadbf2099793b"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__aead.html#gaa8ce6527f2e227f1071fadbf2099793b">psa_aead_decrypt</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg, const uint8_t *nonce, size_t nonce_length, const uint8_t *additional_data, size_t additional_data_length, const uint8_t *ciphertext, size_t ciphertext_length, uint8_t *plaintext, size_t plaintext_size, size_t *plaintext_length)</td></tr>
-<tr class="separator:gaa8ce6527f2e227f1071fadbf2099793b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga47265dc4852f1476f852752218fd12b2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__aead.html#ga47265dc4852f1476f852752218fd12b2">psa_aead_encrypt_setup</a> (<a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation, <a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg)</td></tr>
-<tr class="separator:ga47265dc4852f1476f852752218fd12b2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga439896519d4a367ec86b47f201884152"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__aead.html#ga439896519d4a367ec86b47f201884152">psa_aead_decrypt_setup</a> (<a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation, <a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg)</td></tr>
-<tr class="separator:ga439896519d4a367ec86b47f201884152"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga3eadcf2a29f662129ea4fb3454969ba2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__aead.html#ga3eadcf2a29f662129ea4fb3454969ba2">psa_aead_generate_nonce</a> (<a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation, unsigned char *nonce, size_t nonce_size, size_t *nonce_length)</td></tr>
-<tr class="separator:ga3eadcf2a29f662129ea4fb3454969ba2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga40641d0721ca7fe01bbcd9ef635fbc46"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__aead.html#ga40641d0721ca7fe01bbcd9ef635fbc46">psa_aead_set_nonce</a> (<a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation, const unsigned char *nonce, size_t nonce_length)</td></tr>
-<tr class="separator:ga40641d0721ca7fe01bbcd9ef635fbc46"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gad3431e28d05002c2a7b0760610176050"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__aead.html#gad3431e28d05002c2a7b0760610176050">psa_aead_set_lengths</a> (<a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation, size_t ad_length, size_t plaintext_length)</td></tr>
-<tr class="separator:gad3431e28d05002c2a7b0760610176050"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6d0eed03f832e5c9c91cb8adf2882569"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__aead.html#ga6d0eed03f832e5c9c91cb8adf2882569">psa_aead_update_ad</a> (<a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation, const uint8_t *input, size_t input_length)</td></tr>
-<tr class="separator:ga6d0eed03f832e5c9c91cb8adf2882569"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga3b105de2088cef7c3d9e2fd8048c841c"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__aead.html#ga3b105de2088cef7c3d9e2fd8048c841c">psa_aead_update</a> (<a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation, const uint8_t *input, size_t input_length, unsigned char *output, size_t output_size, size_t *output_length)</td></tr>
-<tr class="separator:ga3b105de2088cef7c3d9e2fd8048c841c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga759791bbe1763b377c3b5447641f1fc8"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__aead.html#ga759791bbe1763b377c3b5447641f1fc8">psa_aead_finish</a> (<a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation, uint8_t *ciphertext, size_t ciphertext_size, size_t *ciphertext_length, uint8_t *tag, size_t tag_size, size_t *tag_length)</td></tr>
-<tr class="separator:ga759791bbe1763b377c3b5447641f1fc8"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaaed211fc61977c859d6ff07f39f59219"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__aead.html#gaaed211fc61977c859d6ff07f39f59219">psa_aead_verify</a> (<a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation, const uint8_t *tag, size_t tag_length)</td></tr>
-<tr class="separator:gaaed211fc61977c859d6ff07f39f59219"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae8a5f93d92318c8f592ee9fbb9d36ba0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__aead.html#gae8a5f93d92318c8f592ee9fbb9d36ba0">psa_aead_abort</a> (<a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation)</td></tr>
-<tr class="separator:gae8a5f93d92318c8f592ee9fbb9d36ba0"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1b0db9d345b5048cdd39357ac2d56c07"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__asymmetric.html#ga1b0db9d345b5048cdd39357ac2d56c07">psa_asymmetric_sign</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg, const uint8_t *hash, size_t hash_length, uint8_t *signature, size_t signature_size, size_t *signature_length)</td></tr>
-<tr class="memdesc:ga1b0db9d345b5048cdd39357ac2d56c07"><td class="mdescLeft"> </td><td class="mdescRight">Sign a hash or short message with a private key. <a href="group__asymmetric.html#ga1b0db9d345b5048cdd39357ac2d56c07">More...</a><br /></td></tr>
-<tr class="separator:ga1b0db9d345b5048cdd39357ac2d56c07"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1b8e964c8d927e3d632325d762959eb7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__asymmetric.html#ga1b8e964c8d927e3d632325d762959eb7">psa_asymmetric_verify</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg, const uint8_t *hash, size_t hash_length, const uint8_t *signature, size_t signature_length)</td></tr>
-<tr class="memdesc:ga1b8e964c8d927e3d632325d762959eb7"><td class="mdescLeft"> </td><td class="mdescRight">Verify the signature a hash or short message using a public key. <a href="group__asymmetric.html#ga1b8e964c8d927e3d632325d762959eb7">More...</a><br /></td></tr>
-<tr class="separator:ga1b8e964c8d927e3d632325d762959eb7"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gad429293b7b0bf2a830b9540a02552004"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__asymmetric.html#gad429293b7b0bf2a830b9540a02552004">psa_asymmetric_encrypt</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg, const uint8_t *input, size_t input_length, const uint8_t *salt, size_t salt_length, uint8_t *output, size_t output_size, size_t *output_length)</td></tr>
-<tr class="memdesc:gad429293b7b0bf2a830b9540a02552004"><td class="mdescLeft"> </td><td class="mdescRight">Encrypt a short message with a public key. <a href="group__asymmetric.html#gad429293b7b0bf2a830b9540a02552004">More...</a><br /></td></tr>
-<tr class="separator:gad429293b7b0bf2a830b9540a02552004"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga34b55fbaee23dba1a677186fc66a556e"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__asymmetric.html#ga34b55fbaee23dba1a677186fc66a556e">psa_asymmetric_decrypt</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg, const uint8_t *input, size_t input_length, const uint8_t *salt, size_t salt_length, uint8_t *output, size_t output_size, size_t *output_length)</td></tr>
-<tr class="memdesc:ga34b55fbaee23dba1a677186fc66a556e"><td class="mdescLeft"> </td><td class="mdescRight">Decrypt a short message with a private key. <a href="group__asymmetric.html#ga34b55fbaee23dba1a677186fc66a556e">More...</a><br /></td></tr>
-<tr class="separator:ga34b55fbaee23dba1a677186fc66a556e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga7453491e3b440193be2c5dccc2040fd2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__generators.html#ga7453491e3b440193be2c5dccc2040fd2">psa_get_generator_capacity</a> (const <a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> *generator, size_t *capacity)</td></tr>
-<tr class="separator:ga7453491e3b440193be2c5dccc2040fd2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga45676ec3c719622f95caaf926f44bb6e"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__generators.html#ga45676ec3c719622f95caaf926f44bb6e">psa_set_generator_capacity</a> (<a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> *generator, size_t capacity)</td></tr>
-<tr class="separator:ga45676ec3c719622f95caaf926f44bb6e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab5712ad29b78c2b170e64cc5bcfc1bce"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__generators.html#gab5712ad29b78c2b170e64cc5bcfc1bce">psa_generator_read</a> (<a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> *generator, uint8_t *output, size_t output_length)</td></tr>
-<tr class="separator:gab5712ad29b78c2b170e64cc5bcfc1bce"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga7fcdf07cd37279ca167db484053da894"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__generators.html#ga7fcdf07cd37279ca167db484053da894">psa_generator_import_key</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a> type, size_t bits, <a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> *generator)</td></tr>
-<tr class="separator:ga7fcdf07cd37279ca167db484053da894"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga563ca64537d90368899286b36d8cf7f3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__generators.html#ga563ca64537d90368899286b36d8cf7f3">psa_generator_abort</a> (<a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> *generator)</td></tr>
-<tr class="separator:ga563ca64537d90368899286b36d8cf7f3"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1825696be813dfac2b8d3d02717e71c5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__derivation.html#ga1825696be813dfac2b8d3d02717e71c5">psa_key_derivation_setup</a> (<a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> *generator, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg)</td></tr>
-<tr class="separator:ga1825696be813dfac2b8d3d02717e71c5"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1b30e888db65c71f5337900848e1b03f"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__derivation.html#ga1b30e888db65c71f5337900848e1b03f">psa_key_derivation_input_bytes</a> (<a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> *generator, <a class="el" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">psa_key_derivation_step_t</a> step, const uint8_t *data, size_t data_length)</td></tr>
-<tr class="separator:ga1b30e888db65c71f5337900848e1b03f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga9e5f549aa1f6f3863a07008d3d98f91a"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__derivation.html#ga9e5f549aa1f6f3863a07008d3d98f91a">psa_key_derivation_input_key</a> (<a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> *generator, <a class="el" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">psa_key_derivation_step_t</a> step, <a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle)</td></tr>
-<tr class="separator:ga9e5f549aa1f6f3863a07008d3d98f91a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga2c7fe304cacc141ffb91553548abc5d2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__derivation.html#ga2c7fe304cacc141ffb91553548abc5d2">psa_key_agreement</a> (<a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> *generator, <a class="el" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">psa_key_derivation_step_t</a> step, <a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> private_key, const uint8_t *peer_key, size_t peer_key_length)</td></tr>
-<tr class="separator:ga2c7fe304cacc141ffb91553548abc5d2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaf1b12eff66a1a0020b5bdc8d0e910006"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__derivation.html#gaf1b12eff66a1a0020b5bdc8d0e910006">psa_key_agreement_raw_shared_secret</a> (<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg, <a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> private_key, const uint8_t *peer_key, size_t peer_key_length, uint8_t *output, size_t output_size, size_t *output_length)</td></tr>
-<tr class="separator:gaf1b12eff66a1a0020b5bdc8d0e910006"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1985eae417dfbccedf50d5fff54ea8c5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__random.html#ga1985eae417dfbccedf50d5fff54ea8c5">psa_generate_random</a> (uint8_t *output, size_t output_size)</td></tr>
-<tr class="memdesc:ga1985eae417dfbccedf50d5fff54ea8c5"><td class="mdescLeft"> </td><td class="mdescRight">Generate random bytes. <a href="group__random.html#ga1985eae417dfbccedf50d5fff54ea8c5">More...</a><br /></td></tr>
-<tr class="separator:ga1985eae417dfbccedf50d5fff54ea8c5"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga72921520494b4f007a3afb904cd9ecdd"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__random.html#ga72921520494b4f007a3afb904cd9ecdd">psa_generate_key</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a> type, size_t bits, const void *extra, size_t extra_size)</td></tr>
-<tr class="memdesc:ga72921520494b4f007a3afb904cd9ecdd"><td class="mdescLeft"> </td><td class="mdescRight">Generate a key or key pair. <a href="group__random.html#ga72921520494b4f007a3afb904cd9ecdd">More...</a><br /></td></tr>
-<tr class="separator:ga72921520494b4f007a3afb904cd9ecdd"><td class="memSeparator" colspan="2"> </td></tr>
-</table>
-<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
-<div class="textblock"><p>Platform Security Architecture cryptography module. </p>
-</div></div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/crypto_8h__incl.map b/docs/html/crypto_8h__incl.map
deleted file mode 100644
index 1ed73ed..0000000
--- a/docs/html/crypto_8h__incl.map
+++ /dev/null
@@ -1,5 +0,0 @@
-<map id="psa/crypto.h" name="psa/crypto.h">
-<area shape="rect" id="node8" href="$crypto__types_8h.html" title="PSA cryptography module: type aliases. " alt="" coords="763,102,871,129"/>
-<area shape="rect" id="node9" href="$crypto__values_8h.html" title="PSA cryptography module: macros to build and analyze integer values. " alt="" coords="896,102,1011,129"/>
-<area shape="rect" id="node10" href="$crypto__sizes_8h.html" title="PSA cryptography module: Mbed TLS buffer size macros. " alt="" coords="1035,102,1141,129"/>
-</map>
diff --git a/docs/html/crypto_8h__incl.md5 b/docs/html/crypto_8h__incl.md5
deleted file mode 100644
index 4e6059e..0000000
--- a/docs/html/crypto_8h__incl.md5
+++ /dev/null
@@ -1 +0,0 @@
-074e89e7e237fada4ce8156df08ea036
\ No newline at end of file
diff --git a/docs/html/crypto_8h__incl.png b/docs/html/crypto_8h__incl.png
deleted file mode 100644
index 520e3e9..0000000
--- a/docs/html/crypto_8h__incl.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/crypto_8h_source.html b/docs/html/crypto_8h_source.html
deleted file mode 100644
index f1d6037..0000000
--- a/docs/html/crypto_8h_source.html
+++ /dev/null
@@ -1,192 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: psa/crypto.h Source File</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li class="current"><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
- <div id="navrow2" class="tabs2">
- <ul class="tablist">
- <li><a href="files.html"><span>File List</span></a></li>
- <li><a href="globals.html"><span>File Members</span></a></li>
- </ul>
- </div>
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div id="nav-path" class="navpath">
- <ul>
-<li class="navelem"><a class="el" href="dir_7dae9cfde651cd3cb034485ce5e391b9.html">psa</a></li> </ul>
-</div>
-</div><!-- top -->
-<div class="header">
- <div class="headertitle">
-<div class="title">crypto.h</div> </div>
-</div><!--header-->
-<div class="contents">
-<a href="crypto_8h.html">Go to the documentation of this file.</a><div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> </div><div class="line"><a name="l00005"></a><span class="lineno"> 5</span> <span class="comment">/*</span></div><div class="line"><a name="l00006"></a><span class="lineno"> 6</span> <span class="comment"> * Copyright (C) 2018, ARM Limited, All Rights Reserved</span></div><div class="line"><a name="l00007"></a><span class="lineno"> 7</span> <span class="comment"> * SPDX-License-Identifier: Apache-2.0</span></div><div class="line"><a name="l00008"></a><span class="lineno"> 8</span> <span class="comment"> *</span></div><div class="line"><a name="l00009"></a><span class="lineno"> 9</span> <span class="comment"> * Licensed under the Apache License, Version 2.0 (the "License"); you may</span></div><div class="line"><a name="l00010"></a><span class="lineno"> 10</span> <span class="comment"> * not use this file except in compliance with the License.</span></div><div class="line"><a name="l00011"></a><span class="lineno"> 11</span> <span class="comment"> * You may obtain a copy of the License at</span></div><div class="line"><a name="l00012"></a><span class="lineno"> 12</span> <span class="comment"> *</span></div><div class="line"><a name="l00013"></a><span class="lineno"> 13</span> <span class="comment"> * http://www.apache.org/licenses/LICENSE-2.0</span></div><div class="line"><a name="l00014"></a><span class="lineno"> 14</span> <span class="comment"> *</span></div><div class="line"><a name="l00015"></a><span class="lineno"> 15</span> <span class="comment"> * Unless required by applicable law or agreed to in writing, software</span></div><div class="line"><a name="l00016"></a><span class="lineno"> 16</span> <span class="comment"> * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT</span></div><div class="line"><a name="l00017"></a><span class="lineno"> 17</span> <span class="comment"> * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.</span></div><div class="line"><a name="l00018"></a><span class="lineno"> 18</span> <span class="comment"> * See the License for the specific language governing permissions and</span></div><div class="line"><a name="l00019"></a><span class="lineno"> 19</span> <span class="comment"> * limitations under the License.</span></div><div class="line"><a name="l00020"></a><span class="lineno"> 20</span> <span class="comment"> */</span></div><div class="line"><a name="l00021"></a><span class="lineno"> 21</span> </div><div class="line"><a name="l00022"></a><span class="lineno"> 22</span> <span class="preprocessor">#ifndef PSA_CRYPTO_H</span></div><div class="line"><a name="l00023"></a><span class="lineno"> 23</span> <span class="preprocessor">#define PSA_CRYPTO_H</span></div><div class="line"><a name="l00024"></a><span class="lineno"> 24</span> </div><div class="line"><a name="l00025"></a><span class="lineno"> 25</span> <span class="preprocessor">#include "crypto_platform.h"</span></div><div class="line"><a name="l00026"></a><span class="lineno"> 26</span> </div><div class="line"><a name="l00027"></a><span class="lineno"> 27</span> <span class="preprocessor">#include <stddef.h></span></div><div class="line"><a name="l00028"></a><span class="lineno"> 28</span> </div><div class="line"><a name="l00029"></a><span class="lineno"> 29</span> <span class="preprocessor">#ifdef __DOXYGEN_ONLY__</span></div><div class="line"><a name="l00030"></a><span class="lineno"> 30</span> <span class="comment">/* This __DOXYGEN_ONLY__ block contains mock definitions for things that</span></div><div class="line"><a name="l00031"></a><span class="lineno"> 31</span> <span class="comment"> * must be defined in the crypto_platform.h header. These mock definitions</span></div><div class="line"><a name="l00032"></a><span class="lineno"> 32</span> <span class="comment"> * are present in this file as a convenience to generate pretty-printed</span></div><div class="line"><a name="l00033"></a><span class="lineno"> 33</span> <span class="comment"> * documentation that includes those definitions. */</span></div><div class="line"><a name="l00034"></a><span class="lineno"> 34</span> </div><div class="line"><a name="l00047"></a><span class="lineno"><a class="line" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75"> 47</a></span> <span class="keyword">typedef</span> _unsigned_integral_type_ <a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a>;</div><div class="line"><a name="l00048"></a><span class="lineno"> 48</span> </div><div class="line"><a name="l00050"></a><span class="lineno"> 50</span> <span class="preprocessor">#endif </span><span class="comment">/* __DOXYGEN_ONLY__ */</span><span class="preprocessor"></span></div><div class="line"><a name="l00051"></a><span class="lineno"> 51</span> </div><div class="line"><a name="l00052"></a><span class="lineno"> 52</span> <span class="preprocessor">#ifdef __cplusplus</span></div><div class="line"><a name="l00053"></a><span class="lineno"> 53</span> <span class="keyword">extern</span> <span class="stringliteral">"C"</span> {</div><div class="line"><a name="l00054"></a><span class="lineno"> 54</span> <span class="preprocessor">#endif</span></div><div class="line"><a name="l00055"></a><span class="lineno"> 55</span> </div><div class="line"><a name="l00056"></a><span class="lineno"> 56</span> <span class="comment">/* The file "crypto_types.h" declares types that encode errors,</span></div><div class="line"><a name="l00057"></a><span class="lineno"> 57</span> <span class="comment"> * algorithms, key types, policies, etc. */</span></div><div class="line"><a name="l00058"></a><span class="lineno"> 58</span> <span class="preprocessor">#include "<a class="code" href="crypto__types_8h.html">crypto_types.h</a>"</span></div><div class="line"><a name="l00059"></a><span class="lineno"> 59</span> </div><div class="line"><a name="l00060"></a><span class="lineno"> 60</span> <span class="comment">/* The file "crypto_values.h" declares macros to build and analyze values</span></div><div class="line"><a name="l00061"></a><span class="lineno"> 61</span> <span class="comment"> * of integral types defined in "crypto_types.h". */</span></div><div class="line"><a name="l00062"></a><span class="lineno"> 62</span> <span class="preprocessor">#include "<a class="code" href="crypto__values_8h.html">crypto_values.h</a>"</span></div><div class="line"><a name="l00063"></a><span class="lineno"> 63</span> </div><div class="line"><a name="l00092"></a><span class="lineno"> 92</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9">psa_crypto_init</a>(<span class="keywordtype">void</span>);</div><div class="line"><a name="l00093"></a><span class="lineno"> 93</span> </div><div class="line"><a name="l00128"></a><span class="lineno"><a class="line" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607"> 128</a></span> <span class="keyword">typedef</span> <span class="keyword">struct </span>psa_key_policy_s <a class="code" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a>;</div><div class="line"><a name="l00129"></a><span class="lineno"> 129</span> </div><div class="line"><a name="l00135"></a><span class="lineno"> 135</span> <span class="preprocessor">#ifdef __DOXYGEN_ONLY__</span></div><div class="line"><a name="l00136"></a><span class="lineno"> 136</span> <span class="comment">/* This is an example definition for documentation purposes.</span></div><div class="line"><a name="l00137"></a><span class="lineno"> 137</span> <span class="comment"> * Implementations should define a suitable value in `crypto_struct.h`.</span></div><div class="line"><a name="l00138"></a><span class="lineno"> 138</span> <span class="comment"> */</span></div><div class="line"><a name="l00139"></a><span class="lineno"><a class="line" href="group__policy.html#ga5e6bc5f550e88fdc7790f2a75e79f7c5"> 139</a></span> <span class="preprocessor">#define PSA_KEY_POLICY_INIT {0}</span></div><div class="line"><a name="l00140"></a><span class="lineno"> 140</span> <span class="preprocessor">#endif</span></div><div class="line"><a name="l00141"></a><span class="lineno"> 141</span> </div><div class="line"><a name="l00144"></a><span class="lineno"> 144</span> <span class="keyword">static</span> <a class="code" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a> psa_key_policy_init(<span class="keywordtype">void</span>);</div><div class="line"><a name="l00145"></a><span class="lineno"> 145</span> </div><div class="line"><a name="l00158"></a><span class="lineno"> 158</span> <span class="keywordtype">void</span> <a class="code" href="group__policy.html#gac16792fd6d375a5f76d372090df40607">psa_key_policy_set_usage</a>(<a class="code" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a> *policy,</div><div class="line"><a name="l00159"></a><span class="lineno"> 159</span>  <a class="code" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a> usage,</div><div class="line"><a name="l00160"></a><span class="lineno"> 160</span>  <a class="code" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg);</div><div class="line"><a name="l00161"></a><span class="lineno"> 161</span> </div><div class="line"><a name="l00168"></a><span class="lineno"> 168</span> <a class="code" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a> <a class="code" href="group__policy.html#ga7746662b7503e484774d0ecb5d8ac2ab">psa_key_policy_get_usage</a>(<span class="keyword">const</span> <a class="code" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a> *policy);</div><div class="line"><a name="l00169"></a><span class="lineno"> 169</span> </div><div class="line"><a name="l00176"></a><span class="lineno"> 176</span> <a class="code" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> <a class="code" href="group__policy.html#gaadf16b89ace53e1d2cb5bcb0aef24c86">psa_key_policy_get_algorithm</a>(<span class="keyword">const</span> <a class="code" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a> *policy);</div><div class="line"><a name="l00177"></a><span class="lineno"> 177</span> </div><div class="line"><a name="l00207"></a><span class="lineno"> 207</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__policy.html#ga1e2a6e50b621864f95d438222a3c640b">psa_set_key_policy</a>(<a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle,</div><div class="line"><a name="l00208"></a><span class="lineno"> 208</span>  <span class="keyword">const</span> <a class="code" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a> *policy);</div><div class="line"><a name="l00209"></a><span class="lineno"> 209</span> </div><div class="line"><a name="l00225"></a><span class="lineno"> 225</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__policy.html#gaed087d1386b807edee66b2e445ba9111">psa_get_key_policy</a>(<a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle,</div><div class="line"><a name="l00226"></a><span class="lineno"> 226</span>  <a class="code" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a> *policy);</div><div class="line"><a name="l00227"></a><span class="lineno"> 227</span> </div><div class="line"><a name="l00250"></a><span class="lineno"> 250</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__key__management.html#ga1e4825ab59260aeb3bdbb3ff07210022">psa_get_key_lifetime</a>(<a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle,</div><div class="line"><a name="l00251"></a><span class="lineno"> 251</span>  <a class="code" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">psa_key_lifetime_t</a> *lifetime);</div><div class="line"><a name="l00252"></a><span class="lineno"> 252</span> </div><div class="line"><a name="l00253"></a><span class="lineno"> 253</span> </div><div class="line"><a name="l00270"></a><span class="lineno"> 270</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__key__management.html#ga40094b77b7a42b9c8e158395113f1a35">psa_allocate_key</a>(<a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> *handle);</div><div class="line"><a name="l00271"></a><span class="lineno"> 271</span> </div><div class="line"><a name="l00301"></a><span class="lineno"> 301</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__key__management.html#gaa9f1c848cf78b80fe2a7b18bb7ccec50">psa_open_key</a>(<a class="code" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">psa_key_lifetime_t</a> lifetime,</div><div class="line"><a name="l00302"></a><span class="lineno"> 302</span>  <a class="code" href="group__key__lifetimes.html#ga11e986351c65bd3dc3c0fe2cd9926e4b">psa_key_id_t</a> <span class="keywordtype">id</span>,</div><div class="line"><a name="l00303"></a><span class="lineno"> 303</span>  <a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> *handle);</div><div class="line"><a name="l00304"></a><span class="lineno"> 304</span> </div><div class="line"><a name="l00338"></a><span class="lineno"> 338</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__key__management.html#ga4108f255d3eaa6d23a7a14b684af8d7c">psa_create_key</a>(<a class="code" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">psa_key_lifetime_t</a> lifetime,</div><div class="line"><a name="l00339"></a><span class="lineno"> 339</span>  <a class="code" href="group__key__lifetimes.html#ga11e986351c65bd3dc3c0fe2cd9926e4b">psa_key_id_t</a> <span class="keywordtype">id</span>,</div><div class="line"><a name="l00340"></a><span class="lineno"> 340</span>  <a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> *handle);</div><div class="line"><a name="l00341"></a><span class="lineno"> 341</span> </div><div class="line"><a name="l00360"></a><span class="lineno"> 360</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__key__management.html#gaa09b720d299dfe6b9f41c36e448078eb">psa_close_key</a>(<a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle);</div><div class="line"><a name="l00361"></a><span class="lineno"> 361</span> </div><div class="line"><a name="l00420"></a><span class="lineno"> 420</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__import__export.html#gac9f999cb4d098663d56095afe81a453a">psa_import_key</a>(<a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle,</div><div class="line"><a name="l00421"></a><span class="lineno"> 421</span>  <a class="code" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a> type,</div><div class="line"><a name="l00422"></a><span class="lineno"> 422</span>  <span class="keyword">const</span> uint8_t *data,</div><div class="line"><a name="l00423"></a><span class="lineno"> 423</span>  <span class="keywordtype">size_t</span> data_length);</div><div class="line"><a name="l00424"></a><span class="lineno"> 424</span> </div><div class="line"><a name="l00464"></a><span class="lineno"> 464</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__import__export.html#ga165085fc1bc7a78b91792fdd94ae102c">psa_destroy_key</a>(<a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle);</div><div class="line"><a name="l00465"></a><span class="lineno"> 465</span> </div><div class="line"><a name="l00489"></a><span class="lineno"> 489</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__import__export.html#gae8939902d6977ea8ad13eb7b4db9a042">psa_get_key_information</a>(<a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle,</div><div class="line"><a name="l00490"></a><span class="lineno"> 490</span>  <a class="code" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a> *type,</div><div class="line"><a name="l00491"></a><span class="lineno"> 491</span>  <span class="keywordtype">size_t</span> *bits);</div><div class="line"><a name="l00492"></a><span class="lineno"> 492</span> </div><div class="line"><a name="l00556"></a><span class="lineno"> 556</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__import__export.html#ga091da8d3d39137fd6ad59f2b10234300">psa_set_key_domain_parameters</a>(<a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle,</div><div class="line"><a name="l00557"></a><span class="lineno"> 557</span>  <a class="code" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a> type,</div><div class="line"><a name="l00558"></a><span class="lineno"> 558</span>  <span class="keyword">const</span> uint8_t *data,</div><div class="line"><a name="l00559"></a><span class="lineno"> 559</span>  <span class="keywordtype">size_t</span> data_length);</div><div class="line"><a name="l00560"></a><span class="lineno"> 560</span> </div><div class="line"><a name="l00588"></a><span class="lineno"> 588</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__import__export.html#gae260b92e32ac5d63f7dfc6ffdf6536f7">psa_get_key_domain_parameters</a>(<a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle,</div><div class="line"><a name="l00589"></a><span class="lineno"> 589</span>  uint8_t *data,</div><div class="line"><a name="l00590"></a><span class="lineno"> 590</span>  <span class="keywordtype">size_t</span> data_size,</div><div class="line"><a name="l00591"></a><span class="lineno"> 591</span>  <span class="keywordtype">size_t</span> *data_length);</div><div class="line"><a name="l00592"></a><span class="lineno"> 592</span> </div><div class="line"><a name="l00675"></a><span class="lineno"> 675</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__import__export.html#ga902b9a7a6cf34d6111668be777b05eaf">psa_export_key</a>(<a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle,</div><div class="line"><a name="l00676"></a><span class="lineno"> 676</span>  uint8_t *data,</div><div class="line"><a name="l00677"></a><span class="lineno"> 677</span>  <span class="keywordtype">size_t</span> data_size,</div><div class="line"><a name="l00678"></a><span class="lineno"> 678</span>  <span class="keywordtype">size_t</span> *data_length);</div><div class="line"><a name="l00679"></a><span class="lineno"> 679</span> </div><div class="line"><a name="l00744"></a><span class="lineno"> 744</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__import__export.html#gad760d1f0d4e60972c78cbb4c8a528256">psa_export_public_key</a>(<a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle,</div><div class="line"><a name="l00745"></a><span class="lineno"> 745</span>  uint8_t *data,</div><div class="line"><a name="l00746"></a><span class="lineno"> 746</span>  <span class="keywordtype">size_t</span> data_size,</div><div class="line"><a name="l00747"></a><span class="lineno"> 747</span>  <span class="keywordtype">size_t</span> *data_length);</div><div class="line"><a name="l00748"></a><span class="lineno"> 748</span> </div><div class="line"><a name="l00810"></a><span class="lineno"> 810</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__import__export.html#ga5c1c24176cfb1517a8806235b3162a9d">psa_copy_key</a>(<a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> source_handle,</div><div class="line"><a name="l00811"></a><span class="lineno"> 811</span>  <a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> target_handle,</div><div class="line"><a name="l00812"></a><span class="lineno"> 812</span>  <span class="keyword">const</span> <a class="code" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a> *constraint);</div><div class="line"><a name="l00813"></a><span class="lineno"> 813</span> </div><div class="line"><a name="l00844"></a><span class="lineno"> 844</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__hash.html#gac69f7f19d96a56c28cf3799d11b12156">psa_hash_compute</a>(<a class="code" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg,</div><div class="line"><a name="l00845"></a><span class="lineno"> 845</span>  <span class="keyword">const</span> uint8_t *input,</div><div class="line"><a name="l00846"></a><span class="lineno"> 846</span>  <span class="keywordtype">size_t</span> input_length,</div><div class="line"><a name="l00847"></a><span class="lineno"> 847</span>  uint8_t *hash,</div><div class="line"><a name="l00848"></a><span class="lineno"> 848</span>  <span class="keywordtype">size_t</span> hash_size,</div><div class="line"><a name="l00849"></a><span class="lineno"> 849</span>  <span class="keywordtype">size_t</span> *hash_length);</div><div class="line"><a name="l00850"></a><span class="lineno"> 850</span> </div><div class="line"><a name="l00873"></a><span class="lineno"> 873</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__hash.html#ga0bb6dbd3c310648c3cf7d202413ff0bc">psa_hash_compare</a>(<a class="code" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg,</div><div class="line"><a name="l00874"></a><span class="lineno"> 874</span>  <span class="keyword">const</span> uint8_t *input,</div><div class="line"><a name="l00875"></a><span class="lineno"> 875</span>  <span class="keywordtype">size_t</span> input_length,</div><div class="line"><a name="l00876"></a><span class="lineno"> 876</span>  <span class="keyword">const</span> uint8_t *hash,</div><div class="line"><a name="l00877"></a><span class="lineno"> 877</span>  <span class="keyword">const</span> <span class="keywordtype">size_t</span> hash_length);</div><div class="line"><a name="l00878"></a><span class="lineno"> 878</span> </div><div class="line"><a name="l00907"></a><span class="lineno"><a class="line" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab"> 907</a></span> <span class="keyword">typedef</span> <span class="keyword">struct </span>psa_hash_operation_s <a class="code" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a>;</div><div class="line"><a name="l00908"></a><span class="lineno"> 908</span> </div><div class="line"><a name="l00914"></a><span class="lineno"> 914</span> <span class="preprocessor">#ifdef __DOXYGEN_ONLY__</span></div><div class="line"><a name="l00915"></a><span class="lineno"> 915</span> <span class="comment">/* This is an example definition for documentation purposes.</span></div><div class="line"><a name="l00916"></a><span class="lineno"> 916</span> <span class="comment"> * Implementations should define a suitable value in `crypto_struct.h`.</span></div><div class="line"><a name="l00917"></a><span class="lineno"> 917</span> <span class="comment"> */</span></div><div class="line"><a name="l00918"></a><span class="lineno"><a class="line" href="group__hash.html#ga6ab7fe8d3500bc2f21be840b4f4f8d1d"> 918</a></span> <span class="preprocessor">#define PSA_HASH_OPERATION_INIT {0}</span></div><div class="line"><a name="l00919"></a><span class="lineno"> 919</span> <span class="preprocessor">#endif</span></div><div class="line"><a name="l00920"></a><span class="lineno"> 920</span> </div><div class="line"><a name="l00923"></a><span class="lineno"> 923</span> <span class="keyword">static</span> <a class="code" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> psa_hash_operation_init(<span class="keywordtype">void</span>);</div><div class="line"><a name="l00924"></a><span class="lineno"> 924</span> </div><div class="line"><a name="l00964"></a><span class="lineno"> 964</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__hash.html#ga8d72896cf70fc4d514c5c6b978912515">psa_hash_setup</a>(<a class="code" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> *operation,</div><div class="line"><a name="l00965"></a><span class="lineno"> 965</span>  <a class="code" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg);</div><div class="line"><a name="l00966"></a><span class="lineno"> 966</span> </div><div class="line"><a name="l00986"></a><span class="lineno"> 986</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__hash.html#ga65b16ef97d7f650899b7db4b7d1112ff">psa_hash_update</a>(<a class="code" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> *operation,</div><div class="line"><a name="l00987"></a><span class="lineno"> 987</span>  <span class="keyword">const</span> uint8_t *input,</div><div class="line"><a name="l00988"></a><span class="lineno"> 988</span>  <span class="keywordtype">size_t</span> input_length);</div><div class="line"><a name="l00989"></a><span class="lineno"> 989</span> </div><div class="line"><a name="l01027"></a><span class="lineno"> 1027</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__hash.html#ga4795fd06a0067b0adcd92e9627b8c97e">psa_hash_finish</a>(<a class="code" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> *operation,</div><div class="line"><a name="l01028"></a><span class="lineno"> 1028</span>  uint8_t *hash,</div><div class="line"><a name="l01029"></a><span class="lineno"> 1029</span>  <span class="keywordtype">size_t</span> hash_size,</div><div class="line"><a name="l01030"></a><span class="lineno"> 1030</span>  <span class="keywordtype">size_t</span> *hash_length);</div><div class="line"><a name="l01031"></a><span class="lineno"> 1031</span> </div><div class="line"><a name="l01063"></a><span class="lineno"> 1063</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__hash.html#ga7be923c5700c9c70ef77ee9b76d1a5c0">psa_hash_verify</a>(<a class="code" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> *operation,</div><div class="line"><a name="l01064"></a><span class="lineno"> 1064</span>  <span class="keyword">const</span> uint8_t *hash,</div><div class="line"><a name="l01065"></a><span class="lineno"> 1065</span>  <span class="keywordtype">size_t</span> hash_length);</div><div class="line"><a name="l01066"></a><span class="lineno"> 1066</span> </div><div class="line"><a name="l01094"></a><span class="lineno"> 1094</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__hash.html#gab0b4d5f9912a615559497a467b532928">psa_hash_abort</a>(<a class="code" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> *operation);</div><div class="line"><a name="l01095"></a><span class="lineno"> 1095</span> </div><div class="line"><a name="l01120"></a><span class="lineno"> 1120</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__hash.html#ga39673348f3302b4646bd780034a5aeda">psa_hash_clone</a>(<span class="keyword">const</span> <a class="code" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> *source_operation,</div><div class="line"><a name="l01121"></a><span class="lineno"> 1121</span>  <a class="code" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> *target_operation);</div><div class="line"><a name="l01122"></a><span class="lineno"> 1122</span> </div><div class="line"><a name="l01167"></a><span class="lineno"> 1167</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__MAC.html#gace78d9b51394f9d4f77952963665897a">psa_mac_compute</a>(<a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle,</div><div class="line"><a name="l01168"></a><span class="lineno"> 1168</span>  <a class="code" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg,</div><div class="line"><a name="l01169"></a><span class="lineno"> 1169</span>  <span class="keyword">const</span> uint8_t *input,</div><div class="line"><a name="l01170"></a><span class="lineno"> 1170</span>  <span class="keywordtype">size_t</span> input_length,</div><div class="line"><a name="l01171"></a><span class="lineno"> 1171</span>  uint8_t *mac,</div><div class="line"><a name="l01172"></a><span class="lineno"> 1172</span>  <span class="keywordtype">size_t</span> mac_size,</div><div class="line"><a name="l01173"></a><span class="lineno"> 1173</span>  <span class="keywordtype">size_t</span> *mac_length);</div><div class="line"><a name="l01174"></a><span class="lineno"> 1174</span> </div><div class="line"><a name="l01202"></a><span class="lineno"> 1202</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__MAC.html#ga08e2e8c21bfe762a907266f3bdd1d07c">psa_mac_verify</a>(<a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle,</div><div class="line"><a name="l01203"></a><span class="lineno"> 1203</span>  <a class="code" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg,</div><div class="line"><a name="l01204"></a><span class="lineno"> 1204</span>  <span class="keyword">const</span> uint8_t *input,</div><div class="line"><a name="l01205"></a><span class="lineno"> 1205</span>  <span class="keywordtype">size_t</span> input_length,</div><div class="line"><a name="l01206"></a><span class="lineno"> 1206</span>  <span class="keyword">const</span> uint8_t *mac,</div><div class="line"><a name="l01207"></a><span class="lineno"> 1207</span>  <span class="keyword">const</span> <span class="keywordtype">size_t</span> mac_length);</div><div class="line"><a name="l01208"></a><span class="lineno"> 1208</span> </div><div class="line"><a name="l01237"></a><span class="lineno"><a class="line" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37"> 1237</a></span> <span class="keyword">typedef</span> <span class="keyword">struct </span>psa_mac_operation_s <a class="code" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a>;</div><div class="line"><a name="l01238"></a><span class="lineno"> 1238</span> </div><div class="line"><a name="l01244"></a><span class="lineno"> 1244</span> <span class="preprocessor">#ifdef __DOXYGEN_ONLY__</span></div><div class="line"><a name="l01245"></a><span class="lineno"> 1245</span> <span class="comment">/* This is an example definition for documentation purposes.</span></div><div class="line"><a name="l01246"></a><span class="lineno"> 1246</span> <span class="comment"> * Implementations should define a suitable value in `crypto_struct.h`.</span></div><div class="line"><a name="l01247"></a><span class="lineno"> 1247</span> <span class="comment"> */</span></div><div class="line"><a name="l01248"></a><span class="lineno"><a class="line" href="group__MAC.html#ga441b6efc161a4573d06465bd22d9dc2d"> 1248</a></span> <span class="preprocessor">#define PSA_MAC_OPERATION_INIT {0}</span></div><div class="line"><a name="l01249"></a><span class="lineno"> 1249</span> <span class="preprocessor">#endif</span></div><div class="line"><a name="l01250"></a><span class="lineno"> 1250</span> </div><div class="line"><a name="l01253"></a><span class="lineno"> 1253</span> <span class="keyword">static</span> <a class="code" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a> psa_mac_operation_init(<span class="keywordtype">void</span>);</div><div class="line"><a name="l01254"></a><span class="lineno"> 1254</span> </div><div class="line"><a name="l01309"></a><span class="lineno"> 1309</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__MAC.html#gad33f2b15119593571ca6b8e7c757ab0e">psa_mac_sign_setup</a>(<a class="code" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a> *operation,</div><div class="line"><a name="l01310"></a><span class="lineno"> 1310</span>  <a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle,</div><div class="line"><a name="l01311"></a><span class="lineno"> 1311</span>  <a class="code" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg);</div><div class="line"><a name="l01312"></a><span class="lineno"> 1312</span> </div><div class="line"><a name="l01366"></a><span class="lineno"> 1366</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__MAC.html#gaa721a59ae6d085ec90c7dc918879a027">psa_mac_verify_setup</a>(<a class="code" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a> *operation,</div><div class="line"><a name="l01367"></a><span class="lineno"> 1367</span>  <a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle,</div><div class="line"><a name="l01368"></a><span class="lineno"> 1368</span>  <a class="code" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg);</div><div class="line"><a name="l01369"></a><span class="lineno"> 1369</span> </div><div class="line"><a name="l01391"></a><span class="lineno"> 1391</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__MAC.html#ga5560af371497babefe03c9da4e8a1c05">psa_mac_update</a>(<a class="code" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a> *operation,</div><div class="line"><a name="l01392"></a><span class="lineno"> 1392</span>  <span class="keyword">const</span> uint8_t *input,</div><div class="line"><a name="l01393"></a><span class="lineno"> 1393</span>  <span class="keywordtype">size_t</span> input_length);</div><div class="line"><a name="l01394"></a><span class="lineno"> 1394</span> </div><div class="line"><a name="l01433"></a><span class="lineno"> 1433</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__MAC.html#gac22bc0125580c96724a09226cfbc97f2">psa_mac_sign_finish</a>(<a class="code" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a> *operation,</div><div class="line"><a name="l01434"></a><span class="lineno"> 1434</span>  uint8_t *mac,</div><div class="line"><a name="l01435"></a><span class="lineno"> 1435</span>  <span class="keywordtype">size_t</span> mac_size,</div><div class="line"><a name="l01436"></a><span class="lineno"> 1436</span>  <span class="keywordtype">size_t</span> *mac_length);</div><div class="line"><a name="l01437"></a><span class="lineno"> 1437</span> </div><div class="line"><a name="l01469"></a><span class="lineno"> 1469</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__MAC.html#gac92b2930d6728e1be4d011c05d485822">psa_mac_verify_finish</a>(<a class="code" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a> *operation,</div><div class="line"><a name="l01470"></a><span class="lineno"> 1470</span>  <span class="keyword">const</span> uint8_t *mac,</div><div class="line"><a name="l01471"></a><span class="lineno"> 1471</span>  <span class="keywordtype">size_t</span> mac_length);</div><div class="line"><a name="l01472"></a><span class="lineno"> 1472</span> </div><div class="line"><a name="l01501"></a><span class="lineno"> 1501</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__MAC.html#gacd8dd54855ba1bc0a03f104f252884fd">psa_mac_abort</a>(<a class="code" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a> *operation);</div><div class="line"><a name="l01502"></a><span class="lineno"> 1502</span> </div><div class="line"><a name="l01544"></a><span class="lineno"> 1544</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__cipher.html#gac76dda492d9a1ba6b327bff610ec17b2">psa_cipher_encrypt</a>(<a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle,</div><div class="line"><a name="l01545"></a><span class="lineno"> 1545</span>  <a class="code" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg,</div><div class="line"><a name="l01546"></a><span class="lineno"> 1546</span>  <span class="keyword">const</span> uint8_t *input,</div><div class="line"><a name="l01547"></a><span class="lineno"> 1547</span>  <span class="keywordtype">size_t</span> input_length,</div><div class="line"><a name="l01548"></a><span class="lineno"> 1548</span>  uint8_t *output,</div><div class="line"><a name="l01549"></a><span class="lineno"> 1549</span>  <span class="keywordtype">size_t</span> output_size,</div><div class="line"><a name="l01550"></a><span class="lineno"> 1550</span>  <span class="keywordtype">size_t</span> *output_length);</div><div class="line"><a name="l01551"></a><span class="lineno"> 1551</span> </div><div class="line"><a name="l01586"></a><span class="lineno"> 1586</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__cipher.html#ga43d5991711ec45c98af0c1d99f6e0216">psa_cipher_decrypt</a>(<a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle,</div><div class="line"><a name="l01587"></a><span class="lineno"> 1587</span>  <a class="code" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg,</div><div class="line"><a name="l01588"></a><span class="lineno"> 1588</span>  <span class="keyword">const</span> uint8_t *input,</div><div class="line"><a name="l01589"></a><span class="lineno"> 1589</span>  <span class="keywordtype">size_t</span> input_length,</div><div class="line"><a name="l01590"></a><span class="lineno"> 1590</span>  uint8_t *output,</div><div class="line"><a name="l01591"></a><span class="lineno"> 1591</span>  <span class="keywordtype">size_t</span> output_size,</div><div class="line"><a name="l01592"></a><span class="lineno"> 1592</span>  <span class="keywordtype">size_t</span> *output_length);</div><div class="line"><a name="l01593"></a><span class="lineno"> 1593</span> </div><div class="line"><a name="l01622"></a><span class="lineno"><a class="line" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa"> 1622</a></span> <span class="keyword">typedef</span> <span class="keyword">struct </span>psa_cipher_operation_s <a class="code" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a>;</div><div class="line"><a name="l01623"></a><span class="lineno"> 1623</span> </div><div class="line"><a name="l01629"></a><span class="lineno"> 1629</span> <span class="preprocessor">#ifdef __DOXYGEN_ONLY__</span></div><div class="line"><a name="l01630"></a><span class="lineno"> 1630</span> <span class="comment">/* This is an example definition for documentation purposes.</span></div><div class="line"><a name="l01631"></a><span class="lineno"> 1631</span> <span class="comment"> * Implementations should define a suitable value in `crypto_struct.h`.</span></div><div class="line"><a name="l01632"></a><span class="lineno"> 1632</span> <span class="comment"> */</span></div><div class="line"><a name="l01633"></a><span class="lineno"><a class="line" href="group__cipher.html#ga2da0541aabf9a4995cf2004e36311919"> 1633</a></span> <span class="preprocessor">#define PSA_CIPHER_OPERATION_INIT {0}</span></div><div class="line"><a name="l01634"></a><span class="lineno"> 1634</span> <span class="preprocessor">#endif</span></div><div class="line"><a name="l01635"></a><span class="lineno"> 1635</span> </div><div class="line"><a name="l01638"></a><span class="lineno"> 1638</span> <span class="keyword">static</span> <a class="code" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> psa_cipher_operation_init(<span class="keywordtype">void</span>);</div><div class="line"><a name="l01639"></a><span class="lineno"> 1639</span> </div><div class="line"><a name="l01695"></a><span class="lineno"> 1695</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__cipher.html#ga2a7fc79a9d150d42dba99f40ee3a185e">psa_cipher_encrypt_setup</a>(<a class="code" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> *operation,</div><div class="line"><a name="l01696"></a><span class="lineno"> 1696</span>  <a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle,</div><div class="line"><a name="l01697"></a><span class="lineno"> 1697</span>  <a class="code" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg);</div><div class="line"><a name="l01698"></a><span class="lineno"> 1698</span> </div><div class="line"><a name="l01754"></a><span class="lineno"> 1754</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__cipher.html#gaddf8504e5367cd0efb4415bdec004f44">psa_cipher_decrypt_setup</a>(<a class="code" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> *operation,</div><div class="line"><a name="l01755"></a><span class="lineno"> 1755</span>  <a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle,</div><div class="line"><a name="l01756"></a><span class="lineno"> 1756</span>  <a class="code" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg);</div><div class="line"><a name="l01757"></a><span class="lineno"> 1757</span> </div><div class="line"><a name="l01786"></a><span class="lineno"> 1786</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__cipher.html#ga44857cf5e0c3d134a3c560f8ff5b50aa">psa_cipher_generate_iv</a>(<a class="code" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> *operation,</div><div class="line"><a name="l01787"></a><span class="lineno"> 1787</span>  <span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> *iv,</div><div class="line"><a name="l01788"></a><span class="lineno"> 1788</span>  <span class="keywordtype">size_t</span> iv_size,</div><div class="line"><a name="l01789"></a><span class="lineno"> 1789</span>  <span class="keywordtype">size_t</span> *iv_length);</div><div class="line"><a name="l01790"></a><span class="lineno"> 1790</span> </div><div class="line"><a name="l01821"></a><span class="lineno"> 1821</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__cipher.html#ga1359b2101f31637496ce7cc36c6e3d42">psa_cipher_set_iv</a>(<a class="code" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> *operation,</div><div class="line"><a name="l01822"></a><span class="lineno"> 1822</span>  <span class="keyword">const</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> *iv,</div><div class="line"><a name="l01823"></a><span class="lineno"> 1823</span>  <span class="keywordtype">size_t</span> iv_length);</div><div class="line"><a name="l01824"></a><span class="lineno"> 1824</span> </div><div class="line"><a name="l01857"></a><span class="lineno"> 1857</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__cipher.html#gafd0caea99cf1052527e4089d37f5ab91">psa_cipher_update</a>(<a class="code" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> *operation,</div><div class="line"><a name="l01858"></a><span class="lineno"> 1858</span>  <span class="keyword">const</span> uint8_t *input,</div><div class="line"><a name="l01859"></a><span class="lineno"> 1859</span>  <span class="keywordtype">size_t</span> input_length,</div><div class="line"><a name="l01860"></a><span class="lineno"> 1860</span>  <span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> *output,</div><div class="line"><a name="l01861"></a><span class="lineno"> 1861</span>  <span class="keywordtype">size_t</span> output_size,</div><div class="line"><a name="l01862"></a><span class="lineno"> 1862</span>  <span class="keywordtype">size_t</span> *output_length);</div><div class="line"><a name="l01863"></a><span class="lineno"> 1863</span> </div><div class="line"><a name="l01895"></a><span class="lineno"> 1895</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__cipher.html#ga1dcb58b8befe23f8a4d7a1d49c99249b">psa_cipher_finish</a>(<a class="code" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> *operation,</div><div class="line"><a name="l01896"></a><span class="lineno"> 1896</span>  uint8_t *output,</div><div class="line"><a name="l01897"></a><span class="lineno"> 1897</span>  <span class="keywordtype">size_t</span> output_size,</div><div class="line"><a name="l01898"></a><span class="lineno"> 1898</span>  <span class="keywordtype">size_t</span> *output_length);</div><div class="line"><a name="l01899"></a><span class="lineno"> 1899</span> </div><div class="line"><a name="l01928"></a><span class="lineno"> 1928</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__cipher.html#gaad482cdca2098bca0620596aaa02eaa4">psa_cipher_abort</a>(<a class="code" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> *operation);</div><div class="line"><a name="l01929"></a><span class="lineno"> 1929</span> </div><div class="line"><a name="l01982"></a><span class="lineno"> 1982</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__aead.html#ga44de092cf58bb6c820c5c80a6c51610d">psa_aead_encrypt</a>(<a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle,</div><div class="line"><a name="l01983"></a><span class="lineno"> 1983</span>  <a class="code" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg,</div><div class="line"><a name="l01984"></a><span class="lineno"> 1984</span>  <span class="keyword">const</span> uint8_t *nonce,</div><div class="line"><a name="l01985"></a><span class="lineno"> 1985</span>  <span class="keywordtype">size_t</span> nonce_length,</div><div class="line"><a name="l01986"></a><span class="lineno"> 1986</span>  <span class="keyword">const</span> uint8_t *additional_data,</div><div class="line"><a name="l01987"></a><span class="lineno"> 1987</span>  <span class="keywordtype">size_t</span> additional_data_length,</div><div class="line"><a name="l01988"></a><span class="lineno"> 1988</span>  <span class="keyword">const</span> uint8_t *plaintext,</div><div class="line"><a name="l01989"></a><span class="lineno"> 1989</span>  <span class="keywordtype">size_t</span> plaintext_length,</div><div class="line"><a name="l01990"></a><span class="lineno"> 1990</span>  uint8_t *ciphertext,</div><div class="line"><a name="l01991"></a><span class="lineno"> 1991</span>  <span class="keywordtype">size_t</span> ciphertext_size,</div><div class="line"><a name="l01992"></a><span class="lineno"> 1992</span>  <span class="keywordtype">size_t</span> *ciphertext_length);</div><div class="line"><a name="l01993"></a><span class="lineno"> 1993</span> </div><div class="line"><a name="l02040"></a><span class="lineno"> 2040</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__aead.html#gaa8ce6527f2e227f1071fadbf2099793b">psa_aead_decrypt</a>(<a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle,</div><div class="line"><a name="l02041"></a><span class="lineno"> 2041</span>  <a class="code" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg,</div><div class="line"><a name="l02042"></a><span class="lineno"> 2042</span>  <span class="keyword">const</span> uint8_t *nonce,</div><div class="line"><a name="l02043"></a><span class="lineno"> 2043</span>  <span class="keywordtype">size_t</span> nonce_length,</div><div class="line"><a name="l02044"></a><span class="lineno"> 2044</span>  <span class="keyword">const</span> uint8_t *additional_data,</div><div class="line"><a name="l02045"></a><span class="lineno"> 2045</span>  <span class="keywordtype">size_t</span> additional_data_length,</div><div class="line"><a name="l02046"></a><span class="lineno"> 2046</span>  <span class="keyword">const</span> uint8_t *ciphertext,</div><div class="line"><a name="l02047"></a><span class="lineno"> 2047</span>  <span class="keywordtype">size_t</span> ciphertext_length,</div><div class="line"><a name="l02048"></a><span class="lineno"> 2048</span>  uint8_t *plaintext,</div><div class="line"><a name="l02049"></a><span class="lineno"> 2049</span>  <span class="keywordtype">size_t</span> plaintext_size,</div><div class="line"><a name="l02050"></a><span class="lineno"> 2050</span>  <span class="keywordtype">size_t</span> *plaintext_length);</div><div class="line"><a name="l02051"></a><span class="lineno"> 2051</span> </div><div class="line"><a name="l02080"></a><span class="lineno"><a class="line" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed"> 2080</a></span> <span class="keyword">typedef</span> <span class="keyword">struct </span>psa_aead_operation_s <a class="code" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a>;</div><div class="line"><a name="l02081"></a><span class="lineno"> 2081</span> </div><div class="line"><a name="l02087"></a><span class="lineno"> 2087</span> <span class="preprocessor">#ifdef __DOXYGEN_ONLY__</span></div><div class="line"><a name="l02088"></a><span class="lineno"> 2088</span> <span class="comment">/* This is an example definition for documentation purposes.</span></div><div class="line"><a name="l02089"></a><span class="lineno"> 2089</span> <span class="comment"> * Implementations should define a suitable value in `crypto_struct.h`.</span></div><div class="line"><a name="l02090"></a><span class="lineno"> 2090</span> <span class="comment"> */</span></div><div class="line"><a name="l02091"></a><span class="lineno"><a class="line" href="group__aead.html#gaf52e036794c0dc6fbadd93a2b990f366"> 2091</a></span> <span class="preprocessor">#define PSA_AEAD_OPERATION_INIT {0}</span></div><div class="line"><a name="l02092"></a><span class="lineno"> 2092</span> <span class="preprocessor">#endif</span></div><div class="line"><a name="l02093"></a><span class="lineno"> 2093</span> </div><div class="line"><a name="l02096"></a><span class="lineno"> 2096</span> <span class="keyword">static</span> <a class="code" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> psa_aead_operation_init(<span class="keywordtype">void</span>);</div><div class="line"><a name="l02097"></a><span class="lineno"> 2097</span> </div><div class="line"><a name="l02159"></a><span class="lineno"> 2159</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__aead.html#ga47265dc4852f1476f852752218fd12b2">psa_aead_encrypt_setup</a>(<a class="code" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation,</div><div class="line"><a name="l02160"></a><span class="lineno"> 2160</span>  <a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle,</div><div class="line"><a name="l02161"></a><span class="lineno"> 2161</span>  <a class="code" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg);</div><div class="line"><a name="l02162"></a><span class="lineno"> 2162</span> </div><div class="line"><a name="l02221"></a><span class="lineno"> 2221</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__aead.html#ga439896519d4a367ec86b47f201884152">psa_aead_decrypt_setup</a>(<a class="code" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation,</div><div class="line"><a name="l02222"></a><span class="lineno"> 2222</span>  <a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle,</div><div class="line"><a name="l02223"></a><span class="lineno"> 2223</span>  <a class="code" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg);</div><div class="line"><a name="l02224"></a><span class="lineno"> 2224</span> </div><div class="line"><a name="l02254"></a><span class="lineno"> 2254</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__aead.html#ga3eadcf2a29f662129ea4fb3454969ba2">psa_aead_generate_nonce</a>(<a class="code" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation,</div><div class="line"><a name="l02255"></a><span class="lineno"> 2255</span>  <span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> *nonce,</div><div class="line"><a name="l02256"></a><span class="lineno"> 2256</span>  <span class="keywordtype">size_t</span> nonce_size,</div><div class="line"><a name="l02257"></a><span class="lineno"> 2257</span>  <span class="keywordtype">size_t</span> *nonce_length);</div><div class="line"><a name="l02258"></a><span class="lineno"> 2258</span> </div><div class="line"><a name="l02288"></a><span class="lineno"> 2288</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__aead.html#ga40641d0721ca7fe01bbcd9ef635fbc46">psa_aead_set_nonce</a>(<a class="code" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation,</div><div class="line"><a name="l02289"></a><span class="lineno"> 2289</span>  <span class="keyword">const</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> *nonce,</div><div class="line"><a name="l02290"></a><span class="lineno"> 2290</span>  <span class="keywordtype">size_t</span> nonce_length);</div><div class="line"><a name="l02291"></a><span class="lineno"> 2291</span> </div><div class="line"><a name="l02326"></a><span class="lineno"> 2326</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__aead.html#gad3431e28d05002c2a7b0760610176050">psa_aead_set_lengths</a>(<a class="code" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation,</div><div class="line"><a name="l02327"></a><span class="lineno"> 2327</span>  <span class="keywordtype">size_t</span> ad_length,</div><div class="line"><a name="l02328"></a><span class="lineno"> 2328</span>  <span class="keywordtype">size_t</span> plaintext_length);</div><div class="line"><a name="l02329"></a><span class="lineno"> 2329</span> </div><div class="line"><a name="l02368"></a><span class="lineno"> 2368</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__aead.html#ga6d0eed03f832e5c9c91cb8adf2882569">psa_aead_update_ad</a>(<a class="code" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation,</div><div class="line"><a name="l02369"></a><span class="lineno"> 2369</span>  <span class="keyword">const</span> uint8_t *input,</div><div class="line"><a name="l02370"></a><span class="lineno"> 2370</span>  <span class="keywordtype">size_t</span> input_length);</div><div class="line"><a name="l02371"></a><span class="lineno"> 2371</span> </div><div class="line"><a name="l02425"></a><span class="lineno"> 2425</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__aead.html#ga3b105de2088cef7c3d9e2fd8048c841c">psa_aead_update</a>(<a class="code" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation,</div><div class="line"><a name="l02426"></a><span class="lineno"> 2426</span>  <span class="keyword">const</span> uint8_t *input,</div><div class="line"><a name="l02427"></a><span class="lineno"> 2427</span>  <span class="keywordtype">size_t</span> input_length,</div><div class="line"><a name="l02428"></a><span class="lineno"> 2428</span>  <span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> *output,</div><div class="line"><a name="l02429"></a><span class="lineno"> 2429</span>  <span class="keywordtype">size_t</span> output_size,</div><div class="line"><a name="l02430"></a><span class="lineno"> 2430</span>  <span class="keywordtype">size_t</span> *output_length);</div><div class="line"><a name="l02431"></a><span class="lineno"> 2431</span> </div><div class="line"><a name="l02484"></a><span class="lineno"> 2484</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__aead.html#ga759791bbe1763b377c3b5447641f1fc8">psa_aead_finish</a>(<a class="code" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation,</div><div class="line"><a name="l02485"></a><span class="lineno"> 2485</span>  uint8_t *ciphertext,</div><div class="line"><a name="l02486"></a><span class="lineno"> 2486</span>  <span class="keywordtype">size_t</span> ciphertext_size,</div><div class="line"><a name="l02487"></a><span class="lineno"> 2487</span>  <span class="keywordtype">size_t</span> *ciphertext_length,</div><div class="line"><a name="l02488"></a><span class="lineno"> 2488</span>  uint8_t *tag,</div><div class="line"><a name="l02489"></a><span class="lineno"> 2489</span>  <span class="keywordtype">size_t</span> tag_size,</div><div class="line"><a name="l02490"></a><span class="lineno"> 2490</span>  <span class="keywordtype">size_t</span> *tag_length);</div><div class="line"><a name="l02491"></a><span class="lineno"> 2491</span> </div><div class="line"><a name="l02527"></a><span class="lineno"> 2527</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__aead.html#gaaed211fc61977c859d6ff07f39f59219">psa_aead_verify</a>(<a class="code" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation,</div><div class="line"><a name="l02528"></a><span class="lineno"> 2528</span>  <span class="keyword">const</span> uint8_t *tag,</div><div class="line"><a name="l02529"></a><span class="lineno"> 2529</span>  <span class="keywordtype">size_t</span> tag_length);</div><div class="line"><a name="l02530"></a><span class="lineno"> 2530</span> </div><div class="line"><a name="l02559"></a><span class="lineno"> 2559</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__aead.html#gae8a5f93d92318c8f592ee9fbb9d36ba0">psa_aead_abort</a>(<a class="code" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation);</div><div class="line"><a name="l02560"></a><span class="lineno"> 2560</span> </div><div class="line"><a name="l02606"></a><span class="lineno"> 2606</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__asymmetric.html#ga1b0db9d345b5048cdd39357ac2d56c07">psa_asymmetric_sign</a>(<a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle,</div><div class="line"><a name="l02607"></a><span class="lineno"> 2607</span>  <a class="code" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg,</div><div class="line"><a name="l02608"></a><span class="lineno"> 2608</span>  <span class="keyword">const</span> uint8_t *hash,</div><div class="line"><a name="l02609"></a><span class="lineno"> 2609</span>  <span class="keywordtype">size_t</span> hash_length,</div><div class="line"><a name="l02610"></a><span class="lineno"> 2610</span>  uint8_t *signature,</div><div class="line"><a name="l02611"></a><span class="lineno"> 2611</span>  <span class="keywordtype">size_t</span> signature_size,</div><div class="line"><a name="l02612"></a><span class="lineno"> 2612</span>  <span class="keywordtype">size_t</span> *signature_length);</div><div class="line"><a name="l02613"></a><span class="lineno"> 2613</span> </div><div class="line"><a name="l02649"></a><span class="lineno"> 2649</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__asymmetric.html#ga1b8e964c8d927e3d632325d762959eb7">psa_asymmetric_verify</a>(<a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle,</div><div class="line"><a name="l02650"></a><span class="lineno"> 2650</span>  <a class="code" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg,</div><div class="line"><a name="l02651"></a><span class="lineno"> 2651</span>  <span class="keyword">const</span> uint8_t *hash,</div><div class="line"><a name="l02652"></a><span class="lineno"> 2652</span>  <span class="keywordtype">size_t</span> hash_length,</div><div class="line"><a name="l02653"></a><span class="lineno"> 2653</span>  <span class="keyword">const</span> uint8_t *signature,</div><div class="line"><a name="l02654"></a><span class="lineno"> 2654</span>  <span class="keywordtype">size_t</span> signature_length);</div><div class="line"><a name="l02655"></a><span class="lineno"> 2655</span> </div><div class="line"><a name="l02703"></a><span class="lineno"> 2703</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__asymmetric.html#gad429293b7b0bf2a830b9540a02552004">psa_asymmetric_encrypt</a>(<a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle,</div><div class="line"><a name="l02704"></a><span class="lineno"> 2704</span>  <a class="code" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg,</div><div class="line"><a name="l02705"></a><span class="lineno"> 2705</span>  <span class="keyword">const</span> uint8_t *input,</div><div class="line"><a name="l02706"></a><span class="lineno"> 2706</span>  <span class="keywordtype">size_t</span> input_length,</div><div class="line"><a name="l02707"></a><span class="lineno"> 2707</span>  <span class="keyword">const</span> uint8_t *salt,</div><div class="line"><a name="l02708"></a><span class="lineno"> 2708</span>  <span class="keywordtype">size_t</span> salt_length,</div><div class="line"><a name="l02709"></a><span class="lineno"> 2709</span>  uint8_t *output,</div><div class="line"><a name="l02710"></a><span class="lineno"> 2710</span>  <span class="keywordtype">size_t</span> output_size,</div><div class="line"><a name="l02711"></a><span class="lineno"> 2711</span>  <span class="keywordtype">size_t</span> *output_length);</div><div class="line"><a name="l02712"></a><span class="lineno"> 2712</span> </div><div class="line"><a name="l02760"></a><span class="lineno"> 2760</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__asymmetric.html#ga34b55fbaee23dba1a677186fc66a556e">psa_asymmetric_decrypt</a>(<a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle,</div><div class="line"><a name="l02761"></a><span class="lineno"> 2761</span>  <a class="code" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg,</div><div class="line"><a name="l02762"></a><span class="lineno"> 2762</span>  <span class="keyword">const</span> uint8_t *input,</div><div class="line"><a name="l02763"></a><span class="lineno"> 2763</span>  <span class="keywordtype">size_t</span> input_length,</div><div class="line"><a name="l02764"></a><span class="lineno"> 2764</span>  <span class="keyword">const</span> uint8_t *salt,</div><div class="line"><a name="l02765"></a><span class="lineno"> 2765</span>  <span class="keywordtype">size_t</span> salt_length,</div><div class="line"><a name="l02766"></a><span class="lineno"> 2766</span>  uint8_t *output,</div><div class="line"><a name="l02767"></a><span class="lineno"> 2767</span>  <span class="keywordtype">size_t</span> output_size,</div><div class="line"><a name="l02768"></a><span class="lineno"> 2768</span>  <span class="keywordtype">size_t</span> *output_length);</div><div class="line"><a name="l02769"></a><span class="lineno"> 2769</span> </div><div class="line"><a name="l02805"></a><span class="lineno"><a class="line" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b"> 2805</a></span> <span class="keyword">typedef</span> <span class="keyword">struct </span>psa_crypto_generator_s <a class="code" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a>;</div><div class="line"><a name="l02806"></a><span class="lineno"> 2806</span> </div><div class="line"><a name="l02812"></a><span class="lineno"> 2812</span> <span class="preprocessor">#ifdef __DOXYGEN_ONLY__</span></div><div class="line"><a name="l02813"></a><span class="lineno"> 2813</span> <span class="comment">/* This is an example definition for documentation purposes.</span></div><div class="line"><a name="l02814"></a><span class="lineno"> 2814</span> <span class="comment"> * Implementations should define a suitable value in `crypto_struct.h`.</span></div><div class="line"><a name="l02815"></a><span class="lineno"> 2815</span> <span class="comment"> */</span></div><div class="line"><a name="l02816"></a><span class="lineno"><a class="line" href="group__generators.html#ga4788b471385fc667876fbd8a0d3fe062"> 2816</a></span> <span class="preprocessor">#define PSA_CRYPTO_GENERATOR_INIT {0}</span></div><div class="line"><a name="l02817"></a><span class="lineno"> 2817</span> <span class="preprocessor">#endif</span></div><div class="line"><a name="l02818"></a><span class="lineno"> 2818</span> </div><div class="line"><a name="l02821"></a><span class="lineno"> 2821</span> <span class="keyword">static</span> <a class="code" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> psa_crypto_generator_init(<span class="keywordtype">void</span>);</div><div class="line"><a name="l02822"></a><span class="lineno"> 2822</span> </div><div class="line"><a name="l02835"></a><span class="lineno"> 2835</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__generators.html#ga7453491e3b440193be2c5dccc2040fd2">psa_get_generator_capacity</a>(<span class="keyword">const</span> <a class="code" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> *generator,</div><div class="line"><a name="l02836"></a><span class="lineno"> 2836</span>  <span class="keywordtype">size_t</span> *capacity);</div><div class="line"><a name="l02837"></a><span class="lineno"> 2837</span> </div><div class="line"><a name="l02851"></a><span class="lineno"> 2851</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__generators.html#ga45676ec3c719622f95caaf926f44bb6e">psa_set_generator_capacity</a>(<a class="code" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> *generator,</div><div class="line"><a name="l02852"></a><span class="lineno"> 2852</span>  <span class="keywordtype">size_t</span> capacity);</div><div class="line"><a name="l02853"></a><span class="lineno"> 2853</span> </div><div class="line"><a name="l02879"></a><span class="lineno"> 2879</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__generators.html#gab5712ad29b78c2b170e64cc5bcfc1bce">psa_generator_read</a>(<a class="code" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> *generator,</div><div class="line"><a name="l02880"></a><span class="lineno"> 2880</span>  uint8_t *output,</div><div class="line"><a name="l02881"></a><span class="lineno"> 2881</span>  <span class="keywordtype">size_t</span> output_length);</div><div class="line"><a name="l02882"></a><span class="lineno"> 2882</span> </div><div class="line"><a name="l02932"></a><span class="lineno"> 2932</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__generators.html#ga7fcdf07cd37279ca167db484053da894">psa_generator_import_key</a>(<a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle,</div><div class="line"><a name="l02933"></a><span class="lineno"> 2933</span>  <a class="code" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a> type,</div><div class="line"><a name="l02934"></a><span class="lineno"> 2934</span>  <span class="keywordtype">size_t</span> bits,</div><div class="line"><a name="l02935"></a><span class="lineno"> 2935</span>  <a class="code" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> *generator);</div><div class="line"><a name="l02936"></a><span class="lineno"> 2936</span> </div><div class="line"><a name="l02959"></a><span class="lineno"> 2959</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__generators.html#ga563ca64537d90368899286b36d8cf7f3">psa_generator_abort</a>(<a class="code" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> *generator);</div><div class="line"><a name="l02960"></a><span class="lineno"> 2960</span> </div><div class="line"><a name="l02968"></a><span class="lineno"><a class="line" href="group__generators.html#gac3222df9b9ecca4d33ae56a7b8fbb1c9"> 2968</a></span> <span class="preprocessor">#define PSA_GENERATOR_UNBRIDLED_CAPACITY ((size_t)(-1))</span></div><div class="line"><a name="l02969"></a><span class="lineno"> 2969</span> </div><div class="line"><a name="l03016"></a><span class="lineno"> 3016</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__derivation.html#ga1825696be813dfac2b8d3d02717e71c5">psa_key_derivation_setup</a>(<a class="code" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> *generator,</div><div class="line"><a name="l03017"></a><span class="lineno"> 3017</span>  <a class="code" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg);</div><div class="line"><a name="l03018"></a><span class="lineno"> 3018</span> </div><div class="line"><a name="l03054"></a><span class="lineno"> 3054</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__derivation.html#ga1b30e888db65c71f5337900848e1b03f">psa_key_derivation_input_bytes</a>(<a class="code" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> *generator,</div><div class="line"><a name="l03055"></a><span class="lineno"> 3055</span>  <a class="code" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">psa_key_derivation_step_t</a> step,</div><div class="line"><a name="l03056"></a><span class="lineno"> 3056</span>  <span class="keyword">const</span> uint8_t *data,</div><div class="line"><a name="l03057"></a><span class="lineno"> 3057</span>  <span class="keywordtype">size_t</span> data_length);</div><div class="line"><a name="l03058"></a><span class="lineno"> 3058</span> </div><div class="line"><a name="l03099"></a><span class="lineno"> 3099</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__derivation.html#ga9e5f549aa1f6f3863a07008d3d98f91a">psa_key_derivation_input_key</a>(<a class="code" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> *generator,</div><div class="line"><a name="l03100"></a><span class="lineno"> 3100</span>  <a class="code" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">psa_key_derivation_step_t</a> step,</div><div class="line"><a name="l03101"></a><span class="lineno"> 3101</span>  <a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle);</div><div class="line"><a name="l03102"></a><span class="lineno"> 3102</span> </div><div class="line"><a name="l03156"></a><span class="lineno"> 3156</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__derivation.html#ga2c7fe304cacc141ffb91553548abc5d2">psa_key_agreement</a>(<a class="code" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> *generator,</div><div class="line"><a name="l03157"></a><span class="lineno"> 3157</span>  <a class="code" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">psa_key_derivation_step_t</a> step,</div><div class="line"><a name="l03158"></a><span class="lineno"> 3158</span>  <a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> private_key,</div><div class="line"><a name="l03159"></a><span class="lineno"> 3159</span>  <span class="keyword">const</span> uint8_t *peer_key,</div><div class="line"><a name="l03160"></a><span class="lineno"> 3160</span>  <span class="keywordtype">size_t</span> peer_key_length);</div><div class="line"><a name="l03161"></a><span class="lineno"> 3161</span> </div><div class="line"><a name="l03210"></a><span class="lineno"> 3210</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__derivation.html#gaf1b12eff66a1a0020b5bdc8d0e910006">psa_key_agreement_raw_shared_secret</a>(<a class="code" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg,</div><div class="line"><a name="l03211"></a><span class="lineno"> 3211</span>  <a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> private_key,</div><div class="line"><a name="l03212"></a><span class="lineno"> 3212</span>  <span class="keyword">const</span> uint8_t *peer_key,</div><div class="line"><a name="l03213"></a><span class="lineno"> 3213</span>  <span class="keywordtype">size_t</span> peer_key_length,</div><div class="line"><a name="l03214"></a><span class="lineno"> 3214</span>  uint8_t *output,</div><div class="line"><a name="l03215"></a><span class="lineno"> 3215</span>  <span class="keywordtype">size_t</span> output_size,</div><div class="line"><a name="l03216"></a><span class="lineno"> 3216</span>  <span class="keywordtype">size_t</span> *output_length);</div><div class="line"><a name="l03217"></a><span class="lineno"> 3217</span> </div><div class="line"><a name="l03247"></a><span class="lineno"> 3247</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__random.html#ga1985eae417dfbccedf50d5fff54ea8c5">psa_generate_random</a>(uint8_t *output,</div><div class="line"><a name="l03248"></a><span class="lineno"> 3248</span>  <span class="keywordtype">size_t</span> output_size);</div><div class="line"><a name="l03249"></a><span class="lineno"> 3249</span> </div><div class="line"><a name="l03255"></a><span class="lineno"><a class="line" href="structpsa__generate__key__extra__rsa.html"> 3255</a></span> <span class="keyword">typedef</span> <span class="keyword">struct </span>{</div><div class="line"><a name="l03256"></a><span class="lineno"><a class="line" href="structpsa__generate__key__extra__rsa.html#a53ccb9e4375f3c9af6e3ecfe111ce11d"> 3256</a></span>  uint32_t <a class="code" href="structpsa__generate__key__extra__rsa.html#a53ccb9e4375f3c9af6e3ecfe111ce11d">e</a>; </div><div class="line"><a name="l03257"></a><span class="lineno"> 3257</span> } <a class="code" href="structpsa__generate__key__extra__rsa.html">psa_generate_key_extra_rsa</a>;</div><div class="line"><a name="l03258"></a><span class="lineno"> 3258</span> </div><div class="line"><a name="l03324"></a><span class="lineno"> 3324</span> <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> <a class="code" href="group__random.html#ga72921520494b4f007a3afb904cd9ecdd">psa_generate_key</a>(<a class="code" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle,</div><div class="line"><a name="l03325"></a><span class="lineno"> 3325</span>  <a class="code" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a> type,</div><div class="line"><a name="l03326"></a><span class="lineno"> 3326</span>  <span class="keywordtype">size_t</span> bits,</div><div class="line"><a name="l03327"></a><span class="lineno"> 3327</span>  <span class="keyword">const</span> <span class="keywordtype">void</span> *extra,</div><div class="line"><a name="l03328"></a><span class="lineno"> 3328</span>  <span class="keywordtype">size_t</span> extra_size);</div><div class="line"><a name="l03329"></a><span class="lineno"> 3329</span> </div><div class="line"><a name="l03332"></a><span class="lineno"> 3332</span> <span class="preprocessor">#ifdef __cplusplus</span></div><div class="line"><a name="l03333"></a><span class="lineno"> 3333</span> }</div><div class="line"><a name="l03334"></a><span class="lineno"> 3334</span> <span class="preprocessor">#endif</span></div><div class="line"><a name="l03335"></a><span class="lineno"> 3335</span> </div><div class="line"><a name="l03336"></a><span class="lineno"> 3336</span> <span class="comment">/* The file "crypto_sizes.h" contains definitions for size calculation</span></div><div class="line"><a name="l03337"></a><span class="lineno"> 3337</span> <span class="comment"> * macros whose definitions are implementation-specific. */</span></div><div class="line"><a name="l03338"></a><span class="lineno"> 3338</span> <span class="preprocessor">#include "<a class="code" href="crypto__sizes_8h.html">crypto_sizes.h</a>"</span></div><div class="line"><a name="l03339"></a><span class="lineno"> 3339</span> </div><div class="line"><a name="l03340"></a><span class="lineno"> 3340</span> <span class="comment">/* The file "crypto_struct.h" contains definitions for</span></div><div class="line"><a name="l03341"></a><span class="lineno"> 3341</span> <span class="comment"> * implementation-specific structs that are declared above. */</span></div><div class="line"><a name="l03342"></a><span class="lineno"> 3342</span> <span class="preprocessor">#include "crypto_struct.h"</span></div><div class="line"><a name="l03343"></a><span class="lineno"> 3343</span> </div><div class="line"><a name="l03344"></a><span class="lineno"> 3344</span> <span class="comment">/* The file "crypto_extra.h" contains vendor-specific definitions. This</span></div><div class="line"><a name="l03345"></a><span class="lineno"> 3345</span> <span class="comment"> * can include vendor-defined algorithms, extra functions, etc. */</span></div><div class="line"><a name="l03346"></a><span class="lineno"> 3346</span> <span class="preprocessor">#include "crypto_extra.h"</span></div><div class="line"><a name="l03347"></a><span class="lineno"> 3347</span> </div><div class="line"><a name="l03348"></a><span class="lineno"> 3348</span> <span class="preprocessor">#endif </span><span class="comment">/* PSA_CRYPTO_H */</span><span class="preprocessor"></span></div><div class="ttc" id="group__cipher_html_ga2a7fc79a9d150d42dba99f40ee3a185e"><div class="ttname"><a href="group__cipher.html#ga2a7fc79a9d150d42dba99f40ee3a185e">psa_cipher_encrypt_setup</a></div><div class="ttdeci">psa_status_t psa_cipher_encrypt_setup(psa_cipher_operation_t *operation, psa_key_handle_t handle, psa_algorithm_t alg)</div></div>
-<div class="ttc" id="group__MAC_html_gac92b2930d6728e1be4d011c05d485822"><div class="ttname"><a href="group__MAC.html#gac92b2930d6728e1be4d011c05d485822">psa_mac_verify_finish</a></div><div class="ttdeci">psa_status_t psa_mac_verify_finish(psa_mac_operation_t *operation, const uint8_t *mac, size_t mac_length)</div></div>
-<div class="ttc" id="group__random_html_ga1985eae417dfbccedf50d5fff54ea8c5"><div class="ttname"><a href="group__random.html#ga1985eae417dfbccedf50d5fff54ea8c5">psa_generate_random</a></div><div class="ttdeci">psa_status_t psa_generate_random(uint8_t *output, size_t output_size)</div><div class="ttdoc">Generate random bytes. </div></div>
-<div class="ttc" id="group__aead_html_ga3eadcf2a29f662129ea4fb3454969ba2"><div class="ttname"><a href="group__aead.html#ga3eadcf2a29f662129ea4fb3454969ba2">psa_aead_generate_nonce</a></div><div class="ttdeci">psa_status_t psa_aead_generate_nonce(psa_aead_operation_t *operation, unsigned char *nonce, size_t nonce_size, size_t *nonce_length)</div></div>
-<div class="ttc" id="group__import__export_html_ga902b9a7a6cf34d6111668be777b05eaf"><div class="ttname"><a href="group__import__export.html#ga902b9a7a6cf34d6111668be777b05eaf">psa_export_key</a></div><div class="ttdeci">psa_status_t psa_export_key(psa_key_handle_t handle, uint8_t *data, size_t data_size, size_t *data_length)</div><div class="ttdoc">Export a key in binary format. </div></div>
-<div class="ttc" id="group__key__management_html_ga40094b77b7a42b9c8e158395113f1a35"><div class="ttname"><a href="group__key__management.html#ga40094b77b7a42b9c8e158395113f1a35">psa_allocate_key</a></div><div class="ttdeci">psa_status_t psa_allocate_key(psa_key_handle_t *handle)</div></div>
-<div class="ttc" id="group__asymmetric_html_ga1b8e964c8d927e3d632325d762959eb7"><div class="ttname"><a href="group__asymmetric.html#ga1b8e964c8d927e3d632325d762959eb7">psa_asymmetric_verify</a></div><div class="ttdeci">psa_status_t psa_asymmetric_verify(psa_key_handle_t handle, psa_algorithm_t alg, const uint8_t *hash, size_t hash_length, const uint8_t *signature, size_t signature_length)</div><div class="ttdoc">Verify the signature a hash or short message using a public key. </div></div>
-<div class="ttc" id="group__cipher_html_gaddf8504e5367cd0efb4415bdec004f44"><div class="ttname"><a href="group__cipher.html#gaddf8504e5367cd0efb4415bdec004f44">psa_cipher_decrypt_setup</a></div><div class="ttdeci">psa_status_t psa_cipher_decrypt_setup(psa_cipher_operation_t *operation, psa_key_handle_t handle, psa_algorithm_t alg)</div></div>
-<div class="ttc" id="group__policy_html_ga7746662b7503e484774d0ecb5d8ac2ab"><div class="ttname"><a href="group__policy.html#ga7746662b7503e484774d0ecb5d8ac2ab">psa_key_policy_get_usage</a></div><div class="ttdeci">psa_key_usage_t psa_key_policy_get_usage(const psa_key_policy_t *policy)</div><div class="ttdoc">Retrieve the usage field of a policy structure. </div></div>
-<div class="ttc" id="group__derivation_html_gaf1b12eff66a1a0020b5bdc8d0e910006"><div class="ttname"><a href="group__derivation.html#gaf1b12eff66a1a0020b5bdc8d0e910006">psa_key_agreement_raw_shared_secret</a></div><div class="ttdeci">psa_status_t psa_key_agreement_raw_shared_secret(psa_algorithm_t alg, psa_key_handle_t private_key, const uint8_t *peer_key, size_t peer_key_length, uint8_t *output, size_t output_size, size_t *output_length)</div></div>
-<div class="ttc" id="group__aead_html_ga47265dc4852f1476f852752218fd12b2"><div class="ttname"><a href="group__aead.html#ga47265dc4852f1476f852752218fd12b2">psa_aead_encrypt_setup</a></div><div class="ttdeci">psa_status_t psa_aead_encrypt_setup(psa_aead_operation_t *operation, psa_key_handle_t handle, psa_algorithm_t alg)</div></div>
-<div class="ttc" id="group__MAC_html_ga08e2e8c21bfe762a907266f3bdd1d07c"><div class="ttname"><a href="group__MAC.html#ga08e2e8c21bfe762a907266f3bdd1d07c">psa_mac_verify</a></div><div class="ttdeci">psa_status_t psa_mac_verify(psa_key_handle_t handle, psa_algorithm_t alg, const uint8_t *input, size_t input_length, const uint8_t *mac, const size_t mac_length)</div></div>
-<div class="ttc" id="group__random_html_ga72921520494b4f007a3afb904cd9ecdd"><div class="ttname"><a href="group__random.html#ga72921520494b4f007a3afb904cd9ecdd">psa_generate_key</a></div><div class="ttdeci">psa_status_t psa_generate_key(psa_key_handle_t handle, psa_key_type_t type, size_t bits, const void *extra, size_t extra_size)</div><div class="ttdoc">Generate a key or key pair. </div></div>
-<div class="ttc" id="group__key__management_html_gaa09b720d299dfe6b9f41c36e448078eb"><div class="ttname"><a href="group__key__management.html#gaa09b720d299dfe6b9f41c36e448078eb">psa_close_key</a></div><div class="ttdeci">psa_status_t psa_close_key(psa_key_handle_t handle)</div></div>
-<div class="ttc" id="group__cipher_html_ga43d5991711ec45c98af0c1d99f6e0216"><div class="ttname"><a href="group__cipher.html#ga43d5991711ec45c98af0c1d99f6e0216">psa_cipher_decrypt</a></div><div class="ttdeci">psa_status_t psa_cipher_decrypt(psa_key_handle_t handle, psa_algorithm_t alg, const uint8_t *input, size_t input_length, uint8_t *output, size_t output_size, size_t *output_length)</div></div>
-<div class="ttc" id="group__import__export_html_gad760d1f0d4e60972c78cbb4c8a528256"><div class="ttname"><a href="group__import__export.html#gad760d1f0d4e60972c78cbb4c8a528256">psa_export_public_key</a></div><div class="ttdeci">psa_status_t psa_export_public_key(psa_key_handle_t handle, uint8_t *data, size_t data_size, size_t *data_length)</div><div class="ttdoc">Export a public key or the public part of a key pair in binary format. </div></div>
-<div class="ttc" id="group__aead_html_ga14f6a01afbaa8c5b3d8c5d345cbaa3ed"><div class="ttname"><a href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a></div><div class="ttdeci">struct psa_aead_operation_s psa_aead_operation_t</div><div class="ttdef"><b>Definition:</b> crypto.h:2080</div></div>
-<div class="ttc" id="group__derivation_html_ga1b30e888db65c71f5337900848e1b03f"><div class="ttname"><a href="group__derivation.html#ga1b30e888db65c71f5337900848e1b03f">psa_key_derivation_input_bytes</a></div><div class="ttdeci">psa_status_t psa_key_derivation_input_bytes(psa_crypto_generator_t *generator, psa_key_derivation_step_t step, const uint8_t *data, size_t data_length)</div></div>
-<div class="ttc" id="group__import__export_html_gae260b92e32ac5d63f7dfc6ffdf6536f7"><div class="ttname"><a href="group__import__export.html#gae260b92e32ac5d63f7dfc6ffdf6536f7">psa_get_key_domain_parameters</a></div><div class="ttdeci">psa_status_t psa_get_key_domain_parameters(psa_key_handle_t handle, uint8_t *data, size_t data_size, size_t *data_length)</div><div class="ttdoc">Get domain parameters for a key. </div></div>
-<div class="ttc" id="crypto__types_8h_html"><div class="ttname"><a href="crypto__types_8h.html">crypto_types.h</a></div><div class="ttdoc">PSA cryptography module: type aliases. </div></div>
-<div class="ttc" id="group__import__export_html_ga5c1c24176cfb1517a8806235b3162a9d"><div class="ttname"><a href="group__import__export.html#ga5c1c24176cfb1517a8806235b3162a9d">psa_copy_key</a></div><div class="ttdeci">psa_status_t psa_copy_key(psa_key_handle_t source_handle, psa_key_handle_t target_handle, const psa_key_policy_t *constraint)</div></div>
-<div class="ttc" id="group__generators_html_ga563ca64537d90368899286b36d8cf7f3"><div class="ttname"><a href="group__generators.html#ga563ca64537d90368899286b36d8cf7f3">psa_generator_abort</a></div><div class="ttdeci">psa_status_t psa_generator_abort(psa_crypto_generator_t *generator)</div></div>
-<div class="ttc" id="group__derivation_html_gaac4eeacd36596c548b3a48fc06c5048b"><div class="ttname"><a href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">psa_key_derivation_step_t</a></div><div class="ttdeci">uint16_t psa_key_derivation_step_t</div><div class="ttdoc">Encoding of the step of a key derivation. </div><div class="ttdef"><b>Definition:</b> crypto_types.h:106</div></div>
-<div class="ttc" id="group__key__lifetimes_html_ga11e986351c65bd3dc3c0fe2cd9926e4b"><div class="ttname"><a href="group__key__lifetimes.html#ga11e986351c65bd3dc3c0fe2cd9926e4b">psa_key_id_t</a></div><div class="ttdeci">uint32_t psa_key_id_t</div><div class="ttdef"><b>Definition:</b> crypto_types.h:88</div></div>
-<div class="ttc" id="group__hash_html_gac69f7f19d96a56c28cf3799d11b12156"><div class="ttname"><a href="group__hash.html#gac69f7f19d96a56c28cf3799d11b12156">psa_hash_compute</a></div><div class="ttdeci">psa_status_t psa_hash_compute(psa_algorithm_t alg, const uint8_t *input, size_t input_length, uint8_t *hash, size_t hash_size, size_t *hash_length)</div></div>
-<div class="ttc" id="group__cipher_html_gafd0caea99cf1052527e4089d37f5ab91"><div class="ttname"><a href="group__cipher.html#gafd0caea99cf1052527e4089d37f5ab91">psa_cipher_update</a></div><div class="ttdeci">psa_status_t psa_cipher_update(psa_cipher_operation_t *operation, const uint8_t *input, size_t input_length, unsigned char *output, size_t output_size, size_t *output_length)</div></div>
-<div class="ttc" id="group__cipher_html_ga1359b2101f31637496ce7cc36c6e3d42"><div class="ttname"><a href="group__cipher.html#ga1359b2101f31637496ce7cc36c6e3d42">psa_cipher_set_iv</a></div><div class="ttdeci">psa_status_t psa_cipher_set_iv(psa_cipher_operation_t *operation, const unsigned char *iv, size_t iv_length)</div></div>
-<div class="ttc" id="group__generators_html_gab5712ad29b78c2b170e64cc5bcfc1bce"><div class="ttname"><a href="group__generators.html#gab5712ad29b78c2b170e64cc5bcfc1bce">psa_generator_read</a></div><div class="ttdeci">psa_status_t psa_generator_read(psa_crypto_generator_t *generator, uint8_t *output, size_t output_length)</div></div>
-<div class="ttc" id="group__hash_html_ga65b16ef97d7f650899b7db4b7d1112ff"><div class="ttname"><a href="group__hash.html#ga65b16ef97d7f650899b7db4b7d1112ff">psa_hash_update</a></div><div class="ttdeci">psa_status_t psa_hash_update(psa_hash_operation_t *operation, const uint8_t *input, size_t input_length)</div></div>
-<div class="ttc" id="group__hash_html_ga0bb6dbd3c310648c3cf7d202413ff0bc"><div class="ttname"><a href="group__hash.html#ga0bb6dbd3c310648c3cf7d202413ff0bc">psa_hash_compare</a></div><div class="ttdeci">psa_status_t psa_hash_compare(psa_algorithm_t alg, const uint8_t *input, size_t input_length, const uint8_t *hash, const size_t hash_length)</div></div>
-<div class="ttc" id="group__aead_html_ga759791bbe1763b377c3b5447641f1fc8"><div class="ttname"><a href="group__aead.html#ga759791bbe1763b377c3b5447641f1fc8">psa_aead_finish</a></div><div class="ttdeci">psa_status_t psa_aead_finish(psa_aead_operation_t *operation, uint8_t *ciphertext, size_t ciphertext_size, size_t *ciphertext_length, uint8_t *tag, size_t tag_size, size_t *tag_length)</div></div>
-<div class="ttc" id="group__asymmetric_html_gad429293b7b0bf2a830b9540a02552004"><div class="ttname"><a href="group__asymmetric.html#gad429293b7b0bf2a830b9540a02552004">psa_asymmetric_encrypt</a></div><div class="ttdeci">psa_status_t psa_asymmetric_encrypt(psa_key_handle_t handle, psa_algorithm_t alg, const uint8_t *input, size_t input_length, const uint8_t *salt, size_t salt_length, uint8_t *output, size_t output_size, size_t *output_length)</div><div class="ttdoc">Encrypt a short message with a public key. </div></div>
-<div class="ttc" id="group__asymmetric_html_ga34b55fbaee23dba1a677186fc66a556e"><div class="ttname"><a href="group__asymmetric.html#ga34b55fbaee23dba1a677186fc66a556e">psa_asymmetric_decrypt</a></div><div class="ttdeci">psa_status_t psa_asymmetric_decrypt(psa_key_handle_t handle, psa_algorithm_t alg, const uint8_t *input, size_t input_length, const uint8_t *salt, size_t salt_length, uint8_t *output, size_t output_size, size_t *output_length)</div><div class="ttdoc">Decrypt a short message with a private key. </div></div>
-<div class="ttc" id="crypto__values_8h_html"><div class="ttname"><a href="crypto__values_8h.html">crypto_values.h</a></div><div class="ttdoc">PSA cryptography module: macros to build and analyze integer values. </div></div>
-<div class="ttc" id="group__import__export_html_ga091da8d3d39137fd6ad59f2b10234300"><div class="ttname"><a href="group__import__export.html#ga091da8d3d39137fd6ad59f2b10234300">psa_set_key_domain_parameters</a></div><div class="ttdeci">psa_status_t psa_set_key_domain_parameters(psa_key_handle_t handle, psa_key_type_t type, const uint8_t *data, size_t data_length)</div><div class="ttdoc">Set domain parameters for a key. </div></div>
-<div class="ttc" id="group__MAC_html_gac22bc0125580c96724a09226cfbc97f2"><div class="ttname"><a href="group__MAC.html#gac22bc0125580c96724a09226cfbc97f2">psa_mac_sign_finish</a></div><div class="ttdeci">psa_status_t psa_mac_sign_finish(psa_mac_operation_t *operation, uint8_t *mac, size_t mac_size, size_t *mac_length)</div></div>
-<div class="ttc" id="group__cipher_html_ga1dcb58b8befe23f8a4d7a1d49c99249b"><div class="ttname"><a href="group__cipher.html#ga1dcb58b8befe23f8a4d7a1d49c99249b">psa_cipher_finish</a></div><div class="ttdeci">psa_status_t psa_cipher_finish(psa_cipher_operation_t *operation, uint8_t *output, size_t output_size, size_t *output_length)</div></div>
-<div class="ttc" id="group__MAC_html_gaa721a59ae6d085ec90c7dc918879a027"><div class="ttname"><a href="group__MAC.html#gaa721a59ae6d085ec90c7dc918879a027">psa_mac_verify_setup</a></div><div class="ttdeci">psa_status_t psa_mac_verify_setup(psa_mac_operation_t *operation, psa_key_handle_t handle, psa_algorithm_t alg)</div></div>
-<div class="ttc" id="group__cipher_html_ga44857cf5e0c3d134a3c560f8ff5b50aa"><div class="ttname"><a href="group__cipher.html#ga44857cf5e0c3d134a3c560f8ff5b50aa">psa_cipher_generate_iv</a></div><div class="ttdeci">psa_status_t psa_cipher_generate_iv(psa_cipher_operation_t *operation, unsigned char *iv, size_t iv_size, size_t *iv_length)</div></div>
-<div class="ttc" id="group__aead_html_ga6d0eed03f832e5c9c91cb8adf2882569"><div class="ttname"><a href="group__aead.html#ga6d0eed03f832e5c9c91cb8adf2882569">psa_aead_update_ad</a></div><div class="ttdeci">psa_status_t psa_aead_update_ad(psa_aead_operation_t *operation, const uint8_t *input, size_t input_length)</div></div>
-<div class="ttc" id="group__hash_html_ga7be923c5700c9c70ef77ee9b76d1a5c0"><div class="ttname"><a href="group__hash.html#ga7be923c5700c9c70ef77ee9b76d1a5c0">psa_hash_verify</a></div><div class="ttdeci">psa_status_t psa_hash_verify(psa_hash_operation_t *operation, const uint8_t *hash, size_t hash_length)</div></div>
-<div class="ttc" id="group__derivation_html_ga9e5f549aa1f6f3863a07008d3d98f91a"><div class="ttname"><a href="group__derivation.html#ga9e5f549aa1f6f3863a07008d3d98f91a">psa_key_derivation_input_key</a></div><div class="ttdeci">psa_status_t psa_key_derivation_input_key(psa_crypto_generator_t *generator, psa_key_derivation_step_t step, psa_key_handle_t handle)</div></div>
-<div class="ttc" id="group__aead_html_gad3431e28d05002c2a7b0760610176050"><div class="ttname"><a href="group__aead.html#gad3431e28d05002c2a7b0760610176050">psa_aead_set_lengths</a></div><div class="ttdeci">psa_status_t psa_aead_set_lengths(psa_aead_operation_t *operation, size_t ad_length, size_t plaintext_length)</div></div>
-<div class="ttc" id="group__aead_html_gaa8ce6527f2e227f1071fadbf2099793b"><div class="ttname"><a href="group__aead.html#gaa8ce6527f2e227f1071fadbf2099793b">psa_aead_decrypt</a></div><div class="ttdeci">psa_status_t psa_aead_decrypt(psa_key_handle_t handle, psa_algorithm_t alg, const uint8_t *nonce, size_t nonce_length, const uint8_t *additional_data, size_t additional_data_length, const uint8_t *ciphertext, size_t ciphertext_length, uint8_t *plaintext, size_t plaintext_size, size_t *plaintext_length)</div></div>
-<div class="ttc" id="group__generators_html_ga7fcdf07cd37279ca167db484053da894"><div class="ttname"><a href="group__generators.html#ga7fcdf07cd37279ca167db484053da894">psa_generator_import_key</a></div><div class="ttdeci">psa_status_t psa_generator_import_key(psa_key_handle_t handle, psa_key_type_t type, size_t bits, psa_crypto_generator_t *generator)</div></div>
-<div class="ttc" id="group__hash_html_ga39673348f3302b4646bd780034a5aeda"><div class="ttname"><a href="group__hash.html#ga39673348f3302b4646bd780034a5aeda">psa_hash_clone</a></div><div class="ttdeci">psa_status_t psa_hash_clone(const psa_hash_operation_t *source_operation, psa_hash_operation_t *target_operation)</div></div>
-<div class="ttc" id="group__policy_html_gaed087d1386b807edee66b2e445ba9111"><div class="ttname"><a href="group__policy.html#gaed087d1386b807edee66b2e445ba9111">psa_get_key_policy</a></div><div class="ttdeci">psa_status_t psa_get_key_policy(psa_key_handle_t handle, psa_key_policy_t *policy)</div><div class="ttdoc">Get the usage policy for a key slot. </div></div>
-<div class="ttc" id="structpsa__generate__key__extra__rsa_html_a53ccb9e4375f3c9af6e3ecfe111ce11d"><div class="ttname"><a href="structpsa__generate__key__extra__rsa.html#a53ccb9e4375f3c9af6e3ecfe111ce11d">psa_generate_key_extra_rsa::e</a></div><div class="ttdeci">uint32_t e</div><div class="ttdef"><b>Definition:</b> crypto.h:3256</div></div>
-<div class="ttc" id="group__crypto__types_html_gac2e4d47f1300d73c2f829a6d99252d69"><div class="ttname"><a href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a></div><div class="ttdeci">uint32_t psa_algorithm_t</div><div class="ttdoc">Encoding of a cryptographic algorithm. </div><div class="ttdef"><b>Definition:</b> crypto_types.h:74</div></div>
-<div class="ttc" id="group__hash_html_ga3c4205d2ce66c4095fc5c78c25273fab"><div class="ttname"><a href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a></div><div class="ttdeci">struct psa_hash_operation_s psa_hash_operation_t</div><div class="ttdef"><b>Definition:</b> crypto.h:907</div></div>
-<div class="ttc" id="group__aead_html_ga44de092cf58bb6c820c5c80a6c51610d"><div class="ttname"><a href="group__aead.html#ga44de092cf58bb6c820c5c80a6c51610d">psa_aead_encrypt</a></div><div class="ttdeci">psa_status_t psa_aead_encrypt(psa_key_handle_t handle, psa_algorithm_t alg, const uint8_t *nonce, size_t nonce_length, const uint8_t *additional_data, size_t additional_data_length, const uint8_t *plaintext, size_t plaintext_length, uint8_t *ciphertext, size_t ciphertext_size, size_t *ciphertext_length)</div></div>
-<div class="ttc" id="group__MAC_html_gacd8dd54855ba1bc0a03f104f252884fd"><div class="ttname"><a href="group__MAC.html#gacd8dd54855ba1bc0a03f104f252884fd">psa_mac_abort</a></div><div class="ttdeci">psa_status_t psa_mac_abort(psa_mac_operation_t *operation)</div></div>
-<div class="ttc" id="group__hash_html_ga8d72896cf70fc4d514c5c6b978912515"><div class="ttname"><a href="group__hash.html#ga8d72896cf70fc4d514c5c6b978912515">psa_hash_setup</a></div><div class="ttdeci">psa_status_t psa_hash_setup(psa_hash_operation_t *operation, psa_algorithm_t alg)</div></div>
-<div class="ttc" id="group__aead_html_ga439896519d4a367ec86b47f201884152"><div class="ttname"><a href="group__aead.html#ga439896519d4a367ec86b47f201884152">psa_aead_decrypt_setup</a></div><div class="ttdeci">psa_status_t psa_aead_decrypt_setup(psa_aead_operation_t *operation, psa_key_handle_t handle, psa_algorithm_t alg)</div></div>
-<div class="ttc" id="group__policy_html_ga7bb9de71337e0e98de843aa7f9b55f25"><div class="ttname"><a href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a></div><div class="ttdeci">uint32_t psa_key_usage_t</div><div class="ttdoc">Encoding of permitted usage on a key. </div><div class="ttdef"><b>Definition:</b> crypto_types.h:97</div></div>
-<div class="ttc" id="group__policy_html_gaf553efd409845b6d09ff25ce2ba36607"><div class="ttname"><a href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a></div><div class="ttdeci">struct psa_key_policy_s psa_key_policy_t</div><div class="ttdef"><b>Definition:</b> crypto.h:128</div></div>
-<div class="ttc" id="group__import__export_html_ga165085fc1bc7a78b91792fdd94ae102c"><div class="ttname"><a href="group__import__export.html#ga165085fc1bc7a78b91792fdd94ae102c">psa_destroy_key</a></div><div class="ttdeci">psa_status_t psa_destroy_key(psa_key_handle_t handle)</div><div class="ttdoc">Destroy a key. </div></div>
-<div class="ttc" id="group__policy_html_gac16792fd6d375a5f76d372090df40607"><div class="ttname"><a href="group__policy.html#gac16792fd6d375a5f76d372090df40607">psa_key_policy_set_usage</a></div><div class="ttdeci">void psa_key_policy_set_usage(psa_key_policy_t *policy, psa_key_usage_t usage, psa_algorithm_t alg)</div><div class="ttdoc">Set the standard fields of a policy structure. </div></div>
-<div class="ttc" id="group__initialization_html_ga2de150803fc2f7dc6101d5af7e921dd9"><div class="ttname"><a href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9">psa_crypto_init</a></div><div class="ttdeci">psa_status_t psa_crypto_init(void)</div><div class="ttdoc">Library initialization. </div></div>
-<div class="ttc" id="group__platform_html_gabf6d5fd4e2ea89ecd425c88f057e7f75"><div class="ttname"><a href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a></div><div class="ttdeci">_unsigned_integral_type_ psa_key_handle_t</div><div class="ttdoc">Key handle. </div><div class="ttdef"><b>Definition:</b> crypto.h:47</div></div>
-<div class="ttc" id="group__MAC_html_gace78d9b51394f9d4f77952963665897a"><div class="ttname"><a href="group__MAC.html#gace78d9b51394f9d4f77952963665897a">psa_mac_compute</a></div><div class="ttdeci">psa_status_t psa_mac_compute(psa_key_handle_t handle, psa_algorithm_t alg, const uint8_t *input, size_t input_length, uint8_t *mac, size_t mac_size, size_t *mac_length)</div></div>
-<div class="ttc" id="crypto__sizes_8h_html"><div class="ttname"><a href="crypto__sizes_8h.html">crypto_sizes.h</a></div><div class="ttdoc">PSA cryptography module: Mbed TLS buffer size macros. </div></div>
-<div class="ttc" id="group__derivation_html_ga2c7fe304cacc141ffb91553548abc5d2"><div class="ttname"><a href="group__derivation.html#ga2c7fe304cacc141ffb91553548abc5d2">psa_key_agreement</a></div><div class="ttdeci">psa_status_t psa_key_agreement(psa_crypto_generator_t *generator, psa_key_derivation_step_t step, psa_key_handle_t private_key, const uint8_t *peer_key, size_t peer_key_length)</div></div>
-<div class="ttc" id="group__key__management_html_gaa9f1c848cf78b80fe2a7b18bb7ccec50"><div class="ttname"><a href="group__key__management.html#gaa9f1c848cf78b80fe2a7b18bb7ccec50">psa_open_key</a></div><div class="ttdeci">psa_status_t psa_open_key(psa_key_lifetime_t lifetime, psa_key_id_t id, psa_key_handle_t *handle)</div></div>
-<div class="ttc" id="group__MAC_html_ga5560af371497babefe03c9da4e8a1c05"><div class="ttname"><a href="group__MAC.html#ga5560af371497babefe03c9da4e8a1c05">psa_mac_update</a></div><div class="ttdeci">psa_status_t psa_mac_update(psa_mac_operation_t *operation, const uint8_t *input, size_t input_length)</div></div>
-<div class="ttc" id="group__aead_html_ga40641d0721ca7fe01bbcd9ef635fbc46"><div class="ttname"><a href="group__aead.html#ga40641d0721ca7fe01bbcd9ef635fbc46">psa_aead_set_nonce</a></div><div class="ttdeci">psa_status_t psa_aead_set_nonce(psa_aead_operation_t *operation, const unsigned char *nonce, size_t nonce_length)</div></div>
-<div class="ttc" id="group__hash_html_gab0b4d5f9912a615559497a467b532928"><div class="ttname"><a href="group__hash.html#gab0b4d5f9912a615559497a467b532928">psa_hash_abort</a></div><div class="ttdeci">psa_status_t psa_hash_abort(psa_hash_operation_t *operation)</div></div>
-<div class="ttc" id="group__key__management_html_ga1e4825ab59260aeb3bdbb3ff07210022"><div class="ttname"><a href="group__key__management.html#ga1e4825ab59260aeb3bdbb3ff07210022">psa_get_key_lifetime</a></div><div class="ttdeci">psa_status_t psa_get_key_lifetime(psa_key_handle_t handle, psa_key_lifetime_t *lifetime)</div><div class="ttdoc">Retrieve the lifetime of an open key. </div></div>
-<div class="ttc" id="group__aead_html_ga3b105de2088cef7c3d9e2fd8048c841c"><div class="ttname"><a href="group__aead.html#ga3b105de2088cef7c3d9e2fd8048c841c">psa_aead_update</a></div><div class="ttdeci">psa_status_t psa_aead_update(psa_aead_operation_t *operation, const uint8_t *input, size_t input_length, unsigned char *output, size_t output_size, size_t *output_length)</div></div>
-<div class="ttc" id="group__cipher_html_ga1399de29db657e3737bb09927aae51fa"><div class="ttname"><a href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a></div><div class="ttdeci">struct psa_cipher_operation_s psa_cipher_operation_t</div><div class="ttdef"><b>Definition:</b> crypto.h:1622</div></div>
-<div class="ttc" id="group__crypto__types_html_ga578159487dfc7096cb191b0d2befe628"><div class="ttname"><a href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a></div><div class="ttdeci">uint32_t psa_key_type_t</div><div class="ttdoc">Encoding of a key type. </div><div class="ttdef"><b>Definition:</b> crypto_types.h:61</div></div>
-<div class="ttc" id="group__aead_html_gaaed211fc61977c859d6ff07f39f59219"><div class="ttname"><a href="group__aead.html#gaaed211fc61977c859d6ff07f39f59219">psa_aead_verify</a></div><div class="ttdeci">psa_status_t psa_aead_verify(psa_aead_operation_t *operation, const uint8_t *tag, size_t tag_length)</div></div>
-<div class="ttc" id="group__MAC_html_ga78f0838b0c4e3db28b26355624d4bd37"><div class="ttname"><a href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a></div><div class="ttdeci">struct psa_mac_operation_s psa_mac_operation_t</div><div class="ttdef"><b>Definition:</b> crypto.h:1237</div></div>
-<div class="ttc" id="group__aead_html_gae8a5f93d92318c8f592ee9fbb9d36ba0"><div class="ttname"><a href="group__aead.html#gae8a5f93d92318c8f592ee9fbb9d36ba0">psa_aead_abort</a></div><div class="ttdeci">psa_status_t psa_aead_abort(psa_aead_operation_t *operation)</div></div>
-<div class="ttc" id="group__policy_html_gaadf16b89ace53e1d2cb5bcb0aef24c86"><div class="ttname"><a href="group__policy.html#gaadf16b89ace53e1d2cb5bcb0aef24c86">psa_key_policy_get_algorithm</a></div><div class="ttdeci">psa_algorithm_t psa_key_policy_get_algorithm(const psa_key_policy_t *policy)</div><div class="ttdoc">Retrieve the algorithm field of a policy structure. </div></div>
-<div class="ttc" id="group__key__lifetimes_html_ga6821ff6dd39dc2bc370ded760ad8b0cf"><div class="ttname"><a href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">psa_key_lifetime_t</a></div><div class="ttdeci">uint32_t psa_key_lifetime_t</div><div class="ttdef"><b>Definition:</b> crypto_types.h:84</div></div>
-<div class="ttc" id="group__generators_html_ga7453491e3b440193be2c5dccc2040fd2"><div class="ttname"><a href="group__generators.html#ga7453491e3b440193be2c5dccc2040fd2">psa_get_generator_capacity</a></div><div class="ttdeci">psa_status_t psa_get_generator_capacity(const psa_crypto_generator_t *generator, size_t *capacity)</div></div>
-<div class="ttc" id="group__policy_html_ga1e2a6e50b621864f95d438222a3c640b"><div class="ttname"><a href="group__policy.html#ga1e2a6e50b621864f95d438222a3c640b">psa_set_key_policy</a></div><div class="ttdeci">psa_status_t psa_set_key_policy(psa_key_handle_t handle, const psa_key_policy_t *policy)</div><div class="ttdoc">Set the usage policy on a key slot. </div></div>
-<div class="ttc" id="group__key__management_html_ga4108f255d3eaa6d23a7a14b684af8d7c"><div class="ttname"><a href="group__key__management.html#ga4108f255d3eaa6d23a7a14b684af8d7c">psa_create_key</a></div><div class="ttdeci">psa_status_t psa_create_key(psa_key_lifetime_t lifetime, psa_key_id_t id, psa_key_handle_t *handle)</div></div>
-<div class="ttc" id="group__import__export_html_gac9f999cb4d098663d56095afe81a453a"><div class="ttname"><a href="group__import__export.html#gac9f999cb4d098663d56095afe81a453a">psa_import_key</a></div><div class="ttdeci">psa_status_t psa_import_key(psa_key_handle_t handle, psa_key_type_t type, const uint8_t *data, size_t data_length)</div><div class="ttdoc">Import a key in binary format. </div></div>
-<div class="ttc" id="group__error_html_ga05676e70ba5c6a7565aff3c36677c1f9"><div class="ttname"><a href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a></div><div class="ttdeci">int32_t psa_status_t</div><div class="ttdoc">Function return status. </div><div class="ttdef"><b>Definition:</b> crypto_types.h:51</div></div>
-<div class="ttc" id="group__cipher_html_gaad482cdca2098bca0620596aaa02eaa4"><div class="ttname"><a href="group__cipher.html#gaad482cdca2098bca0620596aaa02eaa4">psa_cipher_abort</a></div><div class="ttdeci">psa_status_t psa_cipher_abort(psa_cipher_operation_t *operation)</div></div>
-<div class="ttc" id="group__generators_html_ga45676ec3c719622f95caaf926f44bb6e"><div class="ttname"><a href="group__generators.html#ga45676ec3c719622f95caaf926f44bb6e">psa_set_generator_capacity</a></div><div class="ttdeci">psa_status_t psa_set_generator_capacity(psa_crypto_generator_t *generator, size_t capacity)</div></div>
-<div class="ttc" id="group__cipher_html_gac76dda492d9a1ba6b327bff610ec17b2"><div class="ttname"><a href="group__cipher.html#gac76dda492d9a1ba6b327bff610ec17b2">psa_cipher_encrypt</a></div><div class="ttdeci">psa_status_t psa_cipher_encrypt(psa_key_handle_t handle, psa_algorithm_t alg, const uint8_t *input, size_t input_length, uint8_t *output, size_t output_size, size_t *output_length)</div></div>
-<div class="ttc" id="group__MAC_html_gad33f2b15119593571ca6b8e7c757ab0e"><div class="ttname"><a href="group__MAC.html#gad33f2b15119593571ca6b8e7c757ab0e">psa_mac_sign_setup</a></div><div class="ttdeci">psa_status_t psa_mac_sign_setup(psa_mac_operation_t *operation, psa_key_handle_t handle, psa_algorithm_t alg)</div></div>
-<div class="ttc" id="group__derivation_html_ga1825696be813dfac2b8d3d02717e71c5"><div class="ttname"><a href="group__derivation.html#ga1825696be813dfac2b8d3d02717e71c5">psa_key_derivation_setup</a></div><div class="ttdeci">psa_status_t psa_key_derivation_setup(psa_crypto_generator_t *generator, psa_algorithm_t alg)</div></div>
-<div class="ttc" id="group__import__export_html_gae8939902d6977ea8ad13eb7b4db9a042"><div class="ttname"><a href="group__import__export.html#gae8939902d6977ea8ad13eb7b4db9a042">psa_get_key_information</a></div><div class="ttdeci">psa_status_t psa_get_key_information(psa_key_handle_t handle, psa_key_type_t *type, size_t *bits)</div><div class="ttdoc">Get basic metadata about a key. </div></div>
-<div class="ttc" id="group__asymmetric_html_ga1b0db9d345b5048cdd39357ac2d56c07"><div class="ttname"><a href="group__asymmetric.html#ga1b0db9d345b5048cdd39357ac2d56c07">psa_asymmetric_sign</a></div><div class="ttdeci">psa_status_t psa_asymmetric_sign(psa_key_handle_t handle, psa_algorithm_t alg, const uint8_t *hash, size_t hash_length, uint8_t *signature, size_t signature_size, size_t *signature_length)</div><div class="ttdoc">Sign a hash or short message with a private key. </div></div>
-<div class="ttc" id="group__generators_html_ga1f894c4fba202ef8e307d72caf489e3b"><div class="ttname"><a href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a></div><div class="ttdeci">struct psa_crypto_generator_s psa_crypto_generator_t</div><div class="ttdef"><b>Definition:</b> crypto.h:2805</div></div>
-<div class="ttc" id="group__hash_html_ga4795fd06a0067b0adcd92e9627b8c97e"><div class="ttname"><a href="group__hash.html#ga4795fd06a0067b0adcd92e9627b8c97e">psa_hash_finish</a></div><div class="ttdeci">psa_status_t psa_hash_finish(psa_hash_operation_t *operation, uint8_t *hash, size_t hash_size, size_t *hash_length)</div></div>
-<div class="ttc" id="structpsa__generate__key__extra__rsa_html"><div class="ttname"><a href="structpsa__generate__key__extra__rsa.html">psa_generate_key_extra_rsa</a></div><div class="ttdef"><b>Definition:</b> crypto.h:3255</div></div>
-</div><!-- fragment --></div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/crypto__enum_8h.html b/docs/html/crypto__enum_8h.html
deleted file mode 100644
index 851333c..0000000
--- a/docs/html/crypto__enum_8h.html
+++ /dev/null
@@ -1,697 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: psa/crypto_enum.h File Reference</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">Working draft</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li class="current"><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
- <div id="navrow2" class="tabs2">
- <ul class="tablist">
- <li><a href="files.html"><span>File List</span></a></li>
- <li><a href="globals.html"><span>File Members</span></a></li>
- </ul>
- </div>
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div id="nav-path" class="navpath">
- <ul>
-<li class="navelem"><a class="el" href="dir_7dae9cfde651cd3cb034485ce5e391b9.html">psa</a></li> </ul>
-</div>
-</div><!-- top -->
-<div class="header">
- <div class="summary">
-<a href="#define-members">Macros</a> |
-<a href="#typedef-members">Typedefs</a> </div>
- <div class="headertitle">
-<div class="title">crypto_enum.h File Reference</div> </div>
-</div><!--header-->
-<div class="contents">
-
-<p>PSA cryptography module: Integer encodings.
-<a href="#details">More...</a></p>
-<div class="textblock"><code>#include <stdint.h></code><br />
-</div><div class="textblock"><div class="dynheader">
-Include dependency graph for crypto_enum.h:</div>
-<div class="dyncontent">
-<div class="center"><img src="crypto__enum_8h__incl.png" border="0" usemap="#psa_2crypto__enum_8h" alt=""/></div>
-</div>
-</div><div class="textblock"><div class="dynheader">
-This graph shows which files directly or indirectly include this file:</div>
-<div class="dyncontent">
-<div class="center"><img src="crypto__enum_8h__dep__incl.png" border="0" usemap="#psa_2crypto__enum_8hdep" alt=""/></div>
-<map name="psa_2crypto__enum_8hdep" id="psa_2crypto__enum_8hdep">
-<area shape="rect" id="node2" href="crypto_8h.html" title="Platform Security Architecture cryptography module. " alt="" coords="25,80,119,107"/>
-</map>
-</div>
-</div>
-<p><a href="crypto__enum_8h_source.html">Go to the source code of this file.</a></p>
-<table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="define-members"></a>
-Macros</h2></td></tr>
-<tr class="memitem:ga4cc859e2c66ca381c7418db3527a65e1"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)0)</td></tr>
-<tr class="separator:ga4cc859e2c66ca381c7418db3527a65e1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga24d5fdcdd759f846f79d9e581c63a83f"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga24d5fdcdd759f846f79d9e581c63a83f">PSA_ERROR_UNKNOWN_ERROR</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)1)</td></tr>
-<tr class="separator:ga24d5fdcdd759f846f79d9e581c63a83f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1dcc6d130633ed5db8942257581b55dd"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)2)</td></tr>
-<tr class="separator:ga1dcc6d130633ed5db8942257581b55dd"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4d1b8dd8526177a15a210b7afc1accb1"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga4d1b8dd8526177a15a210b7afc1accb1">PSA_ERROR_NOT_PERMITTED</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)3)</td></tr>
-<tr class="separator:ga4d1b8dd8526177a15a210b7afc1accb1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga695025f4ec11249aee7ea3d0f65e01c8"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga695025f4ec11249aee7ea3d0f65e01c8">PSA_ERROR_BUFFER_TOO_SMALL</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)4)</td></tr>
-<tr class="separator:ga695025f4ec11249aee7ea3d0f65e01c8"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac2fee3a51249fbea45360aaa911f3e58"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#gac2fee3a51249fbea45360aaa911f3e58">PSA_ERROR_OCCUPIED_SLOT</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)5)</td></tr>
-<tr class="separator:gac2fee3a51249fbea45360aaa911f3e58"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaba00e3e6ceb2b12965a81e5ac02ae040"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040">PSA_ERROR_EMPTY_SLOT</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)6)</td></tr>
-<tr class="separator:gaba00e3e6ceb2b12965a81e5ac02ae040"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga933d40fa2a591004f2e93aa91e11db84"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)7)</td></tr>
-<tr class="separator:ga933d40fa2a591004f2e93aa91e11db84"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga798df25a505ebf931f7bec1f80f1f85f"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)8)</td></tr>
-<tr class="separator:ga798df25a505ebf931f7bec1f80f1f85f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga91b2ad8a867517a2651f1b076c5216e5"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)9)</td></tr>
-<tr class="separator:ga91b2ad8a867517a2651f1b076c5216e5"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga897a45eb206a6f6b7be7ffbe36f0d766"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga897a45eb206a6f6b7be7ffbe36f0d766">PSA_ERROR_INSUFFICIENT_STORAGE</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)10)</td></tr>
-<tr class="separator:ga897a45eb206a6f6b7be7ffbe36f0d766"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga5cdb6948371d49e916106249020ea3f7"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)11)</td></tr>
-<tr class="separator:ga5cdb6948371d49e916106249020ea3f7"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gadd169a1af2707862b95fb9df91dfc37d"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#gadd169a1af2707862b95fb9df91dfc37d">PSA_ERROR_STORAGE_FAILURE</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)12)</td></tr>
-<tr class="separator:gadd169a1af2707862b95fb9df91dfc37d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga08b10e70fa5ff0b05c631d9f8f6b2c6b"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)13)</td></tr>
-<tr class="separator:ga08b10e70fa5ff0b05c631d9f8f6b2c6b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga2c5dda1485cb54f2385cb9c1279a7004"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)14)</td></tr>
-<tr class="separator:ga2c5dda1485cb54f2385cb9c1279a7004"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4deb59fec02297ec5d8b42178323f675"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga4deb59fec02297ec5d8b42178323f675">PSA_ERROR_INSUFFICIENT_ENTROPY</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)15)</td></tr>
-<tr class="separator:ga4deb59fec02297ec5d8b42178323f675"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga35927f755d232c4766de600f2c49e9f2"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga35927f755d232c4766de600f2c49e9f2">PSA_ERROR_INVALID_SIGNATURE</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)16)</td></tr>
-<tr class="separator:ga35927f755d232c4766de600f2c49e9f2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gabe29594edbfb152cf153975b0597ac48"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#gabe29594edbfb152cf153975b0597ac48">PSA_ERROR_INVALID_PADDING</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)17)</td></tr>
-<tr class="separator:gabe29594edbfb152cf153975b0597ac48"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaf1fa61f72e9e5b4a848c991bea495767"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#gaf1fa61f72e9e5b4a848c991bea495767">PSA_ERROR_INSUFFICIENT_CAPACITY</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)18)</td></tr>
-<tr class="separator:gaf1fa61f72e9e5b4a848c991bea495767"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gadf22718935657c2c3168c228204085f9"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)19)</td></tr>
-<tr class="separator:gadf22718935657c2c3168c228204085f9"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gafce7ab2b54ce97ea5bff73f13a9f3e5b"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gafce7ab2b54ce97ea5bff73f13a9f3e5b">PSA_KEY_TYPE_NONE</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x00000000)</td></tr>
-<tr class="separator:gafce7ab2b54ce97ea5bff73f13a9f3e5b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga8dbaed2fdb1ebae8aa127ad3988516f7"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga8dbaed2fdb1ebae8aa127ad3988516f7">PSA_KEY_TYPE_VENDOR_FLAG</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x80000000)</td></tr>
-<tr class="separator:ga8dbaed2fdb1ebae8aa127ad3988516f7"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6eeda1b2a1550050cf68dbcac35ad8ac"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_TYPE_CATEGORY_MASK</b>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x70000000)</td></tr>
-<tr class="separator:ga6eeda1b2a1550050cf68dbcac35ad8ac"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga8f214beb04334be08f927f227f097ef1"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_TYPE_CATEGORY_SYMMETRIC</b>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x40000000)</td></tr>
-<tr class="separator:ga8f214beb04334be08f927f227f097ef1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab8af75718c5e7b8987720a3fe8abb18f"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_TYPE_CATEGORY_RAW</b>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x50000000)</td></tr>
-<tr class="separator:gab8af75718c5e7b8987720a3fe8abb18f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga58b975beeee1f937cecb71c8051c6357"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY</b>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x60000000)</td></tr>
-<tr class="separator:ga58b975beeee1f937cecb71c8051c6357"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga708196a91ec0384de98e092b9a16f5e8"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_TYPE_CATEGORY_KEY_PAIR</b>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x70000000)</td></tr>
-<tr class="separator:ga708196a91ec0384de98e092b9a16f5e8"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga5a77cb4db2d02ffce77631339e3240f4"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_TYPE_CATEGORY_FLAG_PAIR</b>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x10000000)</td></tr>
-<tr class="separator:ga5a77cb4db2d02ffce77631339e3240f4"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gadbe4c086a6562aefe344bc79e51bdfd3"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gadbe4c086a6562aefe344bc79e51bdfd3">PSA_KEY_TYPE_IS_VENDOR_DEFINED</a>(type)   (((type) & <a class="el" href="group__crypto__types.html#ga8dbaed2fdb1ebae8aa127ad3988516f7">PSA_KEY_TYPE_VENDOR_FLAG</a>) != 0)</td></tr>
-<tr class="separator:gadbe4c086a6562aefe344bc79e51bdfd3"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaef86ce4e810e1c2c76068ac874bfef54"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaef86ce4e810e1c2c76068ac874bfef54">PSA_KEY_TYPE_IS_UNSTRUCTURED</a>(type)</td></tr>
-<tr class="separator:gaef86ce4e810e1c2c76068ac874bfef54"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab138ae2ebf2905dfbaf4154db2620939"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gab138ae2ebf2905dfbaf4154db2620939">PSA_KEY_TYPE_IS_ASYMMETRIC</a>(type)</td></tr>
-<tr class="separator:gab138ae2ebf2905dfbaf4154db2620939"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac674a0f059bc0cb72b47f0c517b4f45b"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gac674a0f059bc0cb72b47f0c517b4f45b">PSA_KEY_TYPE_IS_PUBLIC_KEY</a>(type)   (((type) & PSA_KEY_TYPE_CATEGORY_MASK) == PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY)</td></tr>
-<tr class="separator:gac674a0f059bc0cb72b47f0c517b4f45b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac14c6d6e1b2b7f4a92a7b757465cff29"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gac14c6d6e1b2b7f4a92a7b757465cff29">PSA_KEY_TYPE_IS_KEYPAIR</a>(type)   (((type) & PSA_KEY_TYPE_CATEGORY_MASK) == PSA_KEY_TYPE_CATEGORY_KEY_PAIR)</td></tr>
-<tr class="separator:gac14c6d6e1b2b7f4a92a7b757465cff29"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaf09f1ca1de6a7e7cff0fe516f3f6c91d"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaf09f1ca1de6a7e7cff0fe516f3f6c91d">PSA_KEY_TYPE_KEYPAIR_OF_PUBLIC_KEY</a>(type)   ((type) | PSA_KEY_TYPE_CATEGORY_FLAG_PAIR)</td></tr>
-<tr class="separator:gaf09f1ca1de6a7e7cff0fe516f3f6c91d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gace08e46dd7cbf642d50d982a25d02bec"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gace08e46dd7cbf642d50d982a25d02bec">PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR</a>(type)   ((type) & ~PSA_KEY_TYPE_CATEGORY_FLAG_PAIR)</td></tr>
-<tr class="separator:gace08e46dd7cbf642d50d982a25d02bec"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa97f92025533102616b32d571c940d80"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaa97f92025533102616b32d571c940d80">PSA_KEY_TYPE_RAW_DATA</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x50000001)</td></tr>
-<tr class="separator:gaa97f92025533102616b32d571c940d80"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga92d989f4ca64abd00f463defd773a6f8"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga92d989f4ca64abd00f463defd773a6f8">PSA_KEY_TYPE_HMAC</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x51000000)</td></tr>
-<tr class="separator:ga92d989f4ca64abd00f463defd773a6f8"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae871b2357b8593f33bfd51abbf93ebb1"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gae871b2357b8593f33bfd51abbf93ebb1">PSA_KEY_TYPE_DERIVE</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x52000000)</td></tr>
-<tr class="separator:gae871b2357b8593f33bfd51abbf93ebb1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6ee54579dcf278c677eda4bb1a29575e"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga6ee54579dcf278c677eda4bb1a29575e">PSA_KEY_TYPE_AES</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x40000001)</td></tr>
-<tr class="separator:ga6ee54579dcf278c677eda4bb1a29575e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga577562bfbbc691c820d55ec308333138"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga577562bfbbc691c820d55ec308333138">PSA_KEY_TYPE_DES</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x40000002)</td></tr>
-<tr class="separator:ga577562bfbbc691c820d55ec308333138"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gad8e5da742343fd5519f9d8a630c2ed81"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gad8e5da742343fd5519f9d8a630c2ed81">PSA_KEY_TYPE_CAMELLIA</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x40000003)</td></tr>
-<tr class="separator:gad8e5da742343fd5519f9d8a630c2ed81"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae4d46e83f910dcaa126000a8ed03cde9"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gae4d46e83f910dcaa126000a8ed03cde9">PSA_KEY_TYPE_ARC4</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x40000004)</td></tr>
-<tr class="separator:gae4d46e83f910dcaa126000a8ed03cde9"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga9ba0878f56c8bcd1995ac017a74f513b"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga9ba0878f56c8bcd1995ac017a74f513b">PSA_KEY_TYPE_RSA_PUBLIC_KEY</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x60010000)</td></tr>
-<tr class="separator:ga9ba0878f56c8bcd1995ac017a74f513b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga581f50687f5d650456925278948f2799"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga581f50687f5d650456925278948f2799">PSA_KEY_TYPE_RSA_KEYPAIR</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x70010000)</td></tr>
-<tr class="separator:ga581f50687f5d650456925278948f2799"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga0e1d8f241228e49c9cadadfb4579ef1a"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga0e1d8f241228e49c9cadadfb4579ef1a">PSA_KEY_TYPE_IS_RSA</a>(type)   (<a class="el" href="group__crypto__types.html#gace08e46dd7cbf642d50d982a25d02bec">PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR</a>(type) == <a class="el" href="group__crypto__types.html#ga9ba0878f56c8bcd1995ac017a74f513b">PSA_KEY_TYPE_RSA_PUBLIC_KEY</a>)</td></tr>
-<tr class="separator:ga0e1d8f241228e49c9cadadfb4579ef1a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga5e7439c2905136366c3a876e62e5ddfc"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga5e7439c2905136366c3a876e62e5ddfc">PSA_KEY_TYPE_DSA_PUBLIC_KEY</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x60020000)</td></tr>
-<tr class="separator:ga5e7439c2905136366c3a876e62e5ddfc"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga011010ee28c20388f3d89fb27088ed62"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga011010ee28c20388f3d89fb27088ed62">PSA_KEY_TYPE_DSA_KEYPAIR</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x70020000)</td></tr>
-<tr class="separator:ga011010ee28c20388f3d89fb27088ed62"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga273fdfcf23eb0624f8b63d2321cf95c1"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga273fdfcf23eb0624f8b63d2321cf95c1">PSA_KEY_TYPE_IS_DSA</a>(type)   (<a class="el" href="group__crypto__types.html#gace08e46dd7cbf642d50d982a25d02bec">PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR</a>(type) == <a class="el" href="group__crypto__types.html#ga5e7439c2905136366c3a876e62e5ddfc">PSA_KEY_TYPE_DSA_PUBLIC_KEY</a>)</td></tr>
-<tr class="separator:ga273fdfcf23eb0624f8b63d2321cf95c1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gad8d37a32a305dda9fb4af1707aace47c"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE</b>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x60030000)</td></tr>
-<tr class="separator:gad8d37a32a305dda9fb4af1707aace47c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6754658749714c6ac674bdf6d2d40767"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_TYPE_ECC_KEYPAIR_BASE</b>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x70030000)</td></tr>
-<tr class="separator:ga6754658749714c6ac674bdf6d2d40767"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gadc2a3c0041ac1d0a2b6f421d8e089b25"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_TYPE_ECC_CURVE_MASK</b>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x0000ffff)</td></tr>
-<tr class="separator:gadc2a3c0041ac1d0a2b6f421d8e089b25"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gadf3ad65d157bf5282849c954bf3f51af"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gadf3ad65d157bf5282849c954bf3f51af">PSA_KEY_TYPE_ECC_KEYPAIR</a>(curve)   (PSA_KEY_TYPE_ECC_KEYPAIR_BASE | (curve))</td></tr>
-<tr class="separator:gadf3ad65d157bf5282849c954bf3f51af"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gad54c03d3b47020e571a72cd01d978cf2"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gad54c03d3b47020e571a72cd01d978cf2">PSA_KEY_TYPE_ECC_PUBLIC_KEY</a>(curve)   (PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE | (curve))</td></tr>
-<tr class="separator:gad54c03d3b47020e571a72cd01d978cf2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga88e01fa06b585654689a99bcc06bbe66"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga88e01fa06b585654689a99bcc06bbe66">PSA_KEY_TYPE_IS_ECC</a>(type)</td></tr>
-<tr class="separator:ga88e01fa06b585654689a99bcc06bbe66"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga7bf101b671e8cf26f4cb08fcb679db4b"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga7bf101b671e8cf26f4cb08fcb679db4b">PSA_KEY_TYPE_IS_ECC_KEYPAIR</a>(type)</td></tr>
-<tr class="separator:ga7bf101b671e8cf26f4cb08fcb679db4b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga5af146a173b0c84d7e737e2fb6a3c0a7"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga5af146a173b0c84d7e737e2fb6a3c0a7">PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY</a>(type)</td></tr>
-<tr class="separator:ga5af146a173b0c84d7e737e2fb6a3c0a7"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga0c567210e6f80aa8f2aa87efa7a3a3f9"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga0c567210e6f80aa8f2aa87efa7a3a3f9">PSA_KEY_TYPE_GET_CURVE</a>(type)</td></tr>
-<tr class="separator:ga0c567210e6f80aa8f2aa87efa7a3a3f9"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4201013d5947c375fae7311b0f98bac7"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT163K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0001)</td></tr>
-<tr class="separator:ga4201013d5947c375fae7311b0f98bac7"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaca8816b785f492a8795b5276977d1369"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT163R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0002)</td></tr>
-<tr class="separator:gaca8816b785f492a8795b5276977d1369"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4ab7a853ceb3ad0a525ecb571633a1ca"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT163R2</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0003)</td></tr>
-<tr class="separator:ga4ab7a853ceb3ad0a525ecb571633a1ca"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac9fd11da90ca67649a5f51a158afe5f3"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT193R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0004)</td></tr>
-<tr class="separator:gac9fd11da90ca67649a5f51a158afe5f3"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga7a77f5e385f6439dae5857a7f35756eb"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT193R2</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0005)</td></tr>
-<tr class="separator:ga7a77f5e385f6439dae5857a7f35756eb"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga36e409c36983e41db5db202b1d2095b5"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT233K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0006)</td></tr>
-<tr class="separator:ga36e409c36983e41db5db202b1d2095b5"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga54997a9f8ef752c6d717171e01c31019"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT233R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0007)</td></tr>
-<tr class="separator:ga54997a9f8ef752c6d717171e01c31019"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaabccf2759188c3e98d82faa5d8dfcd8c"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT239K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0008)</td></tr>
-<tr class="separator:gaabccf2759188c3e98d82faa5d8dfcd8c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga28c765d75773b5fe083219e7c0b054f9"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT283K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0009)</td></tr>
-<tr class="separator:ga28c765d75773b5fe083219e7c0b054f9"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gafd8ecacea0d9e7e1a0247c047baf3372"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT283R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x000a)</td></tr>
-<tr class="separator:gafd8ecacea0d9e7e1a0247c047baf3372"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga2bf301617cc84a6f2b36a86cc29eaf4d"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT409K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x000b)</td></tr>
-<tr class="separator:ga2bf301617cc84a6f2b36a86cc29eaf4d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae41caa1cc16d3c35769b6edcb62c8957"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT409R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x000c)</td></tr>
-<tr class="separator:gae41caa1cc16d3c35769b6edcb62c8957"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga2043aa519549a6194d132d81816879bc"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT571K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x000d)</td></tr>
-<tr class="separator:ga2043aa519549a6194d132d81816879bc"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1607d2cb9591b56dbe1295bedc33e19e"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT571R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x000e)</td></tr>
-<tr class="separator:ga1607d2cb9591b56dbe1295bedc33e19e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga2ad14935d244d93ee0e4cfe9b1f218a4"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP160K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x000f)</td></tr>
-<tr class="separator:ga2ad14935d244d93ee0e4cfe9b1f218a4"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga35ed41203039e94eb4855cc70f28f7f0"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP160R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0010)</td></tr>
-<tr class="separator:ga35ed41203039e94eb4855cc70f28f7f0"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac465f57c34914a01aea8c220a613dfe6"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP160R2</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0011)</td></tr>
-<tr class="separator:gac465f57c34914a01aea8c220a613dfe6"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga58c806d45ab350287ddc49da833bd558"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP192K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0012)</td></tr>
-<tr class="separator:ga58c806d45ab350287ddc49da833bd558"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga5aa3ceff4603fa3fafd8f2286c5d3e4a"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP192R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0013)</td></tr>
-<tr class="separator:ga5aa3ceff4603fa3fafd8f2286c5d3e4a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gabfaaab2eaab0ac360e41c1aff6133cdf"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP224K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0014)</td></tr>
-<tr class="separator:gabfaaab2eaab0ac360e41c1aff6133cdf"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga8d1d21b6b87ba4158235b876ae79031d"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP224R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0015)</td></tr>
-<tr class="separator:ga8d1d21b6b87ba4158235b876ae79031d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaaa61941f815aff976a1debd910b1704c"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP256K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0016)</td></tr>
-<tr class="separator:gaaa61941f815aff976a1debd910b1704c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga11224270225c2b2dbfa2ab01073a4e93"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP256R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0017)</td></tr>
-<tr class="separator:ga11224270225c2b2dbfa2ab01073a4e93"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga3e870a36493143507a01a28c70790fa3"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP384R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0018)</td></tr>
-<tr class="separator:ga3e870a36493143507a01a28c70790fa3"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4482ff6155006ff509071c32ce263fdf"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP521R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0019)</td></tr>
-<tr class="separator:ga4482ff6155006ff509071c32ce263fdf"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa999b69c56af0cc1cebf4596f8578191"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_BRAINPOOL_P256R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x001a)</td></tr>
-<tr class="separator:gaa999b69c56af0cc1cebf4596f8578191"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga79f95ed8050f2dc7750cbac212c6e687"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_BRAINPOOL_P384R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x001b)</td></tr>
-<tr class="separator:ga79f95ed8050f2dc7750cbac212c6e687"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa03a2dc6096f336be3d68a1f7405e86c"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_BRAINPOOL_P512R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x001c)</td></tr>
-<tr class="separator:gaa03a2dc6096f336be3d68a1f7405e86c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac94faf3b8d9884221541f51f26b11c7a"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_CURVE25519</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x001d)</td></tr>
-<tr class="separator:gac94faf3b8d9884221541f51f26b11c7a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga902b0e91eff920873b3b59c740854305"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_CURVE448</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x001e)</td></tr>
-<tr class="separator:ga902b0e91eff920873b3b59c740854305"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gacaa366bdeb0413e63e87a667c5457b2e"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gacaa366bdeb0413e63e87a667c5457b2e">PSA_BLOCK_CIPHER_BLOCK_SIZE</a>(type)</td></tr>
-<tr class="separator:gacaa366bdeb0413e63e87a667c5457b2e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaf5d76750b6cfe3e7f0c8e9eee1162318"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_VENDOR_FLAG</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x80000000)</td></tr>
-<tr class="separator:gaf5d76750b6cfe3e7f0c8e9eee1162318"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga25e918c465b4421dbfaedad6b693d110"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CATEGORY_MASK</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x7f000000)</td></tr>
-<tr class="separator:ga25e918c465b4421dbfaedad6b693d110"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gafd048e1835b80e6daaff7fddce699757"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CATEGORY_HASH</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000000)</td></tr>
-<tr class="separator:gafd048e1835b80e6daaff7fddce699757"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga5e6e0039d0b0d18afb3e13e5b9602b3a"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CATEGORY_MAC</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x02000000)</td></tr>
-<tr class="separator:ga5e6e0039d0b0d18afb3e13e5b9602b3a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga68228a619db59eba93fd13e9129dbfe2"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CATEGORY_CIPHER</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x04000000)</td></tr>
-<tr class="separator:ga68228a619db59eba93fd13e9129dbfe2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga37fdd9cac2552f1568f38e091a826549"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CATEGORY_AEAD</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x06000000)</td></tr>
-<tr class="separator:ga37fdd9cac2552f1568f38e091a826549"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga68a0af1dd89b33fb1e53139f654988f6"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CATEGORY_SIGN</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x10000000)</td></tr>
-<tr class="separator:ga68a0af1dd89b33fb1e53139f654988f6"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga72f46c8256b760b174e6db61a61cd608"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x12000000)</td></tr>
-<tr class="separator:ga72f46c8256b760b174e6db61a61cd608"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga808e397a4891c612df4a5b20eebc2fac"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CATEGORY_KEY_AGREEMENT</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x22000000)</td></tr>
-<tr class="separator:ga808e397a4891c612df4a5b20eebc2fac"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac185b2274dd4e5f0b97c43334c2e478f"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CATEGORY_KEY_DERIVATION</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x30000000)</td></tr>
-<tr class="separator:gac185b2274dd4e5f0b97c43334c2e478f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga46ccba3464541e05a428ddc5c176e7af"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CATEGORY_KEY_SELECTION</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x31000000)</td></tr>
-<tr class="separator:ga46ccba3464541e05a428ddc5c176e7af"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga2396d8ba67096b3ebc69bc351a74c78b"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_VENDOR_DEFINED</b>(alg)   (((alg) & PSA_ALG_VENDOR_FLAG) != 0)</td></tr>
-<tr class="separator:ga2396d8ba67096b3ebc69bc351a74c78b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac9280662bb482590b4b33d1dcd32930f"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gac9280662bb482590b4b33d1dcd32930f">PSA_ALG_IS_HASH</a>(alg)   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_HASH)</td></tr>
-<tr class="separator:gac9280662bb482590b4b33d1dcd32930f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaca7aee4c9dde316b3b1a150a26eab776"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaca7aee4c9dde316b3b1a150a26eab776">PSA_ALG_IS_MAC</a>(alg)   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_MAC)</td></tr>
-<tr class="separator:gaca7aee4c9dde316b3b1a150a26eab776"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1d1a5a402ad89a2e68f12bfb535490eb"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga1d1a5a402ad89a2e68f12bfb535490eb">PSA_ALG_IS_CIPHER</a>(alg)   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_CIPHER)</td></tr>
-<tr class="separator:ga1d1a5a402ad89a2e68f12bfb535490eb"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1d44829d60065eaa4ac9a703e7d6abc8"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga1d44829d60065eaa4ac9a703e7d6abc8">PSA_ALG_IS_AEAD</a>(alg)   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_AEAD)</td></tr>
-<tr class="separator:ga1d44829d60065eaa4ac9a703e7d6abc8"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6d490d0904e0698f6c1268a89d72ff31"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga6d490d0904e0698f6c1268a89d72ff31">PSA_ALG_IS_SIGN</a>(alg)   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_SIGN)</td></tr>
-<tr class="separator:ga6d490d0904e0698f6c1268a89d72ff31"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga41d2ee937d54efd76bd54a97b2ebc08a"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga41d2ee937d54efd76bd54a97b2ebc08a">PSA_ALG_IS_ASYMMETRIC_ENCRYPTION</a>(alg)   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION)</td></tr>
-<tr class="separator:ga41d2ee937d54efd76bd54a97b2ebc08a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab19961aac97f3856f83057b04ba7c5f5"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_KEY_SELECTION_FLAG</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000000)</td></tr>
-<tr class="separator:gab19961aac97f3856f83057b04ba7c5f5"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga59753742cb06553bd22751bbef472b6f"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga59753742cb06553bd22751bbef472b6f">PSA_ALG_IS_KEY_AGREEMENT</a>(alg)</td></tr>
-<tr class="separator:ga59753742cb06553bd22751bbef472b6f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaf8b90c648aa53dbd06c236695e300cd0"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaf8b90c648aa53dbd06c236695e300cd0">PSA_ALG_IS_KEY_DERIVATION</a>(alg)   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_KEY_DERIVATION)</td></tr>
-<tr class="separator:gaf8b90c648aa53dbd06c236695e300cd0"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga51b1834ee5e98c6a83c2cfc7699f9077"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga51b1834ee5e98c6a83c2cfc7699f9077">PSA_ALG_IS_KEY_SELECTION</a>(alg)   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_KEY_SELECTION)</td></tr>
-<tr class="separator:ga51b1834ee5e98c6a83c2cfc7699f9077"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac41a7077aef55bb20c629c8949d43c57"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_HASH_MASK</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x000000ff)</td></tr>
-<tr class="separator:gac41a7077aef55bb20c629c8949d43c57"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab076ca67238cb4ebd81556db8f3dbac1"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_MD2</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000001)</td></tr>
-<tr class="separator:gab076ca67238cb4ebd81556db8f3dbac1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaac7ab8c28c117ef4ddf01affc8d3ceb2"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_MD4</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000002)</td></tr>
-<tr class="separator:gaac7ab8c28c117ef4ddf01affc8d3ceb2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gade591d9286d23382eb5cec099c84180d"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_MD5</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000003)</td></tr>
-<tr class="separator:gade591d9286d23382eb5cec099c84180d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6c5d3a32cda59086f07b85ef007033dd"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_RIPEMD160</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000004)</td></tr>
-<tr class="separator:ga6c5d3a32cda59086f07b85ef007033dd"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga3fca4e9f9ad4a1158817d1850dee82e5"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_SHA_1</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000005)</td></tr>
-<tr class="separator:ga3fca4e9f9ad4a1158817d1850dee82e5"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga25d6a3244d10a7148fe6b026d1979f7b"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga25d6a3244d10a7148fe6b026d1979f7b">PSA_ALG_SHA_224</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000008)</td></tr>
-<tr class="separator:ga25d6a3244d10a7148fe6b026d1979f7b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga619471f978e13cdd0a1e37145e4bf341"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga619471f978e13cdd0a1e37145e4bf341">PSA_ALG_SHA_256</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000009)</td></tr>
-<tr class="separator:ga619471f978e13cdd0a1e37145e4bf341"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga58af64dd9a86a287e8da9ed7739eead4"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga58af64dd9a86a287e8da9ed7739eead4">PSA_ALG_SHA_384</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x0100000a)</td></tr>
-<tr class="separator:ga58af64dd9a86a287e8da9ed7739eead4"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gafba3ae409f46d3dd7f37a0910660c3e9"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gafba3ae409f46d3dd7f37a0910660c3e9">PSA_ALG_SHA_512</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x0100000b)</td></tr>
-<tr class="separator:gafba3ae409f46d3dd7f37a0910660c3e9"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga3fe2d7c3c80e3186ca78d16a35d5d931"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga3fe2d7c3c80e3186ca78d16a35d5d931">PSA_ALG_SHA_512_224</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x0100000c)</td></tr>
-<tr class="separator:ga3fe2d7c3c80e3186ca78d16a35d5d931"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga5910b3964c14e9613e8643a45b09c2d4"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga5910b3964c14e9613e8643a45b09c2d4">PSA_ALG_SHA_512_256</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x0100000d)</td></tr>
-<tr class="separator:ga5910b3964c14e9613e8643a45b09c2d4"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga16f5fe34ccce68c2fada1224c054a999"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga16f5fe34ccce68c2fada1224c054a999">PSA_ALG_SHA3_224</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000010)</td></tr>
-<tr class="separator:ga16f5fe34ccce68c2fada1224c054a999"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaace70d9515489bbe3c5e7ac1b7d9155b"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaace70d9515489bbe3c5e7ac1b7d9155b">PSA_ALG_SHA3_256</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000011)</td></tr>
-<tr class="separator:gaace70d9515489bbe3c5e7ac1b7d9155b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab0f079257ea75e2acfe2fc3b38c78cd8"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gab0f079257ea75e2acfe2fc3b38c78cd8">PSA_ALG_SHA3_384</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000012)</td></tr>
-<tr class="separator:gab0f079257ea75e2acfe2fc3b38c78cd8"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga37e5dbe936dddb155e76f2997de27188"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga37e5dbe936dddb155e76f2997de27188">PSA_ALG_SHA3_512</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000013)</td></tr>
-<tr class="separator:ga37e5dbe936dddb155e76f2997de27188"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gabba3fcfee55533b0e25350e78a942e07"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_MAC_SUBCATEGORY_MASK</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x00c00000)</td></tr>
-<tr class="separator:gabba3fcfee55533b0e25350e78a942e07"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga0675192b82720fb8c9037a95bdeb6c88"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_HMAC_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x02800000)</td></tr>
-<tr class="separator:ga0675192b82720fb8c9037a95bdeb6c88"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga70f397425684b3efcde1e0e34c28261f"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga70f397425684b3efcde1e0e34c28261f">PSA_ALG_HMAC</a>(hash_alg)   (PSA_ALG_HMAC_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga70f397425684b3efcde1e0e34c28261f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaee84269106a947cb6ac353e15e6c4687"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_HMAC_GET_HASH</b>(hmac_alg)   (PSA_ALG_CATEGORY_HASH | ((hmac_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:gaee84269106a947cb6ac353e15e6c4687"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4a050c3c3cbc6eb96418f18847601c8a"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga4a050c3c3cbc6eb96418f18847601c8a">PSA_ALG_IS_HMAC</a>(alg)</td></tr>
-<tr class="separator:ga4a050c3c3cbc6eb96418f18847601c8a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga8c48784065c65c623a21b9a3ccc56b1d"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_MAC_TRUNCATION_MASK</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x00003f00)</td></tr>
-<tr class="separator:ga8c48784065c65c623a21b9a3ccc56b1d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6db5ce573e6ad52068aba31c3afdce31"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_MAC_TRUNCATION_OFFSET</b>   8</td></tr>
-<tr class="separator:ga6db5ce573e6ad52068aba31c3afdce31"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaf36137110baf7bb13c5028fd62c64276"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaf36137110baf7bb13c5028fd62c64276">PSA_ALG_TRUNCATED_MAC</a>(alg, mac_length)</td></tr>
-<tr class="separator:gaf36137110baf7bb13c5028fd62c64276"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa05a8d99634f3350597ac9284fb70cb1"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaa05a8d99634f3350597ac9284fb70cb1">PSA_ALG_FULL_LENGTH_MAC</a>(alg)   ((alg) & ~PSA_ALG_MAC_TRUNCATION_MASK)</td></tr>
-<tr class="separator:gaa05a8d99634f3350597ac9284fb70cb1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab03726c4476174e019a08e2a04018ce8"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gab03726c4476174e019a08e2a04018ce8">PSA_MAC_TRUNCATED_LENGTH</a>(alg)   (((alg) & PSA_ALG_MAC_TRUNCATION_MASK) >> PSA_MAC_TRUNCATION_OFFSET)</td></tr>
-<tr class="separator:gab03726c4476174e019a08e2a04018ce8"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaee0c29980b08305f6d0e7b3fbb588ade"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CIPHER_MAC_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x02c00000)</td></tr>
-<tr class="separator:gaee0c29980b08305f6d0e7b3fbb588ade"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga20bdc755de7b90f6621ccb1e6bb5d9e1"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CBC_MAC</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x02c00001)</td></tr>
-<tr class="separator:ga20bdc755de7b90f6621ccb1e6bb5d9e1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga146328a1e0023a02464e232d6ecefdc2"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CMAC</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x02c00002)</td></tr>
-<tr class="separator:ga146328a1e0023a02464e232d6ecefdc2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga69a012ce150219a2d97c3ab5582f0004"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_GMAC</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x02c00003)</td></tr>
-<tr class="separator:ga69a012ce150219a2d97c3ab5582f0004"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae49d1eb601125d65a5c5b252aa45479e"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gae49d1eb601125d65a5c5b252aa45479e">PSA_ALG_IS_BLOCK_CIPHER_MAC</a>(alg)</td></tr>
-<tr class="separator:gae49d1eb601125d65a5c5b252aa45479e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac79618293c4254143caa75f6c5c82fa1"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CIPHER_STREAM_FLAG</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x00800000)</td></tr>
-<tr class="separator:gac79618293c4254143caa75f6c5c82fa1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gabc80d19d140032e3b138db4ed37d0bd7"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CIPHER_FROM_BLOCK_FLAG</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x00400000)</td></tr>
-<tr class="separator:gabc80d19d140032e3b138db4ed37d0bd7"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gacfec68e0c6175e02e1b2ebc97df383c0"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gacfec68e0c6175e02e1b2ebc97df383c0">PSA_ALG_IS_STREAM_CIPHER</a>(alg)</td></tr>
-<tr class="separator:gacfec68e0c6175e02e1b2ebc97df383c0"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab6a5284decb0e5e1b5b8740a41ef3c5e"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gab6a5284decb0e5e1b5b8740a41ef3c5e">PSA_ALG_ARC4</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x04800001)</td></tr>
-<tr class="separator:gab6a5284decb0e5e1b5b8740a41ef3c5e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gad318309706a769cffdc64e4c7e06b2e9"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gad318309706a769cffdc64e4c7e06b2e9">PSA_ALG_CTR</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x04c00001)</td></tr>
-<tr class="separator:gad318309706a769cffdc64e4c7e06b2e9"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga0088c933e01d671f263a9a1f177cb5bc"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CFB</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x04c00002)</td></tr>
-<tr class="separator:ga0088c933e01d671f263a9a1f177cb5bc"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae96bb421fa634c6fa8f571f0112f1ddb"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_OFB</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x04c00003)</td></tr>
-<tr class="separator:gae96bb421fa634c6fa8f571f0112f1ddb"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa722c0e426a797fd6d99623f59748125"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaa722c0e426a797fd6d99623f59748125">PSA_ALG_XTS</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x044000ff)</td></tr>
-<tr class="separator:gaa722c0e426a797fd6d99623f59748125"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gacb332d72716958880ee7f97d8365ae66"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gacb332d72716958880ee7f97d8365ae66">PSA_ALG_CBC_NO_PADDING</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x04600100)</td></tr>
-<tr class="separator:gacb332d72716958880ee7f97d8365ae66"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaef50d2e9716eb6d476046608e4e0c78c"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaef50d2e9716eb6d476046608e4e0c78c">PSA_ALG_CBC_PKCS7</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x04600101)</td></tr>
-<tr class="separator:gaef50d2e9716eb6d476046608e4e0c78c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac2c0e7d21f1b2df5e76bcb4a8f84273c"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CCM</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x06001001)</td></tr>
-<tr class="separator:gac2c0e7d21f1b2df5e76bcb4a8f84273c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga0d7d02b15aaae490d38277d99f1c637c"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_GCM</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x06001002)</td></tr>
-<tr class="separator:ga0d7d02b15aaae490d38277d99f1c637c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga575d9082463a06a86c2a22dd63c2e772"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_AEAD_TAG_LENGTH_MASK</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x00003f00)</td></tr>
-<tr class="separator:ga575d9082463a06a86c2a22dd63c2e772"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga987d416146048906d40dd1d9572e3193"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_AEAD_TAG_LENGTH_OFFSET</b>   8</td></tr>
-<tr class="separator:ga987d416146048906d40dd1d9572e3193"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa63c520b62ab001d54d28801742fc9db"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaa63c520b62ab001d54d28801742fc9db">PSA_ALG_AEAD_WITH_TAG_LENGTH</a>(alg, tag_length)</td></tr>
-<tr class="separator:gaa63c520b62ab001d54d28801742fc9db"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaddea507e062250cda8a29407a9480d2b"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaddea507e062250cda8a29407a9480d2b">PSA_ALG_AEAD_WITH_DEFAULT_TAG_LENGTH</a>(alg)</td></tr>
-<tr class="separator:gaddea507e062250cda8a29407a9480d2b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6e52012ca3be6acb4c756c372f18c3eb"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><b>PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE</b>(alg, ref)</td></tr>
-<tr class="separator:ga6e52012ca3be6acb4c756c372f18c3eb"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga819b23c9899e92e9f867c7b2ae8f264c"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_RSA_PKCS1V15_SIGN_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x10020000)</td></tr>
-<tr class="separator:ga819b23c9899e92e9f867c7b2ae8f264c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga702ff75385a6ae7d4247033f479439af"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga702ff75385a6ae7d4247033f479439af">PSA_ALG_RSA_PKCS1V15_SIGN</a>(hash_alg)   (PSA_ALG_RSA_PKCS1V15_SIGN_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga702ff75385a6ae7d4247033f479439af"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4215e2a78dcf834e9a625927faa2a817"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga4215e2a78dcf834e9a625927faa2a817">PSA_ALG_RSA_PKCS1V15_SIGN_RAW</a>   PSA_ALG_RSA_PKCS1V15_SIGN_BASE</td></tr>
-<tr class="separator:ga4215e2a78dcf834e9a625927faa2a817"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga9d545279f23d43b1b2a744d0dd6826d0"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_RSA_PKCS1V15_SIGN</b>(alg)   (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_RSA_PKCS1V15_SIGN_BASE)</td></tr>
-<tr class="separator:ga9d545279f23d43b1b2a744d0dd6826d0"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga49d39a343790971b7a74644f4faea0c0"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_RSA_PSS_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x10030000)</td></tr>
-<tr class="separator:ga49d39a343790971b7a74644f4faea0c0"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga62152bf4cb4bf6aace5e1be8f143564d"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga62152bf4cb4bf6aace5e1be8f143564d">PSA_ALG_RSA_PSS</a>(hash_alg)   (PSA_ALG_RSA_PSS_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga62152bf4cb4bf6aace5e1be8f143564d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gafa04fae7393a76d5161558768cb82a78"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_RSA_PSS</b>(alg)   (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_RSA_PSS_BASE)</td></tr>
-<tr class="separator:gafa04fae7393a76d5161558768cb82a78"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga863284106894476e3a8524805410b55b"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_DSA_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x10040000)</td></tr>
-<tr class="separator:ga863284106894476e3a8524805410b55b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga9a68efdddff5ae95f104a1416b12742e"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga9a68efdddff5ae95f104a1416b12742e">PSA_ALG_DSA</a>(hash_alg)   (PSA_ALG_DSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga9a68efdddff5ae95f104a1416b12742e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gad3800dafc62d6a17bcae4bce98402e68"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_DETERMINISTIC_DSA_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x10050000)</td></tr>
-<tr class="separator:gad3800dafc62d6a17bcae4bce98402e68"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1d2a96f788cce4f8fc156d13342e70de"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_DSA_DETERMINISTIC_FLAG</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x00010000)</td></tr>
-<tr class="separator:ga1d2a96f788cce4f8fc156d13342e70de"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab8eb98fb6d2e094e47f3b44dfe128f94"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_DETERMINISTIC_DSA</b>(hash_alg)   (PSA_ALG_DETERMINISTIC_DSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:gab8eb98fb6d2e094e47f3b44dfe128f94"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gacfc3cd50ef0c4bf694cf936079bcbaee"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_DSA</b>(alg)</td></tr>
-<tr class="separator:gacfc3cd50ef0c4bf694cf936079bcbaee"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae01ae792228c16eac05102f8e900efd1"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_DSA_IS_DETERMINISTIC</b>(alg)   (((alg) & PSA_ALG_DSA_DETERMINISTIC_FLAG) != 0)</td></tr>
-<tr class="separator:gae01ae792228c16eac05102f8e900efd1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga11f7d6fe7a4441143ed398420b7d1980"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_DETERMINISTIC_DSA</b>(alg)   (PSA_ALG_IS_DSA(alg) && PSA_ALG_DSA_IS_DETERMINISTIC(alg))</td></tr>
-<tr class="separator:ga11f7d6fe7a4441143ed398420b7d1980"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga474c0582c4726d0c0274e470f4199cf9"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_RANDOMIZED_DSA</b>(alg)   (PSA_ALG_IS_DSA(alg) && !PSA_ALG_DSA_IS_DETERMINISTIC(alg))</td></tr>
-<tr class="separator:ga474c0582c4726d0c0274e470f4199cf9"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gafd9800fdbe6ea881e0ac0ce03d145928"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_ECDSA_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x10060000)</td></tr>
-<tr class="separator:gafd9800fdbe6ea881e0ac0ce03d145928"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga7e3ce9f514a227d5ba5d8318870452e3"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga7e3ce9f514a227d5ba5d8318870452e3">PSA_ALG_ECDSA</a>(hash_alg)   (PSA_ALG_ECDSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga7e3ce9f514a227d5ba5d8318870452e3"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga51d6b6044a62e33cae0cf64bfc3b22a4"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga51d6b6044a62e33cae0cf64bfc3b22a4">PSA_ALG_ECDSA_ANY</a>   PSA_ALG_ECDSA_BASE</td></tr>
-<tr class="separator:ga51d6b6044a62e33cae0cf64bfc3b22a4"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6c08b65200140aeb46ee9db9c8ed878c"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_DETERMINISTIC_ECDSA_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x10070000)</td></tr>
-<tr class="separator:ga6c08b65200140aeb46ee9db9c8ed878c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga11da566bcd341661c8de921e2ca5ed03"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga11da566bcd341661c8de921e2ca5ed03">PSA_ALG_DETERMINISTIC_ECDSA</a>(hash_alg)   (PSA_ALG_DETERMINISTIC_ECDSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga11da566bcd341661c8de921e2ca5ed03"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gafb92dc138c9d2388033ff5fc1dab7b48"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_ECDSA</b>(alg)</td></tr>
-<tr class="separator:gafb92dc138c9d2388033ff5fc1dab7b48"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaced29d8e3a1740aaec01e9ef8211df4f"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_ECDSA_IS_DETERMINISTIC</b>(alg)   (((alg) & PSA_ALG_DSA_DETERMINISTIC_FLAG) != 0)</td></tr>
-<tr class="separator:gaced29d8e3a1740aaec01e9ef8211df4f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gacd8766fe0fb8c1e2d32644e0d092c43a"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_DETERMINISTIC_ECDSA</b>(alg)   (PSA_ALG_IS_ECDSA(alg) && PSA_ALG_ECDSA_IS_DETERMINISTIC(alg))</td></tr>
-<tr class="separator:gacd8766fe0fb8c1e2d32644e0d092c43a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae7b0fafebd139f6f815285b7cad622ea"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_RANDOMIZED_ECDSA</b>(alg)   (PSA_ALG_IS_ECDSA(alg) && !PSA_ALG_ECDSA_IS_DETERMINISTIC(alg))</td></tr>
-<tr class="separator:gae7b0fafebd139f6f815285b7cad622ea"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga24cf6d7bcd2b9aeeeff86f07b6c674e3"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga24cf6d7bcd2b9aeeeff86f07b6c674e3">PSA_ALG_SIGN_GET_HASH</a>(alg)</td></tr>
-<tr class="separator:ga24cf6d7bcd2b9aeeeff86f07b6c674e3"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4c540d3abe43fb9abcb94f2bc51acef9"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga4c540d3abe43fb9abcb94f2bc51acef9">PSA_ALG_RSA_PKCS1V15_CRYPT</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x12020000)</td></tr>
-<tr class="separator:ga4c540d3abe43fb9abcb94f2bc51acef9"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga67ba62fbd154f5d3098866ae68ba66eb"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_RSA_OAEP_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x12030000)</td></tr>
-<tr class="separator:ga67ba62fbd154f5d3098866ae68ba66eb"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa1235dc3fdd9839c6c1b1a9857344c76"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaa1235dc3fdd9839c6c1b1a9857344c76">PSA_ALG_RSA_OAEP</a>(hash_alg)   (PSA_ALG_RSA_OAEP_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:gaa1235dc3fdd9839c6c1b1a9857344c76"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga9a85c05fd5c39ca63bbc47fb0755da39"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_RSA_OAEP</b>(alg)   (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_RSA_OAEP_BASE)</td></tr>
-<tr class="separator:ga9a85c05fd5c39ca63bbc47fb0755da39"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae6b0b87aabe82a1b3113824f022c52e8"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_RSA_OAEP_GET_HASH</b>(alg)</td></tr>
-<tr class="separator:gae6b0b87aabe82a1b3113824f022c52e8"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga85fe668f95a1e65b573dc5acb798be6f"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_HKDF_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x30000100)</td></tr>
-<tr class="separator:ga85fe668f95a1e65b573dc5acb798be6f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga32a888fb360e6e25cab8a343772c4a82"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga32a888fb360e6e25cab8a343772c4a82">PSA_ALG_HKDF</a>(hash_alg)   (PSA_ALG_HKDF_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga32a888fb360e6e25cab8a343772c4a82"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1979d0a76fcee6164cf2e65960f38db2"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga1979d0a76fcee6164cf2e65960f38db2">PSA_ALG_IS_HKDF</a>(alg)   (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_HKDF_BASE)</td></tr>
-<tr class="separator:ga1979d0a76fcee6164cf2e65960f38db2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga643df48b529b176995927b697ff07a4c"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_HKDF_GET_HASH</b>(hkdf_alg)   (PSA_ALG_CATEGORY_HASH | ((hkdf_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga643df48b529b176995927b697ff07a4c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gadb328698047e32da8e16551b28b50a35"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_TLS12_PRF_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x30000200)</td></tr>
-<tr class="separator:gadb328698047e32da8e16551b28b50a35"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6d5623c2ccda1d4a84e34351af8382d5"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga6d5623c2ccda1d4a84e34351af8382d5">PSA_ALG_TLS12_PRF</a>(hash_alg)   (PSA_ALG_TLS12_PRF_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga6d5623c2ccda1d4a84e34351af8382d5"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa3c18890c50222e5219f40ade8927e66"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaa3c18890c50222e5219f40ade8927e66">PSA_ALG_IS_TLS12_PRF</a>(alg)   (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_TLS12_PRF_BASE)</td></tr>
-<tr class="separator:gaa3c18890c50222e5219f40ade8927e66"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga403b2695655c7e03d6c07c061c606ab7"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_TLS12_PRF_GET_HASH</b>(hkdf_alg)   (PSA_ALG_CATEGORY_HASH | ((hkdf_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga403b2695655c7e03d6c07c061c606ab7"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaaca4b1953a3f31f1a285a48454aa4a6f"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_TLS12_PSK_TO_MS_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x30000300)</td></tr>
-<tr class="separator:gaaca4b1953a3f31f1a285a48454aa4a6f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga039ec797f15d1635d9b2e09a611f8a68"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga039ec797f15d1635d9b2e09a611f8a68">PSA_ALG_TLS12_PSK_TO_MS</a>(hash_alg)   (PSA_ALG_TLS12_PSK_TO_MS_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga039ec797f15d1635d9b2e09a611f8a68"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab25ecc074a93fd11069bedfbba5a287b"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gab25ecc074a93fd11069bedfbba5a287b">PSA_ALG_IS_TLS12_PSK_TO_MS</a>(alg)   (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_TLS12_PSK_TO_MS_BASE)</td></tr>
-<tr class="separator:gab25ecc074a93fd11069bedfbba5a287b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga49f873d8cf9fb0042118e626330eec9d"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_TLS12_PSK_TO_MS_GET_HASH</b>(hkdf_alg)   (PSA_ALG_CATEGORY_HASH | ((hkdf_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga49f873d8cf9fb0042118e626330eec9d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga914b52f4be62633b3350c5e03bf32ecb"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_KEY_DERIVATION_MASK</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x010fffff)</td></tr>
-<tr class="separator:ga914b52f4be62633b3350c5e03bf32ecb"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gacbbcb60abf1714722f50f80ce9c21602"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gacbbcb60abf1714722f50f80ce9c21602">PSA_ALG_SELECT_RAW</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x31000001)</td></tr>
-<tr class="separator:gacbbcb60abf1714722f50f80ce9c21602"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga56c1189add62b59e8e6a28a809b57037"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_KEY_AGREEMENT_GET_KDF</b>(alg)   (((alg) & PSA_ALG_KEY_DERIVATION_MASK) | PSA_ALG_CATEGORY_KEY_DERIVATION)</td></tr>
-<tr class="separator:ga56c1189add62b59e8e6a28a809b57037"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaf837c55ba698b488b6e63300e3470abf"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_KEY_AGREEMENT_GET_BASE</b>(alg)   ((alg) & ~PSA_ALG_KEY_DERIVATION_MASK)</td></tr>
-<tr class="separator:gaf837c55ba698b488b6e63300e3470abf"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaf5e91b071f657a662ce546d4989e0067"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_FFDH_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x22100000)</td></tr>
-<tr class="separator:gaf5e91b071f657a662ce546d4989e0067"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga21037568ad0b2e97d76dfc700b6b4483"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga21037568ad0b2e97d76dfc700b6b4483">PSA_ALG_FFDH</a>(kdf_alg)   (PSA_ALG_FFDH_BASE | ((kdf_alg) & PSA_ALG_KEY_DERIVATION_MASK))</td></tr>
-<tr class="separator:ga21037568ad0b2e97d76dfc700b6b4483"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa3cf76164cd9375af4fb8a291078a19e"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaa3cf76164cd9375af4fb8a291078a19e">PSA_ALG_IS_FFDH</a>(alg)   (PSA_ALG_KEY_AGREEMENT_GET_BASE(alg) == PSA_ALG_FFDH_BASE)</td></tr>
-<tr class="separator:gaa3cf76164cd9375af4fb8a291078a19e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga856863cdf3b7881d7dcb2b0f8a72b5c8"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_ECDH_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x22200000)</td></tr>
-<tr class="separator:ga856863cdf3b7881d7dcb2b0f8a72b5c8"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga974b73fccc5a9142256d8ce3092dff7f"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga974b73fccc5a9142256d8ce3092dff7f">PSA_ALG_ECDH</a>(kdf_alg)   (PSA_ALG_ECDH_BASE | ((kdf_alg) & PSA_ALG_KEY_DERIVATION_MASK))</td></tr>
-<tr class="separator:ga974b73fccc5a9142256d8ce3092dff7f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga9d9b6533d2a6bea7bac7ae01facb820d"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga9d9b6533d2a6bea7bac7ae01facb820d">PSA_ALG_IS_ECDH</a>(alg)   (PSA_ALG_KEY_AGREEMENT_GET_BASE(alg) == PSA_ALG_ECDH_BASE)</td></tr>
-<tr class="separator:ga9d9b6533d2a6bea7bac7ae01facb820d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga8b438870ba69489b685730d346455108"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__key__lifetimes.html#ga8b438870ba69489b685730d346455108">PSA_KEY_LIFETIME_VOLATILE</a>   ((<a class="el" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">psa_key_lifetime_t</a>)0x00000000)</td></tr>
-<tr class="separator:ga8b438870ba69489b685730d346455108"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga3713a01c5fcd5f7eae46ff22ceaf6d02"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__key__lifetimes.html#ga3713a01c5fcd5f7eae46ff22ceaf6d02">PSA_KEY_LIFETIME_PERSISTENT</a>   ((<a class="el" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">psa_key_lifetime_t</a>)0x00000001)</td></tr>
-<tr class="separator:ga3713a01c5fcd5f7eae46ff22ceaf6d02"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga7dddccdd1303176e87a4d20c87b589ed"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#ga7dddccdd1303176e87a4d20c87b589ed">PSA_KEY_USAGE_EXPORT</a>   ((<a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a>)0x00000001)</td></tr>
-<tr class="separator:ga7dddccdd1303176e87a4d20c87b589ed"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga75153b296d045d529d97203a6a995dad"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#ga75153b296d045d529d97203a6a995dad">PSA_KEY_USAGE_ENCRYPT</a>   ((<a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a>)0x00000100)</td></tr>
-<tr class="separator:ga75153b296d045d529d97203a6a995dad"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac3f2d2e5983db1edde9f142ca9bf8e6a"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#gac3f2d2e5983db1edde9f142ca9bf8e6a">PSA_KEY_USAGE_DECRYPT</a>   ((<a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a>)0x00000200)</td></tr>
-<tr class="separator:gac3f2d2e5983db1edde9f142ca9bf8e6a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga99b9f456cf59efc4b5579465407aef5a"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#ga99b9f456cf59efc4b5579465407aef5a">PSA_KEY_USAGE_SIGN</a>   ((<a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a>)0x00000400)</td></tr>
-<tr class="separator:ga99b9f456cf59efc4b5579465407aef5a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga39b54ffd5958b69634607924fa53cea6"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#ga39b54ffd5958b69634607924fa53cea6">PSA_KEY_USAGE_VERIFY</a>   ((<a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a>)0x00000800)</td></tr>
-<tr class="separator:ga39b54ffd5958b69634607924fa53cea6"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaf19022acc5ef23cf12477f632b48a0b2"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#gaf19022acc5ef23cf12477f632b48a0b2">PSA_KEY_USAGE_DERIVE</a>   ((<a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a>)0x00001000)</td></tr>
-<tr class="separator:gaf19022acc5ef23cf12477f632b48a0b2"><td class="memSeparator" colspan="2"> </td></tr>
-</table><table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="typedef-members"></a>
-Typedefs</h2></td></tr>
-<tr class="memitem:ga05676e70ba5c6a7565aff3c36677c1f9"><td class="memItemLeft" align="right" valign="top">typedef int32_t </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a></td></tr>
-<tr class="memdesc:ga05676e70ba5c6a7565aff3c36677c1f9"><td class="mdescLeft"> </td><td class="mdescRight">Function return status. <a href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">More...</a><br /></td></tr>
-<tr class="separator:ga05676e70ba5c6a7565aff3c36677c1f9"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga578159487dfc7096cb191b0d2befe628"><td class="memItemLeft" align="right" valign="top">
-typedef uint32_t </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a></td></tr>
-<tr class="memdesc:ga578159487dfc7096cb191b0d2befe628"><td class="mdescLeft"> </td><td class="mdescRight">Encoding of a key type. <br /></td></tr>
-<tr class="separator:ga578159487dfc7096cb191b0d2befe628"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4e8977c145cce5077c4bce7fec890ad9"><td class="memItemLeft" align="right" valign="top">typedef uint16_t </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a></td></tr>
-<tr class="separator:ga4e8977c145cce5077c4bce7fec890ad9"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac2e4d47f1300d73c2f829a6d99252d69"><td class="memItemLeft" align="right" valign="top">typedef uint32_t </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a></td></tr>
-<tr class="memdesc:gac2e4d47f1300d73c2f829a6d99252d69"><td class="mdescLeft"> </td><td class="mdescRight">Encoding of a cryptographic algorithm. <a href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">More...</a><br /></td></tr>
-<tr class="separator:gac2e4d47f1300d73c2f829a6d99252d69"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6821ff6dd39dc2bc370ded760ad8b0cf"><td class="memItemLeft" align="right" valign="top">typedef uint32_t </td><td class="memItemRight" valign="bottom"><a class="el" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">psa_key_lifetime_t</a></td></tr>
-<tr class="separator:ga6821ff6dd39dc2bc370ded760ad8b0cf"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga11e986351c65bd3dc3c0fe2cd9926e4b"><td class="memItemLeft" align="right" valign="top">typedef uint32_t </td><td class="memItemRight" valign="bottom"><a class="el" href="group__key__lifetimes.html#ga11e986351c65bd3dc3c0fe2cd9926e4b">psa_key_id_t</a></td></tr>
-<tr class="separator:ga11e986351c65bd3dc3c0fe2cd9926e4b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga7bb9de71337e0e98de843aa7f9b55f25"><td class="memItemLeft" align="right" valign="top">
-typedef uint32_t </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a></td></tr>
-<tr class="memdesc:ga7bb9de71337e0e98de843aa7f9b55f25"><td class="mdescLeft"> </td><td class="mdescRight">Encoding of permitted usage on a key. <br /></td></tr>
-<tr class="separator:ga7bb9de71337e0e98de843aa7f9b55f25"><td class="memSeparator" colspan="2"> </td></tr>
-</table>
-<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
-<div class="textblock"><p>PSA cryptography module: Integer encodings. </p>
-<dl class="section note"><dt>Note</dt><dd>This file may not be included directly. Applications must include <a class="el" href="crypto_8h.html" title="Platform Security Architecture cryptography module. ">psa/crypto.h</a>. Drivers must include the appropriate driver header file.</dd></dl>
-<p>This file contains portable definitions of integral types and macros to build and analyze values of these types. The types concerned are properties of cryptographic keys, designations of cryptographic algorithms, and error codes returned by the library.</p>
-<p>This header file does not declare any function. </p>
-</div></div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/crypto__enum_8h__dep__incl.map b/docs/html/crypto__enum_8h__dep__incl.map
deleted file mode 100644
index 805e410..0000000
--- a/docs/html/crypto__enum_8h__dep__incl.map
+++ /dev/null
@@ -1,3 +0,0 @@
-<map id="psa/crypto_enum.h" name="psa/crypto_enum.h">
-<area shape="rect" id="node2" href="$crypto_8h.html" title="Platform Security Architecture cryptography module. " alt="" coords="25,80,119,107"/>
-</map>
diff --git a/docs/html/crypto__enum_8h__dep__incl.md5 b/docs/html/crypto__enum_8h__dep__incl.md5
deleted file mode 100644
index 21c7ef7..0000000
--- a/docs/html/crypto__enum_8h__dep__incl.md5
+++ /dev/null
@@ -1 +0,0 @@
-13274746bc95b43464bdf033bcf1ced6
\ No newline at end of file
diff --git a/docs/html/crypto__enum_8h__dep__incl.png b/docs/html/crypto__enum_8h__dep__incl.png
deleted file mode 100644
index ac4a5c5..0000000
--- a/docs/html/crypto__enum_8h__dep__incl.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/crypto__enum_8h__incl.map b/docs/html/crypto__enum_8h__incl.map
deleted file mode 100644
index ee3647e..0000000
--- a/docs/html/crypto__enum_8h__incl.map
+++ /dev/null
@@ -1,2 +0,0 @@
-<map id="psa/crypto_enum.h" name="psa/crypto_enum.h">
-</map>
diff --git a/docs/html/crypto__enum_8h__incl.md5 b/docs/html/crypto__enum_8h__incl.md5
deleted file mode 100644
index cc108ec..0000000
--- a/docs/html/crypto__enum_8h__incl.md5
+++ /dev/null
@@ -1 +0,0 @@
-a4850a23fc9b42677d19279e04a16c71
\ No newline at end of file
diff --git a/docs/html/crypto__enum_8h__incl.png b/docs/html/crypto__enum_8h__incl.png
deleted file mode 100644
index dd745f9..0000000
--- a/docs/html/crypto__enum_8h__incl.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/crypto__enum_8h_source.html b/docs/html/crypto__enum_8h_source.html
deleted file mode 100644
index 2a7b432..0000000
--- a/docs/html/crypto__enum_8h_source.html
+++ /dev/null
@@ -1,108 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: psa/crypto_enum.h Source File</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">Working draft</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li class="current"><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
- <div id="navrow2" class="tabs2">
- <ul class="tablist">
- <li><a href="files.html"><span>File List</span></a></li>
- <li><a href="globals.html"><span>File Members</span></a></li>
- </ul>
- </div>
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div id="nav-path" class="navpath">
- <ul>
-<li class="navelem"><a class="el" href="dir_7dae9cfde651cd3cb034485ce5e391b9.html">psa</a></li> </ul>
-</div>
-</div><!-- top -->
-<div class="header">
- <div class="headertitle">
-<div class="title">crypto_enum.h</div> </div>
-</div><!--header-->
-<div class="contents">
-<a href="crypto__enum_8h.html">Go to the documentation of this file.</a><div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> </div><div class="line"><a name="l00017"></a><span class="lineno"> 17</span> <span class="comment">/*</span></div><div class="line"><a name="l00018"></a><span class="lineno"> 18</span> <span class="comment"> * Copyright (C) 2018, ARM Limited, All Rights Reserved</span></div><div class="line"><a name="l00019"></a><span class="lineno"> 19</span> <span class="comment"> * SPDX-License-Identifier: Apache-2.0</span></div><div class="line"><a name="l00020"></a><span class="lineno"> 20</span> <span class="comment"> *</span></div><div class="line"><a name="l00021"></a><span class="lineno"> 21</span> <span class="comment"> * Licensed under the Apache License, Version 2.0 (the "License"); you may</span></div><div class="line"><a name="l00022"></a><span class="lineno"> 22</span> <span class="comment"> * not use this file except in compliance with the License.</span></div><div class="line"><a name="l00023"></a><span class="lineno"> 23</span> <span class="comment"> * You may obtain a copy of the License at</span></div><div class="line"><a name="l00024"></a><span class="lineno"> 24</span> <span class="comment"> *</span></div><div class="line"><a name="l00025"></a><span class="lineno"> 25</span> <span class="comment"> * http://www.apache.org/licenses/LICENSE-2.0</span></div><div class="line"><a name="l00026"></a><span class="lineno"> 26</span> <span class="comment"> *</span></div><div class="line"><a name="l00027"></a><span class="lineno"> 27</span> <span class="comment"> * Unless required by applicable law or agreed to in writing, software</span></div><div class="line"><a name="l00028"></a><span class="lineno"> 28</span> <span class="comment"> * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT</span></div><div class="line"><a name="l00029"></a><span class="lineno"> 29</span> <span class="comment"> * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.</span></div><div class="line"><a name="l00030"></a><span class="lineno"> 30</span> <span class="comment"> * See the License for the specific language governing permissions and</span></div><div class="line"><a name="l00031"></a><span class="lineno"> 31</span> <span class="comment"> * limitations under the License.</span></div><div class="line"><a name="l00032"></a><span class="lineno"> 32</span> <span class="comment"> *</span></div><div class="line"><a name="l00033"></a><span class="lineno"> 33</span> <span class="comment"> * This file is part of mbed TLS (https://tls.mbed.org)</span></div><div class="line"><a name="l00034"></a><span class="lineno"> 34</span> <span class="comment"> */</span></div><div class="line"><a name="l00035"></a><span class="lineno"> 35</span> </div><div class="line"><a name="l00036"></a><span class="lineno"> 36</span> <span class="preprocessor">#ifndef PSA_CRYPTO_ENUM_H</span></div><div class="line"><a name="l00037"></a><span class="lineno"> 37</span> <span class="preprocessor">#define PSA_CRYPTO_ENUM_H</span></div><div class="line"><a name="l00038"></a><span class="lineno"> 38</span> </div><div class="line"><a name="l00039"></a><span class="lineno"> 39</span> <span class="preprocessor">#include <stdint.h></span></div><div class="line"><a name="l00040"></a><span class="lineno"> 40</span> </div><div class="line"><a name="l00045"></a><span class="lineno"> 45</span> <span class="preprocessor">#if defined(PSA_SUCCESS)</span></div><div class="line"><a name="l00046"></a><span class="lineno"> 46</span> <span class="comment">/* If PSA_SUCCESS is defined, assume that PSA crypto is being used</span></div><div class="line"><a name="l00047"></a><span class="lineno"> 47</span> <span class="comment"> * together with PSA IPC, which also defines the identifier</span></div><div class="line"><a name="l00048"></a><span class="lineno"> 48</span> <span class="comment"> * PSA_SUCCESS. We must not define PSA_SUCCESS ourselves in that case;</span></div><div class="line"><a name="l00049"></a><span class="lineno"> 49</span> <span class="comment"> * the other error code names don't clash. Also define psa_status_t as</span></div><div class="line"><a name="l00050"></a><span class="lineno"> 50</span> <span class="comment"> * an alias for the type used by PSA IPC. This is a temporary hack</span></div><div class="line"><a name="l00051"></a><span class="lineno"> 51</span> <span class="comment"> * until we unify error reporting in PSA IPC and PSA crypto.</span></div><div class="line"><a name="l00052"></a><span class="lineno"> 52</span> <span class="comment"> *</span></div><div class="line"><a name="l00053"></a><span class="lineno"> 53</span> <span class="comment"> * Note that psa_defs.h must be included before this header!</span></div><div class="line"><a name="l00054"></a><span class="lineno"> 54</span> <span class="comment"> */</span></div><div class="line"><a name="l00055"></a><span class="lineno"> 55</span> <span class="keyword">typedef</span> psa_error_t <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>;</div><div class="line"><a name="l00056"></a><span class="lineno"> 56</span> </div><div class="line"><a name="l00057"></a><span class="lineno"> 57</span> <span class="preprocessor">#else </span><span class="comment">/* defined(PSA_SUCCESS) */</span><span class="preprocessor"></span></div><div class="line"><a name="l00058"></a><span class="lineno"> 58</span> </div><div class="line"><a name="l00066"></a><span class="lineno"><a class="line" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9"> 66</a></span> <span class="keyword">typedef</span> int32_t <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>;</div><div class="line"><a name="l00067"></a><span class="lineno"> 67</span> </div><div class="line"><a name="l00069"></a><span class="lineno"><a class="line" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1"> 69</a></span> <span class="preprocessor">#define PSA_SUCCESS ((psa_status_t)0)</span></div><div class="line"><a name="l00070"></a><span class="lineno"> 70</span> </div><div class="line"><a name="l00071"></a><span class="lineno"> 71</span> <span class="preprocessor">#endif </span><span class="comment">/* !defined(PSA_SUCCESS) */</span><span class="preprocessor"></span></div><div class="line"><a name="l00072"></a><span class="lineno"> 72</span> </div><div class="line"><a name="l00078"></a><span class="lineno"><a class="line" href="group__error.html#ga24d5fdcdd759f846f79d9e581c63a83f"> 78</a></span> <span class="preprocessor">#define PSA_ERROR_UNKNOWN_ERROR ((psa_status_t)1)</span></div><div class="line"><a name="l00079"></a><span class="lineno"> 79</span> </div><div class="line"><a name="l00087"></a><span class="lineno"><a class="line" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd"> 87</a></span> <span class="preprocessor">#define PSA_ERROR_NOT_SUPPORTED ((psa_status_t)2)</span></div><div class="line"><a name="l00088"></a><span class="lineno"> 88</span> </div><div class="line"><a name="l00100"></a><span class="lineno"><a class="line" href="group__error.html#ga4d1b8dd8526177a15a210b7afc1accb1"> 100</a></span> <span class="preprocessor">#define PSA_ERROR_NOT_PERMITTED ((psa_status_t)3)</span></div><div class="line"><a name="l00101"></a><span class="lineno"> 101</span> </div><div class="line"><a name="l00112"></a><span class="lineno"><a class="line" href="group__error.html#ga695025f4ec11249aee7ea3d0f65e01c8"> 112</a></span> <span class="preprocessor">#define PSA_ERROR_BUFFER_TOO_SMALL ((psa_status_t)4)</span></div><div class="line"><a name="l00113"></a><span class="lineno"> 113</span> </div><div class="line"><a name="l00120"></a><span class="lineno"><a class="line" href="group__error.html#gac2fee3a51249fbea45360aaa911f3e58"> 120</a></span> <span class="preprocessor">#define PSA_ERROR_OCCUPIED_SLOT ((psa_status_t)5)</span></div><div class="line"><a name="l00121"></a><span class="lineno"> 121</span> </div><div class="line"><a name="l00128"></a><span class="lineno"><a class="line" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040"> 128</a></span> <span class="preprocessor">#define PSA_ERROR_EMPTY_SLOT ((psa_status_t)6)</span></div><div class="line"><a name="l00129"></a><span class="lineno"> 129</span> </div><div class="line"><a name="l00140"></a><span class="lineno"><a class="line" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84"> 140</a></span> <span class="preprocessor">#define PSA_ERROR_BAD_STATE ((psa_status_t)7)</span></div><div class="line"><a name="l00141"></a><span class="lineno"> 141</span> </div><div class="line"><a name="l00156"></a><span class="lineno"><a class="line" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f"> 156</a></span> <span class="preprocessor">#define PSA_ERROR_INVALID_ARGUMENT ((psa_status_t)8)</span></div><div class="line"><a name="l00157"></a><span class="lineno"> 157</span> </div><div class="line"><a name="l00162"></a><span class="lineno"><a class="line" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5"> 162</a></span> <span class="preprocessor">#define PSA_ERROR_INSUFFICIENT_MEMORY ((psa_status_t)9)</span></div><div class="line"><a name="l00163"></a><span class="lineno"> 163</span> </div><div class="line"><a name="l00171"></a><span class="lineno"><a class="line" href="group__error.html#ga897a45eb206a6f6b7be7ffbe36f0d766"> 171</a></span> <span class="preprocessor">#define PSA_ERROR_INSUFFICIENT_STORAGE ((psa_status_t)10)</span></div><div class="line"><a name="l00172"></a><span class="lineno"> 172</span> </div><div class="line"><a name="l00188"></a><span class="lineno"><a class="line" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7"> 188</a></span> <span class="preprocessor">#define PSA_ERROR_COMMUNICATION_FAILURE ((psa_status_t)11)</span></div><div class="line"><a name="l00189"></a><span class="lineno"> 189</span> </div><div class="line"><a name="l00213"></a><span class="lineno"><a class="line" href="group__error.html#gadd169a1af2707862b95fb9df91dfc37d"> 213</a></span> <span class="preprocessor">#define PSA_ERROR_STORAGE_FAILURE ((psa_status_t)12)</span></div><div class="line"><a name="l00214"></a><span class="lineno"> 214</span> </div><div class="line"><a name="l00219"></a><span class="lineno"><a class="line" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b"> 219</a></span> <span class="preprocessor">#define PSA_ERROR_HARDWARE_FAILURE ((psa_status_t)13)</span></div><div class="line"><a name="l00220"></a><span class="lineno"> 220</span> </div><div class="line"><a name="l00250"></a><span class="lineno"><a class="line" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004"> 250</a></span> <span class="preprocessor">#define PSA_ERROR_TAMPERING_DETECTED ((psa_status_t)14)</span></div><div class="line"><a name="l00251"></a><span class="lineno"> 251</span> </div><div class="line"><a name="l00269"></a><span class="lineno"><a class="line" href="group__error.html#ga4deb59fec02297ec5d8b42178323f675"> 269</a></span> <span class="preprocessor">#define PSA_ERROR_INSUFFICIENT_ENTROPY ((psa_status_t)15)</span></div><div class="line"><a name="l00270"></a><span class="lineno"> 270</span> </div><div class="line"><a name="l00279"></a><span class="lineno"><a class="line" href="group__error.html#ga35927f755d232c4766de600f2c49e9f2"> 279</a></span> <span class="preprocessor">#define PSA_ERROR_INVALID_SIGNATURE ((psa_status_t)16)</span></div><div class="line"><a name="l00280"></a><span class="lineno"> 280</span> </div><div class="line"><a name="l00295"></a><span class="lineno"><a class="line" href="group__error.html#gabe29594edbfb152cf153975b0597ac48"> 295</a></span> <span class="preprocessor">#define PSA_ERROR_INVALID_PADDING ((psa_status_t)17)</span></div><div class="line"><a name="l00296"></a><span class="lineno"> 296</span> </div><div class="line"><a name="l00301"></a><span class="lineno"><a class="line" href="group__error.html#gaf1fa61f72e9e5b4a848c991bea495767"> 301</a></span> <span class="preprocessor">#define PSA_ERROR_INSUFFICIENT_CAPACITY ((psa_status_t)18)</span></div><div class="line"><a name="l00302"></a><span class="lineno"> 302</span> </div><div class="line"><a name="l00305"></a><span class="lineno"><a class="line" href="group__error.html#gadf22718935657c2c3168c228204085f9"> 305</a></span> <span class="preprocessor">#define PSA_ERROR_INVALID_HANDLE ((psa_status_t)19)</span></div><div class="line"><a name="l00306"></a><span class="lineno"> 306</span> </div><div class="line"><a name="l00315"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628"> 315</a></span> <span class="keyword">typedef</span> uint32_t <a class="code" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>;</div><div class="line"><a name="l00316"></a><span class="lineno"> 316</span> </div><div class="line"><a name="l00321"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gafce7ab2b54ce97ea5bff73f13a9f3e5b"> 321</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_NONE ((psa_key_type_t)0x00000000)</span></div><div class="line"><a name="l00322"></a><span class="lineno"> 322</span> </div><div class="line"><a name="l00330"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga8dbaed2fdb1ebae8aa127ad3988516f7"> 330</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_VENDOR_FLAG ((psa_key_type_t)0x80000000)</span></div><div class="line"><a name="l00331"></a><span class="lineno"> 331</span> </div><div class="line"><a name="l00332"></a><span class="lineno"> 332</span> <span class="preprocessor">#define PSA_KEY_TYPE_CATEGORY_MASK ((psa_key_type_t)0x70000000)</span></div><div class="line"><a name="l00333"></a><span class="lineno"> 333</span> <span class="preprocessor">#define PSA_KEY_TYPE_CATEGORY_SYMMETRIC ((psa_key_type_t)0x40000000)</span></div><div class="line"><a name="l00334"></a><span class="lineno"> 334</span> <span class="preprocessor">#define PSA_KEY_TYPE_CATEGORY_RAW ((psa_key_type_t)0x50000000)</span></div><div class="line"><a name="l00335"></a><span class="lineno"> 335</span> <span class="preprocessor">#define PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY ((psa_key_type_t)0x60000000)</span></div><div class="line"><a name="l00336"></a><span class="lineno"> 336</span> <span class="preprocessor">#define PSA_KEY_TYPE_CATEGORY_KEY_PAIR ((psa_key_type_t)0x70000000)</span></div><div class="line"><a name="l00337"></a><span class="lineno"> 337</span> </div><div class="line"><a name="l00338"></a><span class="lineno"> 338</span> <span class="preprocessor">#define PSA_KEY_TYPE_CATEGORY_FLAG_PAIR ((psa_key_type_t)0x10000000)</span></div><div class="line"><a name="l00339"></a><span class="lineno"> 339</span> </div><div class="line"><a name="l00341"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gadbe4c086a6562aefe344bc79e51bdfd3"> 341</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_IS_VENDOR_DEFINED(type) \</span></div><div class="line"><a name="l00342"></a><span class="lineno"> 342</span> <span class="preprocessor"> (((type) & PSA_KEY_TYPE_VENDOR_FLAG) != 0)</span></div><div class="line"><a name="l00343"></a><span class="lineno"> 343</span> </div><div class="line"><a name="l00348"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaef86ce4e810e1c2c76068ac874bfef54"> 348</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_IS_UNSTRUCTURED(type) \</span></div><div class="line"><a name="l00349"></a><span class="lineno"> 349</span> <span class="preprocessor"> (((type) & PSA_KEY_TYPE_CATEGORY_MASK & ~(psa_key_type_t)0x10000000) == \</span></div><div class="line"><a name="l00350"></a><span class="lineno"> 350</span> <span class="preprocessor"> PSA_KEY_TYPE_CATEGORY_SYMMETRIC)</span></div><div class="line"><a name="l00351"></a><span class="lineno"> 351</span> </div><div class="line"><a name="l00353"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gab138ae2ebf2905dfbaf4154db2620939"> 353</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_IS_ASYMMETRIC(type) \</span></div><div class="line"><a name="l00354"></a><span class="lineno"> 354</span> <span class="preprocessor"> (((type) & PSA_KEY_TYPE_CATEGORY_MASK \</span></div><div class="line"><a name="l00355"></a><span class="lineno"> 355</span> <span class="preprocessor"> & ~PSA_KEY_TYPE_CATEGORY_FLAG_PAIR) == \</span></div><div class="line"><a name="l00356"></a><span class="lineno"> 356</span> <span class="preprocessor"> PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY)</span></div><div class="line"><a name="l00357"></a><span class="lineno"> 357</span> </div><div class="line"><a name="l00358"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gac674a0f059bc0cb72b47f0c517b4f45b"> 358</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_IS_PUBLIC_KEY(type) \</span></div><div class="line"><a name="l00359"></a><span class="lineno"> 359</span> <span class="preprocessor"> (((type) & PSA_KEY_TYPE_CATEGORY_MASK) == PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY)</span></div><div class="line"><a name="l00360"></a><span class="lineno"> 360</span> </div><div class="line"><a name="l00362"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gac14c6d6e1b2b7f4a92a7b757465cff29"> 362</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_IS_KEYPAIR(type) \</span></div><div class="line"><a name="l00363"></a><span class="lineno"> 363</span> <span class="preprocessor"> (((type) & PSA_KEY_TYPE_CATEGORY_MASK) == PSA_KEY_TYPE_CATEGORY_KEY_PAIR)</span></div><div class="line"><a name="l00364"></a><span class="lineno"> 364</span> </div><div class="line"><a name="l00374"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaf09f1ca1de6a7e7cff0fe516f3f6c91d"> 374</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_KEYPAIR_OF_PUBLIC_KEY(type) \</span></div><div class="line"><a name="l00375"></a><span class="lineno"> 375</span> <span class="preprocessor"> ((type) | PSA_KEY_TYPE_CATEGORY_FLAG_PAIR)</span></div><div class="line"><a name="l00376"></a><span class="lineno"> 376</span> </div><div class="line"><a name="l00386"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gace08e46dd7cbf642d50d982a25d02bec"> 386</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR(type) \</span></div><div class="line"><a name="l00387"></a><span class="lineno"> 387</span> <span class="preprocessor"> ((type) & ~PSA_KEY_TYPE_CATEGORY_FLAG_PAIR)</span></div><div class="line"><a name="l00388"></a><span class="lineno"> 388</span> </div><div class="line"><a name="l00393"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaa97f92025533102616b32d571c940d80"> 393</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_RAW_DATA ((psa_key_type_t)0x50000001)</span></div><div class="line"><a name="l00394"></a><span class="lineno"> 394</span> </div><div class="line"><a name="l00403"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga92d989f4ca64abd00f463defd773a6f8"> 403</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_HMAC ((psa_key_type_t)0x51000000)</span></div><div class="line"><a name="l00404"></a><span class="lineno"> 404</span> </div><div class="line"><a name="l00410"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gae871b2357b8593f33bfd51abbf93ebb1"> 410</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_DERIVE ((psa_key_type_t)0x52000000)</span></div><div class="line"><a name="l00411"></a><span class="lineno"> 411</span> </div><div class="line"><a name="l00417"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga6ee54579dcf278c677eda4bb1a29575e"> 417</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_AES ((psa_key_type_t)0x40000001)</span></div><div class="line"><a name="l00418"></a><span class="lineno"> 418</span> </div><div class="line"><a name="l00428"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga577562bfbbc691c820d55ec308333138"> 428</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_DES ((psa_key_type_t)0x40000002)</span></div><div class="line"><a name="l00429"></a><span class="lineno"> 429</span> </div><div class="line"><a name="l00432"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gad8e5da742343fd5519f9d8a630c2ed81"> 432</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_CAMELLIA ((psa_key_type_t)0x40000003)</span></div><div class="line"><a name="l00433"></a><span class="lineno"> 433</span> </div><div class="line"><a name="l00438"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gae4d46e83f910dcaa126000a8ed03cde9"> 438</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_ARC4 ((psa_key_type_t)0x40000004)</span></div><div class="line"><a name="l00439"></a><span class="lineno"> 439</span> </div><div class="line"><a name="l00441"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga9ba0878f56c8bcd1995ac017a74f513b"> 441</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_RSA_PUBLIC_KEY ((psa_key_type_t)0x60010000)</span></div><div class="line"><a name="l00442"></a><span class="lineno"> 442</span> </div><div class="line"><a name="l00443"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga581f50687f5d650456925278948f2799"> 443</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_RSA_KEYPAIR ((psa_key_type_t)0x70010000)</span></div><div class="line"><a name="l00444"></a><span class="lineno"> 444</span> </div><div class="line"><a name="l00445"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga0e1d8f241228e49c9cadadfb4579ef1a"> 445</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_IS_RSA(type) \</span></div><div class="line"><a name="l00446"></a><span class="lineno"> 446</span> <span class="preprocessor"> (PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR(type) == PSA_KEY_TYPE_RSA_PUBLIC_KEY)</span></div><div class="line"><a name="l00447"></a><span class="lineno"> 447</span> </div><div class="line"><a name="l00449"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga5e7439c2905136366c3a876e62e5ddfc"> 449</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_DSA_PUBLIC_KEY ((psa_key_type_t)0x60020000)</span></div><div class="line"><a name="l00450"></a><span class="lineno"> 450</span> </div><div class="line"><a name="l00451"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga011010ee28c20388f3d89fb27088ed62"> 451</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_DSA_KEYPAIR ((psa_key_type_t)0x70020000)</span></div><div class="line"><a name="l00452"></a><span class="lineno"> 452</span> </div><div class="line"><a name="l00453"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga273fdfcf23eb0624f8b63d2321cf95c1"> 453</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_IS_DSA(type) \</span></div><div class="line"><a name="l00454"></a><span class="lineno"> 454</span> <span class="preprocessor"> (PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR(type) == PSA_KEY_TYPE_DSA_PUBLIC_KEY)</span></div><div class="line"><a name="l00455"></a><span class="lineno"> 455</span> </div><div class="line"><a name="l00456"></a><span class="lineno"> 456</span> <span class="preprocessor">#define PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE ((psa_key_type_t)0x60030000)</span></div><div class="line"><a name="l00457"></a><span class="lineno"> 457</span> <span class="preprocessor">#define PSA_KEY_TYPE_ECC_KEYPAIR_BASE ((psa_key_type_t)0x70030000)</span></div><div class="line"><a name="l00458"></a><span class="lineno"> 458</span> <span class="preprocessor">#define PSA_KEY_TYPE_ECC_CURVE_MASK ((psa_key_type_t)0x0000ffff)</span></div><div class="line"><a name="l00459"></a><span class="lineno"> 459</span> </div><div class="line"><a name="l00460"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gadf3ad65d157bf5282849c954bf3f51af"> 460</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_ECC_KEYPAIR(curve) \</span></div><div class="line"><a name="l00461"></a><span class="lineno"> 461</span> <span class="preprocessor"> (PSA_KEY_TYPE_ECC_KEYPAIR_BASE | (curve))</span></div><div class="line"><a name="l00462"></a><span class="lineno"> 462</span> </div><div class="line"><a name="l00463"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gad54c03d3b47020e571a72cd01d978cf2"> 463</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_ECC_PUBLIC_KEY(curve) \</span></div><div class="line"><a name="l00464"></a><span class="lineno"> 464</span> <span class="preprocessor"> (PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE | (curve))</span></div><div class="line"><a name="l00465"></a><span class="lineno"> 465</span> </div><div class="line"><a name="l00467"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga88e01fa06b585654689a99bcc06bbe66"> 467</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_IS_ECC(type) \</span></div><div class="line"><a name="l00468"></a><span class="lineno"> 468</span> <span class="preprocessor"> ((PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR(type) & \</span></div><div class="line"><a name="l00469"></a><span class="lineno"> 469</span> <span class="preprocessor"> ~PSA_KEY_TYPE_ECC_CURVE_MASK) == PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE)</span></div><div class="line"><a name="l00470"></a><span class="lineno"> 470</span> </div><div class="line"><a name="l00471"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga7bf101b671e8cf26f4cb08fcb679db4b"> 471</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_IS_ECC_KEYPAIR(type) \</span></div><div class="line"><a name="l00472"></a><span class="lineno"> 472</span> <span class="preprocessor"> (((type) & ~PSA_KEY_TYPE_ECC_CURVE_MASK) == \</span></div><div class="line"><a name="l00473"></a><span class="lineno"> 473</span> <span class="preprocessor"> PSA_KEY_TYPE_ECC_KEYPAIR_BASE)</span></div><div class="line"><a name="l00474"></a><span class="lineno"> 474</span> </div><div class="line"><a name="l00475"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga5af146a173b0c84d7e737e2fb6a3c0a7"> 475</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY(type) \</span></div><div class="line"><a name="l00476"></a><span class="lineno"> 476</span> <span class="preprocessor"> (((type) & ~PSA_KEY_TYPE_ECC_CURVE_MASK) == \</span></div><div class="line"><a name="l00477"></a><span class="lineno"> 477</span> <span class="preprocessor"> PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE)</span></div><div class="line"><a name="l00478"></a><span class="lineno"> 478</span> </div><div class="line"><a name="l00480"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9"> 480</a></span> <span class="keyword">typedef</span> uint16_t <a class="code" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>;</div><div class="line"><a name="l00482"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga0c567210e6f80aa8f2aa87efa7a3a3f9"> 482</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_GET_CURVE(type) \</span></div><div class="line"><a name="l00483"></a><span class="lineno"> 483</span> <span class="preprocessor"> ((psa_ecc_curve_t) (PSA_KEY_TYPE_IS_ECC(type) ? \</span></div><div class="line"><a name="l00484"></a><span class="lineno"> 484</span> <span class="preprocessor"> ((type) & PSA_KEY_TYPE_ECC_CURVE_MASK) : \</span></div><div class="line"><a name="l00485"></a><span class="lineno"> 485</span> <span class="preprocessor"> 0))</span></div><div class="line"><a name="l00486"></a><span class="lineno"> 486</span> </div><div class="line"><a name="l00487"></a><span class="lineno"> 487</span> <span class="comment">/* The encoding of curve identifiers is currently aligned with the</span></div><div class="line"><a name="l00488"></a><span class="lineno"> 488</span> <span class="comment"> * TLS Supported Groups Registry (formerly known as the</span></div><div class="line"><a name="l00489"></a><span class="lineno"> 489</span> <span class="comment"> * TLS EC Named Curve Registry)</span></div><div class="line"><a name="l00490"></a><span class="lineno"> 490</span> <span class="comment"> * https://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml#tls-parameters-8</span></div><div class="line"><a name="l00491"></a><span class="lineno"> 491</span> <span class="comment"> * The values are defined by RFC 8422 and RFC 7027. */</span></div><div class="line"><a name="l00492"></a><span class="lineno"> 492</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECT163K1 ((psa_ecc_curve_t) 0x0001)</span></div><div class="line"><a name="l00493"></a><span class="lineno"> 493</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECT163R1 ((psa_ecc_curve_t) 0x0002)</span></div><div class="line"><a name="l00494"></a><span class="lineno"> 494</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECT163R2 ((psa_ecc_curve_t) 0x0003)</span></div><div class="line"><a name="l00495"></a><span class="lineno"> 495</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECT193R1 ((psa_ecc_curve_t) 0x0004)</span></div><div class="line"><a name="l00496"></a><span class="lineno"> 496</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECT193R2 ((psa_ecc_curve_t) 0x0005)</span></div><div class="line"><a name="l00497"></a><span class="lineno"> 497</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECT233K1 ((psa_ecc_curve_t) 0x0006)</span></div><div class="line"><a name="l00498"></a><span class="lineno"> 498</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECT233R1 ((psa_ecc_curve_t) 0x0007)</span></div><div class="line"><a name="l00499"></a><span class="lineno"> 499</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECT239K1 ((psa_ecc_curve_t) 0x0008)</span></div><div class="line"><a name="l00500"></a><span class="lineno"> 500</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECT283K1 ((psa_ecc_curve_t) 0x0009)</span></div><div class="line"><a name="l00501"></a><span class="lineno"> 501</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECT283R1 ((psa_ecc_curve_t) 0x000a)</span></div><div class="line"><a name="l00502"></a><span class="lineno"> 502</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECT409K1 ((psa_ecc_curve_t) 0x000b)</span></div><div class="line"><a name="l00503"></a><span class="lineno"> 503</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECT409R1 ((psa_ecc_curve_t) 0x000c)</span></div><div class="line"><a name="l00504"></a><span class="lineno"> 504</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECT571K1 ((psa_ecc_curve_t) 0x000d)</span></div><div class="line"><a name="l00505"></a><span class="lineno"> 505</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECT571R1 ((psa_ecc_curve_t) 0x000e)</span></div><div class="line"><a name="l00506"></a><span class="lineno"> 506</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECP160K1 ((psa_ecc_curve_t) 0x000f)</span></div><div class="line"><a name="l00507"></a><span class="lineno"> 507</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECP160R1 ((psa_ecc_curve_t) 0x0010)</span></div><div class="line"><a name="l00508"></a><span class="lineno"> 508</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECP160R2 ((psa_ecc_curve_t) 0x0011)</span></div><div class="line"><a name="l00509"></a><span class="lineno"> 509</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECP192K1 ((psa_ecc_curve_t) 0x0012)</span></div><div class="line"><a name="l00510"></a><span class="lineno"> 510</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECP192R1 ((psa_ecc_curve_t) 0x0013)</span></div><div class="line"><a name="l00511"></a><span class="lineno"> 511</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECP224K1 ((psa_ecc_curve_t) 0x0014)</span></div><div class="line"><a name="l00512"></a><span class="lineno"> 512</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECP224R1 ((psa_ecc_curve_t) 0x0015)</span></div><div class="line"><a name="l00513"></a><span class="lineno"> 513</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECP256K1 ((psa_ecc_curve_t) 0x0016)</span></div><div class="line"><a name="l00514"></a><span class="lineno"> 514</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECP256R1 ((psa_ecc_curve_t) 0x0017)</span></div><div class="line"><a name="l00515"></a><span class="lineno"> 515</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECP384R1 ((psa_ecc_curve_t) 0x0018)</span></div><div class="line"><a name="l00516"></a><span class="lineno"> 516</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECP521R1 ((psa_ecc_curve_t) 0x0019)</span></div><div class="line"><a name="l00517"></a><span class="lineno"> 517</span> <span class="preprocessor">#define PSA_ECC_CURVE_BRAINPOOL_P256R1 ((psa_ecc_curve_t) 0x001a)</span></div><div class="line"><a name="l00518"></a><span class="lineno"> 518</span> <span class="preprocessor">#define PSA_ECC_CURVE_BRAINPOOL_P384R1 ((psa_ecc_curve_t) 0x001b)</span></div><div class="line"><a name="l00519"></a><span class="lineno"> 519</span> <span class="preprocessor">#define PSA_ECC_CURVE_BRAINPOOL_P512R1 ((psa_ecc_curve_t) 0x001c)</span></div><div class="line"><a name="l00520"></a><span class="lineno"> 520</span> <span class="preprocessor">#define PSA_ECC_CURVE_CURVE25519 ((psa_ecc_curve_t) 0x001d)</span></div><div class="line"><a name="l00521"></a><span class="lineno"> 521</span> <span class="preprocessor">#define PSA_ECC_CURVE_CURVE448 ((psa_ecc_curve_t) 0x001e)</span></div><div class="line"><a name="l00522"></a><span class="lineno"> 522</span> </div><div class="line"><a name="l00541"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gacaa366bdeb0413e63e87a667c5457b2e"> 541</a></span> <span class="preprocessor">#define PSA_BLOCK_CIPHER_BLOCK_SIZE(type) \</span></div><div class="line"><a name="l00542"></a><span class="lineno"> 542</span> <span class="preprocessor"> ( \</span></div><div class="line"><a name="l00543"></a><span class="lineno"> 543</span> <span class="preprocessor"> (type) == PSA_KEY_TYPE_AES ? 16 : \</span></div><div class="line"><a name="l00544"></a><span class="lineno"> 544</span> <span class="preprocessor"> (type) == PSA_KEY_TYPE_DES ? 8 : \</span></div><div class="line"><a name="l00545"></a><span class="lineno"> 545</span> <span class="preprocessor"> (type) == PSA_KEY_TYPE_CAMELLIA ? 16 : \</span></div><div class="line"><a name="l00546"></a><span class="lineno"> 546</span> <span class="preprocessor"> (type) == PSA_KEY_TYPE_ARC4 ? 1 : \</span></div><div class="line"><a name="l00547"></a><span class="lineno"> 547</span> <span class="preprocessor"> 0)</span></div><div class="line"><a name="l00548"></a><span class="lineno"> 548</span> </div><div class="line"><a name="l00557"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69"> 557</a></span> <span class="keyword">typedef</span> uint32_t <a class="code" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>;</div><div class="line"><a name="l00558"></a><span class="lineno"> 558</span> </div><div class="line"><a name="l00559"></a><span class="lineno"> 559</span> <span class="preprocessor">#define PSA_ALG_VENDOR_FLAG ((psa_algorithm_t)0x80000000)</span></div><div class="line"><a name="l00560"></a><span class="lineno"> 560</span> <span class="preprocessor">#define PSA_ALG_CATEGORY_MASK ((psa_algorithm_t)0x7f000000)</span></div><div class="line"><a name="l00561"></a><span class="lineno"> 561</span> <span class="preprocessor">#define PSA_ALG_CATEGORY_HASH ((psa_algorithm_t)0x01000000)</span></div><div class="line"><a name="l00562"></a><span class="lineno"> 562</span> <span class="preprocessor">#define PSA_ALG_CATEGORY_MAC ((psa_algorithm_t)0x02000000)</span></div><div class="line"><a name="l00563"></a><span class="lineno"> 563</span> <span class="preprocessor">#define PSA_ALG_CATEGORY_CIPHER ((psa_algorithm_t)0x04000000)</span></div><div class="line"><a name="l00564"></a><span class="lineno"> 564</span> <span class="preprocessor">#define PSA_ALG_CATEGORY_AEAD ((psa_algorithm_t)0x06000000)</span></div><div class="line"><a name="l00565"></a><span class="lineno"> 565</span> <span class="preprocessor">#define PSA_ALG_CATEGORY_SIGN ((psa_algorithm_t)0x10000000)</span></div><div class="line"><a name="l00566"></a><span class="lineno"> 566</span> <span class="preprocessor">#define PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION ((psa_algorithm_t)0x12000000)</span></div><div class="line"><a name="l00567"></a><span class="lineno"> 567</span> <span class="preprocessor">#define PSA_ALG_CATEGORY_KEY_AGREEMENT ((psa_algorithm_t)0x22000000)</span></div><div class="line"><a name="l00568"></a><span class="lineno"> 568</span> <span class="preprocessor">#define PSA_ALG_CATEGORY_KEY_DERIVATION ((psa_algorithm_t)0x30000000)</span></div><div class="line"><a name="l00569"></a><span class="lineno"> 569</span> <span class="preprocessor">#define PSA_ALG_CATEGORY_KEY_SELECTION ((psa_algorithm_t)0x31000000)</span></div><div class="line"><a name="l00570"></a><span class="lineno"> 570</span> </div><div class="line"><a name="l00571"></a><span class="lineno"> 571</span> <span class="preprocessor">#define PSA_ALG_IS_VENDOR_DEFINED(alg) \</span></div><div class="line"><a name="l00572"></a><span class="lineno"> 572</span> <span class="preprocessor"> (((alg) & PSA_ALG_VENDOR_FLAG) != 0)</span></div><div class="line"><a name="l00573"></a><span class="lineno"> 573</span> </div><div class="line"><a name="l00582"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gac9280662bb482590b4b33d1dcd32930f"> 582</a></span> <span class="preprocessor">#define PSA_ALG_IS_HASH(alg) \</span></div><div class="line"><a name="l00583"></a><span class="lineno"> 583</span> <span class="preprocessor"> (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_HASH)</span></div><div class="line"><a name="l00584"></a><span class="lineno"> 584</span> </div><div class="line"><a name="l00593"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaca7aee4c9dde316b3b1a150a26eab776"> 593</a></span> <span class="preprocessor">#define PSA_ALG_IS_MAC(alg) \</span></div><div class="line"><a name="l00594"></a><span class="lineno"> 594</span> <span class="preprocessor"> (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_MAC)</span></div><div class="line"><a name="l00595"></a><span class="lineno"> 595</span> </div><div class="line"><a name="l00604"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga1d1a5a402ad89a2e68f12bfb535490eb"> 604</a></span> <span class="preprocessor">#define PSA_ALG_IS_CIPHER(alg) \</span></div><div class="line"><a name="l00605"></a><span class="lineno"> 605</span> <span class="preprocessor"> (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_CIPHER)</span></div><div class="line"><a name="l00606"></a><span class="lineno"> 606</span> </div><div class="line"><a name="l00616"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga1d44829d60065eaa4ac9a703e7d6abc8"> 616</a></span> <span class="preprocessor">#define PSA_ALG_IS_AEAD(alg) \</span></div><div class="line"><a name="l00617"></a><span class="lineno"> 617</span> <span class="preprocessor"> (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_AEAD)</span></div><div class="line"><a name="l00618"></a><span class="lineno"> 618</span> </div><div class="line"><a name="l00627"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga6d490d0904e0698f6c1268a89d72ff31"> 627</a></span> <span class="preprocessor">#define PSA_ALG_IS_SIGN(alg) \</span></div><div class="line"><a name="l00628"></a><span class="lineno"> 628</span> <span class="preprocessor"> (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_SIGN)</span></div><div class="line"><a name="l00629"></a><span class="lineno"> 629</span> </div><div class="line"><a name="l00638"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga41d2ee937d54efd76bd54a97b2ebc08a"> 638</a></span> <span class="preprocessor">#define PSA_ALG_IS_ASYMMETRIC_ENCRYPTION(alg) \</span></div><div class="line"><a name="l00639"></a><span class="lineno"> 639</span> <span class="preprocessor"> (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION)</span></div><div class="line"><a name="l00640"></a><span class="lineno"> 640</span> </div><div class="line"><a name="l00641"></a><span class="lineno"> 641</span> <span class="preprocessor">#define PSA_ALG_KEY_SELECTION_FLAG ((psa_algorithm_t)0x01000000)</span></div><div class="line"><a name="l00642"></a><span class="lineno"> 642</span> </div><div class="line"><a name="l00650"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga59753742cb06553bd22751bbef472b6f"> 650</a></span> <span class="preprocessor">#define PSA_ALG_IS_KEY_AGREEMENT(alg) \</span></div><div class="line"><a name="l00651"></a><span class="lineno"> 651</span> <span class="preprocessor"> (((alg) & PSA_ALG_CATEGORY_MASK & ~PSA_ALG_KEY_SELECTION_FLAG) == \</span></div><div class="line"><a name="l00652"></a><span class="lineno"> 652</span> <span class="preprocessor"> PSA_ALG_CATEGORY_KEY_AGREEMENT)</span></div><div class="line"><a name="l00653"></a><span class="lineno"> 653</span> </div><div class="line"><a name="l00662"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaf8b90c648aa53dbd06c236695e300cd0"> 662</a></span> <span class="preprocessor">#define PSA_ALG_IS_KEY_DERIVATION(alg) \</span></div><div class="line"><a name="l00663"></a><span class="lineno"> 663</span> <span class="preprocessor"> (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_KEY_DERIVATION)</span></div><div class="line"><a name="l00664"></a><span class="lineno"> 664</span> </div><div class="line"><a name="l00673"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga51b1834ee5e98c6a83c2cfc7699f9077"> 673</a></span> <span class="preprocessor">#define PSA_ALG_IS_KEY_SELECTION(alg) \</span></div><div class="line"><a name="l00674"></a><span class="lineno"> 674</span> <span class="preprocessor"> (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_KEY_SELECTION)</span></div><div class="line"><a name="l00675"></a><span class="lineno"> 675</span> </div><div class="line"><a name="l00676"></a><span class="lineno"> 676</span> <span class="preprocessor">#define PSA_ALG_HASH_MASK ((psa_algorithm_t)0x000000ff)</span></div><div class="line"><a name="l00677"></a><span class="lineno"> 677</span> <span class="preprocessor">#define PSA_ALG_MD2 ((psa_algorithm_t)0x01000001)</span></div><div class="line"><a name="l00678"></a><span class="lineno"> 678</span> <span class="preprocessor">#define PSA_ALG_MD4 ((psa_algorithm_t)0x01000002)</span></div><div class="line"><a name="l00679"></a><span class="lineno"> 679</span> <span class="preprocessor">#define PSA_ALG_MD5 ((psa_algorithm_t)0x01000003)</span></div><div class="line"><a name="l00680"></a><span class="lineno"> 680</span> <span class="preprocessor">#define PSA_ALG_RIPEMD160 ((psa_algorithm_t)0x01000004)</span></div><div class="line"><a name="l00681"></a><span class="lineno"> 681</span> <span class="preprocessor">#define PSA_ALG_SHA_1 ((psa_algorithm_t)0x01000005)</span></div><div class="line"><a name="l00682"></a><span class="lineno"> 682</span> </div><div class="line"><a name="l00683"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga25d6a3244d10a7148fe6b026d1979f7b"> 683</a></span> <span class="preprocessor">#define PSA_ALG_SHA_224 ((psa_algorithm_t)0x01000008)</span></div><div class="line"><a name="l00684"></a><span class="lineno"> 684</span> </div><div class="line"><a name="l00685"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga619471f978e13cdd0a1e37145e4bf341"> 685</a></span> <span class="preprocessor">#define PSA_ALG_SHA_256 ((psa_algorithm_t)0x01000009)</span></div><div class="line"><a name="l00686"></a><span class="lineno"> 686</span> </div><div class="line"><a name="l00687"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga58af64dd9a86a287e8da9ed7739eead4"> 687</a></span> <span class="preprocessor">#define PSA_ALG_SHA_384 ((psa_algorithm_t)0x0100000a)</span></div><div class="line"><a name="l00688"></a><span class="lineno"> 688</span> </div><div class="line"><a name="l00689"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gafba3ae409f46d3dd7f37a0910660c3e9"> 689</a></span> <span class="preprocessor">#define PSA_ALG_SHA_512 ((psa_algorithm_t)0x0100000b)</span></div><div class="line"><a name="l00690"></a><span class="lineno"> 690</span> </div><div class="line"><a name="l00691"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga3fe2d7c3c80e3186ca78d16a35d5d931"> 691</a></span> <span class="preprocessor">#define PSA_ALG_SHA_512_224 ((psa_algorithm_t)0x0100000c)</span></div><div class="line"><a name="l00692"></a><span class="lineno"> 692</span> </div><div class="line"><a name="l00693"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga5910b3964c14e9613e8643a45b09c2d4"> 693</a></span> <span class="preprocessor">#define PSA_ALG_SHA_512_256 ((psa_algorithm_t)0x0100000d)</span></div><div class="line"><a name="l00694"></a><span class="lineno"> 694</span> </div><div class="line"><a name="l00695"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga16f5fe34ccce68c2fada1224c054a999"> 695</a></span> <span class="preprocessor">#define PSA_ALG_SHA3_224 ((psa_algorithm_t)0x01000010)</span></div><div class="line"><a name="l00696"></a><span class="lineno"> 696</span> </div><div class="line"><a name="l00697"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaace70d9515489bbe3c5e7ac1b7d9155b"> 697</a></span> <span class="preprocessor">#define PSA_ALG_SHA3_256 ((psa_algorithm_t)0x01000011)</span></div><div class="line"><a name="l00698"></a><span class="lineno"> 698</span> </div><div class="line"><a name="l00699"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gab0f079257ea75e2acfe2fc3b38c78cd8"> 699</a></span> <span class="preprocessor">#define PSA_ALG_SHA3_384 ((psa_algorithm_t)0x01000012)</span></div><div class="line"><a name="l00700"></a><span class="lineno"> 700</span> </div><div class="line"><a name="l00701"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga37e5dbe936dddb155e76f2997de27188"> 701</a></span> <span class="preprocessor">#define PSA_ALG_SHA3_512 ((psa_algorithm_t)0x01000013)</span></div><div class="line"><a name="l00702"></a><span class="lineno"> 702</span> </div><div class="line"><a name="l00703"></a><span class="lineno"> 703</span> <span class="preprocessor">#define PSA_ALG_MAC_SUBCATEGORY_MASK ((psa_algorithm_t)0x00c00000)</span></div><div class="line"><a name="l00704"></a><span class="lineno"> 704</span> <span class="preprocessor">#define PSA_ALG_HMAC_BASE ((psa_algorithm_t)0x02800000)</span></div><div class="line"><a name="l00705"></a><span class="lineno"> 705</span> </div><div class="line"><a name="l00716"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga70f397425684b3efcde1e0e34c28261f"> 716</a></span> <span class="preprocessor">#define PSA_ALG_HMAC(hash_alg) \</span></div><div class="line"><a name="l00717"></a><span class="lineno"> 717</span> <span class="preprocessor"> (PSA_ALG_HMAC_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l00718"></a><span class="lineno"> 718</span> </div><div class="line"><a name="l00719"></a><span class="lineno"> 719</span> <span class="preprocessor">#define PSA_ALG_HMAC_GET_HASH(hmac_alg) \</span></div><div class="line"><a name="l00720"></a><span class="lineno"> 720</span> <span class="preprocessor"> (PSA_ALG_CATEGORY_HASH | ((hmac_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l00721"></a><span class="lineno"> 721</span> </div><div class="line"><a name="l00732"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga4a050c3c3cbc6eb96418f18847601c8a"> 732</a></span> <span class="preprocessor">#define PSA_ALG_IS_HMAC(alg) \</span></div><div class="line"><a name="l00733"></a><span class="lineno"> 733</span> <span class="preprocessor"> (((alg) & (PSA_ALG_CATEGORY_MASK | PSA_ALG_MAC_SUBCATEGORY_MASK)) == \</span></div><div class="line"><a name="l00734"></a><span class="lineno"> 734</span> <span class="preprocessor"> PSA_ALG_HMAC_BASE)</span></div><div class="line"><a name="l00735"></a><span class="lineno"> 735</span> </div><div class="line"><a name="l00736"></a><span class="lineno"> 736</span> <span class="comment">/* In the encoding of a MAC algorithm, the bits corresponding to</span></div><div class="line"><a name="l00737"></a><span class="lineno"> 737</span> <span class="comment"> * PSA_ALG_MAC_TRUNCATION_MASK encode the length to which the MAC is</span></div><div class="line"><a name="l00738"></a><span class="lineno"> 738</span> <span class="comment"> * truncated. As an exception, the value 0 means the untruncated algorithm,</span></div><div class="line"><a name="l00739"></a><span class="lineno"> 739</span> <span class="comment"> * whatever its length is. The length is encoded in 6 bits, so it can</span></div><div class="line"><a name="l00740"></a><span class="lineno"> 740</span> <span class="comment"> * reach up to 63; the largest MAC is 64 bytes so its trivial truncation</span></div><div class="line"><a name="l00741"></a><span class="lineno"> 741</span> <span class="comment"> * to full length is correctly encoded as 0 and any non-trivial truncation</span></div><div class="line"><a name="l00742"></a><span class="lineno"> 742</span> <span class="comment"> * is correctly encoded as a value between 1 and 63. */</span></div><div class="line"><a name="l00743"></a><span class="lineno"> 743</span> <span class="preprocessor">#define PSA_ALG_MAC_TRUNCATION_MASK ((psa_algorithm_t)0x00003f00)</span></div><div class="line"><a name="l00744"></a><span class="lineno"> 744</span> <span class="preprocessor">#define PSA_MAC_TRUNCATION_OFFSET 8</span></div><div class="line"><a name="l00745"></a><span class="lineno"> 745</span> </div><div class="line"><a name="l00779"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaf36137110baf7bb13c5028fd62c64276"> 779</a></span> <span class="preprocessor">#define PSA_ALG_TRUNCATED_MAC(alg, mac_length) \</span></div><div class="line"><a name="l00780"></a><span class="lineno"> 780</span> <span class="preprocessor"> (((alg) & ~PSA_ALG_MAC_TRUNCATION_MASK) | \</span></div><div class="line"><a name="l00781"></a><span class="lineno"> 781</span> <span class="preprocessor"> ((mac_length) << PSA_MAC_TRUNCATION_OFFSET & PSA_ALG_MAC_TRUNCATION_MASK))</span></div><div class="line"><a name="l00782"></a><span class="lineno"> 782</span> </div><div class="line"><a name="l00795"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaa05a8d99634f3350597ac9284fb70cb1"> 795</a></span> <span class="preprocessor">#define PSA_ALG_FULL_LENGTH_MAC(alg) \</span></div><div class="line"><a name="l00796"></a><span class="lineno"> 796</span> <span class="preprocessor"> ((alg) & ~PSA_ALG_MAC_TRUNCATION_MASK)</span></div><div class="line"><a name="l00797"></a><span class="lineno"> 797</span> </div><div class="line"><a name="l00809"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gab03726c4476174e019a08e2a04018ce8"> 809</a></span> <span class="preprocessor">#define PSA_MAC_TRUNCATED_LENGTH(alg) \</span></div><div class="line"><a name="l00810"></a><span class="lineno"> 810</span> <span class="preprocessor"> (((alg) & PSA_ALG_MAC_TRUNCATION_MASK) >> PSA_MAC_TRUNCATION_OFFSET)</span></div><div class="line"><a name="l00811"></a><span class="lineno"> 811</span> </div><div class="line"><a name="l00812"></a><span class="lineno"> 812</span> <span class="preprocessor">#define PSA_ALG_CIPHER_MAC_BASE ((psa_algorithm_t)0x02c00000)</span></div><div class="line"><a name="l00813"></a><span class="lineno"> 813</span> <span class="preprocessor">#define PSA_ALG_CBC_MAC ((psa_algorithm_t)0x02c00001)</span></div><div class="line"><a name="l00814"></a><span class="lineno"> 814</span> <span class="preprocessor">#define PSA_ALG_CMAC ((psa_algorithm_t)0x02c00002)</span></div><div class="line"><a name="l00815"></a><span class="lineno"> 815</span> <span class="preprocessor">#define PSA_ALG_GMAC ((psa_algorithm_t)0x02c00003)</span></div><div class="line"><a name="l00816"></a><span class="lineno"> 816</span> </div><div class="line"><a name="l00825"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gae49d1eb601125d65a5c5b252aa45479e"> 825</a></span> <span class="preprocessor">#define PSA_ALG_IS_BLOCK_CIPHER_MAC(alg) \</span></div><div class="line"><a name="l00826"></a><span class="lineno"> 826</span> <span class="preprocessor"> (((alg) & (PSA_ALG_CATEGORY_MASK | PSA_ALG_MAC_SUBCATEGORY_MASK)) == \</span></div><div class="line"><a name="l00827"></a><span class="lineno"> 827</span> <span class="preprocessor"> PSA_ALG_CIPHER_MAC_BASE)</span></div><div class="line"><a name="l00828"></a><span class="lineno"> 828</span> </div><div class="line"><a name="l00829"></a><span class="lineno"> 829</span> <span class="preprocessor">#define PSA_ALG_CIPHER_STREAM_FLAG ((psa_algorithm_t)0x00800000)</span></div><div class="line"><a name="l00830"></a><span class="lineno"> 830</span> <span class="preprocessor">#define PSA_ALG_CIPHER_FROM_BLOCK_FLAG ((psa_algorithm_t)0x00400000)</span></div><div class="line"><a name="l00831"></a><span class="lineno"> 831</span> </div><div class="line"><a name="l00844"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gacfec68e0c6175e02e1b2ebc97df383c0"> 844</a></span> <span class="preprocessor">#define PSA_ALG_IS_STREAM_CIPHER(alg) \</span></div><div class="line"><a name="l00845"></a><span class="lineno"> 845</span> <span class="preprocessor"> (((alg) & (PSA_ALG_CATEGORY_MASK | PSA_ALG_CIPHER_STREAM_FLAG)) == \</span></div><div class="line"><a name="l00846"></a><span class="lineno"> 846</span> <span class="preprocessor"> (PSA_ALG_CATEGORY_CIPHER | PSA_ALG_CIPHER_STREAM_FLAG))</span></div><div class="line"><a name="l00847"></a><span class="lineno"> 847</span> </div><div class="line"><a name="l00850"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gab6a5284decb0e5e1b5b8740a41ef3c5e"> 850</a></span> <span class="preprocessor">#define PSA_ALG_ARC4 ((psa_algorithm_t)0x04800001)</span></div><div class="line"><a name="l00851"></a><span class="lineno"> 851</span> </div><div class="line"><a name="l00859"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gad318309706a769cffdc64e4c7e06b2e9"> 859</a></span> <span class="preprocessor">#define PSA_ALG_CTR ((psa_algorithm_t)0x04c00001)</span></div><div class="line"><a name="l00860"></a><span class="lineno"> 860</span> </div><div class="line"><a name="l00861"></a><span class="lineno"> 861</span> <span class="preprocessor">#define PSA_ALG_CFB ((psa_algorithm_t)0x04c00002)</span></div><div class="line"><a name="l00862"></a><span class="lineno"> 862</span> </div><div class="line"><a name="l00863"></a><span class="lineno"> 863</span> <span class="preprocessor">#define PSA_ALG_OFB ((psa_algorithm_t)0x04c00003)</span></div><div class="line"><a name="l00864"></a><span class="lineno"> 864</span> </div><div class="line"><a name="l00871"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaa722c0e426a797fd6d99623f59748125"> 871</a></span> <span class="preprocessor">#define PSA_ALG_XTS ((psa_algorithm_t)0x044000ff)</span></div><div class="line"><a name="l00872"></a><span class="lineno"> 872</span> </div><div class="line"><a name="l00880"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gacb332d72716958880ee7f97d8365ae66"> 880</a></span> <span class="preprocessor">#define PSA_ALG_CBC_NO_PADDING ((psa_algorithm_t)0x04600100)</span></div><div class="line"><a name="l00881"></a><span class="lineno"> 881</span> </div><div class="line"><a name="l00888"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaef50d2e9716eb6d476046608e4e0c78c"> 888</a></span> <span class="preprocessor">#define PSA_ALG_CBC_PKCS7 ((psa_algorithm_t)0x04600101)</span></div><div class="line"><a name="l00889"></a><span class="lineno"> 889</span> </div><div class="line"><a name="l00890"></a><span class="lineno"> 890</span> <span class="preprocessor">#define PSA_ALG_CCM ((psa_algorithm_t)0x06001001)</span></div><div class="line"><a name="l00891"></a><span class="lineno"> 891</span> <span class="preprocessor">#define PSA_ALG_GCM ((psa_algorithm_t)0x06001002)</span></div><div class="line"><a name="l00892"></a><span class="lineno"> 892</span> </div><div class="line"><a name="l00893"></a><span class="lineno"> 893</span> <span class="comment">/* In the encoding of a AEAD algorithm, the bits corresponding to</span></div><div class="line"><a name="l00894"></a><span class="lineno"> 894</span> <span class="comment"> * PSA_ALG_AEAD_TAG_LENGTH_MASK encode the length of the AEAD tag.</span></div><div class="line"><a name="l00895"></a><span class="lineno"> 895</span> <span class="comment"> * The constants for default lengths follow this encoding.</span></div><div class="line"><a name="l00896"></a><span class="lineno"> 896</span> <span class="comment"> */</span></div><div class="line"><a name="l00897"></a><span class="lineno"> 897</span> <span class="preprocessor">#define PSA_ALG_AEAD_TAG_LENGTH_MASK ((psa_algorithm_t)0x00003f00)</span></div><div class="line"><a name="l00898"></a><span class="lineno"> 898</span> <span class="preprocessor">#define PSA_AEAD_TAG_LENGTH_OFFSET 8</span></div><div class="line"><a name="l00899"></a><span class="lineno"> 899</span> </div><div class="line"><a name="l00918"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaa63c520b62ab001d54d28801742fc9db"> 918</a></span> <span class="preprocessor">#define PSA_ALG_AEAD_WITH_TAG_LENGTH(alg, tag_length) \</span></div><div class="line"><a name="l00919"></a><span class="lineno"> 919</span> <span class="preprocessor"> (((alg) & ~PSA_ALG_AEAD_TAG_LENGTH_MASK) | \</span></div><div class="line"><a name="l00920"></a><span class="lineno"> 920</span> <span class="preprocessor"> ((tag_length) << PSA_AEAD_TAG_LENGTH_OFFSET & \</span></div><div class="line"><a name="l00921"></a><span class="lineno"> 921</span> <span class="preprocessor"> PSA_ALG_AEAD_TAG_LENGTH_MASK))</span></div><div class="line"><a name="l00922"></a><span class="lineno"> 922</span> </div><div class="line"><a name="l00931"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaddea507e062250cda8a29407a9480d2b"> 931</a></span> <span class="preprocessor">#define PSA_ALG_AEAD_WITH_DEFAULT_TAG_LENGTH(alg) \</span></div><div class="line"><a name="l00932"></a><span class="lineno"> 932</span> <span class="preprocessor"> ( \</span></div><div class="line"><a name="l00933"></a><span class="lineno"> 933</span> <span class="preprocessor"> PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE(alg, PSA_ALG_CCM) \</span></div><div class="line"><a name="l00934"></a><span class="lineno"> 934</span> <span class="preprocessor"> PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE(alg, PSA_ALG_GCM) \</span></div><div class="line"><a name="l00935"></a><span class="lineno"> 935</span> <span class="preprocessor"> 0)</span></div><div class="line"><a name="l00936"></a><span class="lineno"> 936</span> <span class="preprocessor">#define PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE(alg, ref) \</span></div><div class="line"><a name="l00937"></a><span class="lineno"> 937</span> <span class="preprocessor"> PSA_ALG_AEAD_WITH_TAG_LENGTH(alg, 0) == \</span></div><div class="line"><a name="l00938"></a><span class="lineno"> 938</span> <span class="preprocessor"> PSA_ALG_AEAD_WITH_TAG_LENGTH(ref, 0) ? \</span></div><div class="line"><a name="l00939"></a><span class="lineno"> 939</span> <span class="preprocessor"> ref :</span></div><div class="line"><a name="l00940"></a><span class="lineno"> 940</span> </div><div class="line"><a name="l00941"></a><span class="lineno"> 941</span> <span class="preprocessor">#define PSA_ALG_RSA_PKCS1V15_SIGN_BASE ((psa_algorithm_t)0x10020000)</span></div><div class="line"><a name="l00942"></a><span class="lineno"> 942</span> </div><div class="line"><a name="l00955"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga702ff75385a6ae7d4247033f479439af"> 955</a></span> <span class="preprocessor">#define PSA_ALG_RSA_PKCS1V15_SIGN(hash_alg) \</span></div><div class="line"><a name="l00956"></a><span class="lineno"> 956</span> <span class="preprocessor"> (PSA_ALG_RSA_PKCS1V15_SIGN_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l00957"></a><span class="lineno"> 957</span> </div><div class="line"><a name="l00963"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga4215e2a78dcf834e9a625927faa2a817"> 963</a></span> <span class="preprocessor">#define PSA_ALG_RSA_PKCS1V15_SIGN_RAW PSA_ALG_RSA_PKCS1V15_SIGN_BASE</span></div><div class="line"><a name="l00964"></a><span class="lineno"> 964</span> <span class="preprocessor">#define PSA_ALG_IS_RSA_PKCS1V15_SIGN(alg) \</span></div><div class="line"><a name="l00965"></a><span class="lineno"> 965</span> <span class="preprocessor"> (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_RSA_PKCS1V15_SIGN_BASE)</span></div><div class="line"><a name="l00966"></a><span class="lineno"> 966</span> </div><div class="line"><a name="l00967"></a><span class="lineno"> 967</span> <span class="preprocessor">#define PSA_ALG_RSA_PSS_BASE ((psa_algorithm_t)0x10030000)</span></div><div class="line"><a name="l00968"></a><span class="lineno"> 968</span> </div><div class="line"><a name="l00984"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga62152bf4cb4bf6aace5e1be8f143564d"> 984</a></span> <span class="preprocessor">#define PSA_ALG_RSA_PSS(hash_alg) \</span></div><div class="line"><a name="l00985"></a><span class="lineno"> 985</span> <span class="preprocessor"> (PSA_ALG_RSA_PSS_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l00986"></a><span class="lineno"> 986</span> <span class="preprocessor">#define PSA_ALG_IS_RSA_PSS(alg) \</span></div><div class="line"><a name="l00987"></a><span class="lineno"> 987</span> <span class="preprocessor"> (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_RSA_PSS_BASE)</span></div><div class="line"><a name="l00988"></a><span class="lineno"> 988</span> </div><div class="line"><a name="l00989"></a><span class="lineno"> 989</span> <span class="preprocessor">#define PSA_ALG_DSA_BASE ((psa_algorithm_t)0x10040000)</span></div><div class="line"><a name="l00990"></a><span class="lineno"> 990</span> </div><div class="line"><a name="l01002"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga9a68efdddff5ae95f104a1416b12742e"> 1002</a></span> <span class="preprocessor">#define PSA_ALG_DSA(hash_alg) \</span></div><div class="line"><a name="l01003"></a><span class="lineno"> 1003</span> <span class="preprocessor"> (PSA_ALG_DSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l01004"></a><span class="lineno"> 1004</span> <span class="preprocessor">#define PSA_ALG_DETERMINISTIC_DSA_BASE ((psa_algorithm_t)0x10050000)</span></div><div class="line"><a name="l01005"></a><span class="lineno"> 1005</span> <span class="preprocessor">#define PSA_ALG_DSA_DETERMINISTIC_FLAG ((psa_algorithm_t)0x00010000)</span></div><div class="line"><a name="l01006"></a><span class="lineno"> 1006</span> <span class="preprocessor">#define PSA_ALG_DETERMINISTIC_DSA(hash_alg) \</span></div><div class="line"><a name="l01007"></a><span class="lineno"> 1007</span> <span class="preprocessor"> (PSA_ALG_DETERMINISTIC_DSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l01008"></a><span class="lineno"> 1008</span> <span class="preprocessor">#define PSA_ALG_IS_DSA(alg) \</span></div><div class="line"><a name="l01009"></a><span class="lineno"> 1009</span> <span class="preprocessor"> (((alg) & ~PSA_ALG_HASH_MASK & ~PSA_ALG_DSA_DETERMINISTIC_FLAG) == \</span></div><div class="line"><a name="l01010"></a><span class="lineno"> 1010</span> <span class="preprocessor"> PSA_ALG_DSA_BASE)</span></div><div class="line"><a name="l01011"></a><span class="lineno"> 1011</span> <span class="preprocessor">#define PSA_ALG_DSA_IS_DETERMINISTIC(alg) \</span></div><div class="line"><a name="l01012"></a><span class="lineno"> 1012</span> <span class="preprocessor"> (((alg) & PSA_ALG_DSA_DETERMINISTIC_FLAG) != 0)</span></div><div class="line"><a name="l01013"></a><span class="lineno"> 1013</span> <span class="preprocessor">#define PSA_ALG_IS_DETERMINISTIC_DSA(alg) \</span></div><div class="line"><a name="l01014"></a><span class="lineno"> 1014</span> <span class="preprocessor"> (PSA_ALG_IS_DSA(alg) && PSA_ALG_DSA_IS_DETERMINISTIC(alg))</span></div><div class="line"><a name="l01015"></a><span class="lineno"> 1015</span> <span class="preprocessor">#define PSA_ALG_IS_RANDOMIZED_DSA(alg) \</span></div><div class="line"><a name="l01016"></a><span class="lineno"> 1016</span> <span class="preprocessor"> (PSA_ALG_IS_DSA(alg) && !PSA_ALG_DSA_IS_DETERMINISTIC(alg))</span></div><div class="line"><a name="l01017"></a><span class="lineno"> 1017</span> </div><div class="line"><a name="l01018"></a><span class="lineno"> 1018</span> <span class="preprocessor">#define PSA_ALG_ECDSA_BASE ((psa_algorithm_t)0x10060000)</span></div><div class="line"><a name="l01019"></a><span class="lineno"> 1019</span> </div><div class="line"><a name="l01037"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga7e3ce9f514a227d5ba5d8318870452e3"> 1037</a></span> <span class="preprocessor">#define PSA_ALG_ECDSA(hash_alg) \</span></div><div class="line"><a name="l01038"></a><span class="lineno"> 1038</span> <span class="preprocessor"> (PSA_ALG_ECDSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l01039"></a><span class="lineno"> 1039</span> </div><div class="line"><a name="l01048"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga51d6b6044a62e33cae0cf64bfc3b22a4"> 1048</a></span> <span class="preprocessor">#define PSA_ALG_ECDSA_ANY PSA_ALG_ECDSA_BASE</span></div><div class="line"><a name="l01049"></a><span class="lineno"> 1049</span> <span class="preprocessor">#define PSA_ALG_DETERMINISTIC_ECDSA_BASE ((psa_algorithm_t)0x10070000)</span></div><div class="line"><a name="l01050"></a><span class="lineno"> 1050</span> </div><div class="line"><a name="l01070"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga11da566bcd341661c8de921e2ca5ed03"> 1070</a></span> <span class="preprocessor">#define PSA_ALG_DETERMINISTIC_ECDSA(hash_alg) \</span></div><div class="line"><a name="l01071"></a><span class="lineno"> 1071</span> <span class="preprocessor"> (PSA_ALG_DETERMINISTIC_ECDSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l01072"></a><span class="lineno"> 1072</span> <span class="preprocessor">#define PSA_ALG_IS_ECDSA(alg) \</span></div><div class="line"><a name="l01073"></a><span class="lineno"> 1073</span> <span class="preprocessor"> (((alg) & ~PSA_ALG_HASH_MASK & ~PSA_ALG_DSA_DETERMINISTIC_FLAG) == \</span></div><div class="line"><a name="l01074"></a><span class="lineno"> 1074</span> <span class="preprocessor"> PSA_ALG_ECDSA_BASE)</span></div><div class="line"><a name="l01075"></a><span class="lineno"> 1075</span> <span class="preprocessor">#define PSA_ALG_ECDSA_IS_DETERMINISTIC(alg) \</span></div><div class="line"><a name="l01076"></a><span class="lineno"> 1076</span> <span class="preprocessor"> (((alg) & PSA_ALG_DSA_DETERMINISTIC_FLAG) != 0)</span></div><div class="line"><a name="l01077"></a><span class="lineno"> 1077</span> <span class="preprocessor">#define PSA_ALG_IS_DETERMINISTIC_ECDSA(alg) \</span></div><div class="line"><a name="l01078"></a><span class="lineno"> 1078</span> <span class="preprocessor"> (PSA_ALG_IS_ECDSA(alg) && PSA_ALG_ECDSA_IS_DETERMINISTIC(alg))</span></div><div class="line"><a name="l01079"></a><span class="lineno"> 1079</span> <span class="preprocessor">#define PSA_ALG_IS_RANDOMIZED_ECDSA(alg) \</span></div><div class="line"><a name="l01080"></a><span class="lineno"> 1080</span> <span class="preprocessor"> (PSA_ALG_IS_ECDSA(alg) && !PSA_ALG_ECDSA_IS_DETERMINISTIC(alg))</span></div><div class="line"><a name="l01081"></a><span class="lineno"> 1081</span> </div><div class="line"><a name="l01100"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga24cf6d7bcd2b9aeeeff86f07b6c674e3"> 1100</a></span> <span class="preprocessor">#define PSA_ALG_SIGN_GET_HASH(alg) \</span></div><div class="line"><a name="l01101"></a><span class="lineno"> 1101</span> <span class="preprocessor"> (PSA_ALG_IS_RSA_PSS(alg) || PSA_ALG_IS_RSA_PKCS1V15_SIGN(alg) || \</span></div><div class="line"><a name="l01102"></a><span class="lineno"> 1102</span> <span class="preprocessor"> PSA_ALG_IS_DSA(alg) || PSA_ALG_IS_ECDSA(alg) ? \</span></div><div class="line"><a name="l01103"></a><span class="lineno"> 1103</span> <span class="preprocessor"> ((alg) & PSA_ALG_HASH_MASK) == 0 ? </span><span class="comment">/*"raw" algorithm*/</span><span class="preprocessor"> 0 : \</span></div><div class="line"><a name="l01104"></a><span class="lineno"> 1104</span> <span class="preprocessor"> ((alg) & PSA_ALG_HASH_MASK) | PSA_ALG_CATEGORY_HASH : \</span></div><div class="line"><a name="l01105"></a><span class="lineno"> 1105</span> <span class="preprocessor"> 0)</span></div><div class="line"><a name="l01106"></a><span class="lineno"> 1106</span> </div><div class="line"><a name="l01109"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga4c540d3abe43fb9abcb94f2bc51acef9"> 1109</a></span> <span class="preprocessor">#define PSA_ALG_RSA_PKCS1V15_CRYPT ((psa_algorithm_t)0x12020000)</span></div><div class="line"><a name="l01110"></a><span class="lineno"> 1110</span> </div><div class="line"><a name="l01111"></a><span class="lineno"> 1111</span> <span class="preprocessor">#define PSA_ALG_RSA_OAEP_BASE ((psa_algorithm_t)0x12030000)</span></div><div class="line"><a name="l01112"></a><span class="lineno"> 1112</span> </div><div class="line"><a name="l01126"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaa1235dc3fdd9839c6c1b1a9857344c76"> 1126</a></span> <span class="preprocessor">#define PSA_ALG_RSA_OAEP(hash_alg) \</span></div><div class="line"><a name="l01127"></a><span class="lineno"> 1127</span> <span class="preprocessor"> (PSA_ALG_RSA_OAEP_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l01128"></a><span class="lineno"> 1128</span> <span class="preprocessor">#define PSA_ALG_IS_RSA_OAEP(alg) \</span></div><div class="line"><a name="l01129"></a><span class="lineno"> 1129</span> <span class="preprocessor"> (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_RSA_OAEP_BASE)</span></div><div class="line"><a name="l01130"></a><span class="lineno"> 1130</span> <span class="preprocessor">#define PSA_ALG_RSA_OAEP_GET_HASH(alg) \</span></div><div class="line"><a name="l01131"></a><span class="lineno"> 1131</span> <span class="preprocessor"> (PSA_ALG_IS_RSA_OAEP(alg) ? \</span></div><div class="line"><a name="l01132"></a><span class="lineno"> 1132</span> <span class="preprocessor"> ((alg) & PSA_ALG_HASH_MASK) | PSA_ALG_CATEGORY_HASH : \</span></div><div class="line"><a name="l01133"></a><span class="lineno"> 1133</span> <span class="preprocessor"> 0)</span></div><div class="line"><a name="l01134"></a><span class="lineno"> 1134</span> </div><div class="line"><a name="l01135"></a><span class="lineno"> 1135</span> <span class="preprocessor">#define PSA_ALG_HKDF_BASE ((psa_algorithm_t)0x30000100)</span></div><div class="line"><a name="l01136"></a><span class="lineno"> 1136</span> </div><div class="line"><a name="l01147"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga32a888fb360e6e25cab8a343772c4a82"> 1147</a></span> <span class="preprocessor">#define PSA_ALG_HKDF(hash_alg) \</span></div><div class="line"><a name="l01148"></a><span class="lineno"> 1148</span> <span class="preprocessor"> (PSA_ALG_HKDF_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l01149"></a><span class="lineno"> 1149</span> </div><div class="line"><a name="l01160"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga1979d0a76fcee6164cf2e65960f38db2"> 1160</a></span> <span class="preprocessor">#define PSA_ALG_IS_HKDF(alg) \</span></div><div class="line"><a name="l01161"></a><span class="lineno"> 1161</span> <span class="preprocessor"> (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_HKDF_BASE)</span></div><div class="line"><a name="l01162"></a><span class="lineno"> 1162</span> <span class="preprocessor">#define PSA_ALG_HKDF_GET_HASH(hkdf_alg) \</span></div><div class="line"><a name="l01163"></a><span class="lineno"> 1163</span> <span class="preprocessor"> (PSA_ALG_CATEGORY_HASH | ((hkdf_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l01164"></a><span class="lineno"> 1164</span> </div><div class="line"><a name="l01165"></a><span class="lineno"> 1165</span> <span class="preprocessor">#define PSA_ALG_TLS12_PRF_BASE ((psa_algorithm_t)0x30000200)</span></div><div class="line"><a name="l01166"></a><span class="lineno"> 1166</span> </div><div class="line"><a name="l01188"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga6d5623c2ccda1d4a84e34351af8382d5"> 1188</a></span> <span class="preprocessor">#define PSA_ALG_TLS12_PRF(hash_alg) \</span></div><div class="line"><a name="l01189"></a><span class="lineno"> 1189</span> <span class="preprocessor"> (PSA_ALG_TLS12_PRF_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l01190"></a><span class="lineno"> 1190</span> </div><div class="line"><a name="l01199"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaa3c18890c50222e5219f40ade8927e66"> 1199</a></span> <span class="preprocessor">#define PSA_ALG_IS_TLS12_PRF(alg) \</span></div><div class="line"><a name="l01200"></a><span class="lineno"> 1200</span> <span class="preprocessor"> (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_TLS12_PRF_BASE)</span></div><div class="line"><a name="l01201"></a><span class="lineno"> 1201</span> <span class="preprocessor">#define PSA_ALG_TLS12_PRF_GET_HASH(hkdf_alg) \</span></div><div class="line"><a name="l01202"></a><span class="lineno"> 1202</span> <span class="preprocessor"> (PSA_ALG_CATEGORY_HASH | ((hkdf_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l01203"></a><span class="lineno"> 1203</span> </div><div class="line"><a name="l01204"></a><span class="lineno"> 1204</span> <span class="preprocessor">#define PSA_ALG_TLS12_PSK_TO_MS_BASE ((psa_algorithm_t)0x30000300)</span></div><div class="line"><a name="l01205"></a><span class="lineno"> 1205</span> </div><div class="line"><a name="l01228"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga039ec797f15d1635d9b2e09a611f8a68"> 1228</a></span> <span class="preprocessor">#define PSA_ALG_TLS12_PSK_TO_MS(hash_alg) \</span></div><div class="line"><a name="l01229"></a><span class="lineno"> 1229</span> <span class="preprocessor"> (PSA_ALG_TLS12_PSK_TO_MS_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l01230"></a><span class="lineno"> 1230</span> </div><div class="line"><a name="l01239"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gab25ecc074a93fd11069bedfbba5a287b"> 1239</a></span> <span class="preprocessor">#define PSA_ALG_IS_TLS12_PSK_TO_MS(alg) \</span></div><div class="line"><a name="l01240"></a><span class="lineno"> 1240</span> <span class="preprocessor"> (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_TLS12_PSK_TO_MS_BASE)</span></div><div class="line"><a name="l01241"></a><span class="lineno"> 1241</span> <span class="preprocessor">#define PSA_ALG_TLS12_PSK_TO_MS_GET_HASH(hkdf_alg) \</span></div><div class="line"><a name="l01242"></a><span class="lineno"> 1242</span> <span class="preprocessor"> (PSA_ALG_CATEGORY_HASH | ((hkdf_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l01243"></a><span class="lineno"> 1243</span> </div><div class="line"><a name="l01244"></a><span class="lineno"> 1244</span> <span class="preprocessor">#define PSA_ALG_KEY_DERIVATION_MASK ((psa_algorithm_t)0x010fffff)</span></div><div class="line"><a name="l01245"></a><span class="lineno"> 1245</span> </div><div class="line"><a name="l01256"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gacbbcb60abf1714722f50f80ce9c21602"> 1256</a></span> <span class="preprocessor">#define PSA_ALG_SELECT_RAW ((psa_algorithm_t)0x31000001)</span></div><div class="line"><a name="l01257"></a><span class="lineno"> 1257</span> </div><div class="line"><a name="l01258"></a><span class="lineno"> 1258</span> <span class="preprocessor">#define PSA_ALG_KEY_AGREEMENT_GET_KDF(alg) \</span></div><div class="line"><a name="l01259"></a><span class="lineno"> 1259</span> <span class="preprocessor"> (((alg) & PSA_ALG_KEY_DERIVATION_MASK) | PSA_ALG_CATEGORY_KEY_DERIVATION)</span></div><div class="line"><a name="l01260"></a><span class="lineno"> 1260</span> </div><div class="line"><a name="l01261"></a><span class="lineno"> 1261</span> <span class="preprocessor">#define PSA_ALG_KEY_AGREEMENT_GET_BASE(alg) \</span></div><div class="line"><a name="l01262"></a><span class="lineno"> 1262</span> <span class="preprocessor"> ((alg) & ~PSA_ALG_KEY_DERIVATION_MASK)</span></div><div class="line"><a name="l01263"></a><span class="lineno"> 1263</span> </div><div class="line"><a name="l01264"></a><span class="lineno"> 1264</span> <span class="preprocessor">#define PSA_ALG_FFDH_BASE ((psa_algorithm_t)0x22100000)</span></div><div class="line"><a name="l01265"></a><span class="lineno"> 1265</span> </div><div class="line"><a name="l01287"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga21037568ad0b2e97d76dfc700b6b4483"> 1287</a></span> <span class="preprocessor">#define PSA_ALG_FFDH(kdf_alg) \</span></div><div class="line"><a name="l01288"></a><span class="lineno"> 1288</span> <span class="preprocessor"> (PSA_ALG_FFDH_BASE | ((kdf_alg) & PSA_ALG_KEY_DERIVATION_MASK))</span></div><div class="line"><a name="l01289"></a><span class="lineno"> 1289</span> </div><div class="line"><a name="l01300"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaa3cf76164cd9375af4fb8a291078a19e"> 1300</a></span> <span class="preprocessor">#define PSA_ALG_IS_FFDH(alg) \</span></div><div class="line"><a name="l01301"></a><span class="lineno"> 1301</span> <span class="preprocessor"> (PSA_ALG_KEY_AGREEMENT_GET_BASE(alg) == PSA_ALG_FFDH_BASE)</span></div><div class="line"><a name="l01302"></a><span class="lineno"> 1302</span> </div><div class="line"><a name="l01303"></a><span class="lineno"> 1303</span> <span class="preprocessor">#define PSA_ALG_ECDH_BASE ((psa_algorithm_t)0x22200000)</span></div><div class="line"><a name="l01304"></a><span class="lineno"> 1304</span> </div><div class="line"><a name="l01343"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga974b73fccc5a9142256d8ce3092dff7f"> 1343</a></span> <span class="preprocessor">#define PSA_ALG_ECDH(kdf_alg) \</span></div><div class="line"><a name="l01344"></a><span class="lineno"> 1344</span> <span class="preprocessor"> (PSA_ALG_ECDH_BASE | ((kdf_alg) & PSA_ALG_KEY_DERIVATION_MASK))</span></div><div class="line"><a name="l01345"></a><span class="lineno"> 1345</span> </div><div class="line"><a name="l01358"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga9d9b6533d2a6bea7bac7ae01facb820d"> 1358</a></span> <span class="preprocessor">#define PSA_ALG_IS_ECDH(alg) \</span></div><div class="line"><a name="l01359"></a><span class="lineno"> 1359</span> <span class="preprocessor"> (PSA_ALG_KEY_AGREEMENT_GET_BASE(alg) == PSA_ALG_ECDH_BASE)</span></div><div class="line"><a name="l01360"></a><span class="lineno"> 1360</span> </div><div class="line"><a name="l01369"></a><span class="lineno"><a class="line" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf"> 1369</a></span> <span class="keyword">typedef</span> uint32_t <a class="code" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">psa_key_lifetime_t</a>;</div><div class="line"><a name="l01370"></a><span class="lineno"> 1370</span> </div><div class="line"><a name="l01373"></a><span class="lineno"><a class="line" href="group__key__lifetimes.html#ga11e986351c65bd3dc3c0fe2cd9926e4b"> 1373</a></span> <span class="keyword">typedef</span> uint32_t <a class="code" href="group__key__lifetimes.html#ga11e986351c65bd3dc3c0fe2cd9926e4b">psa_key_id_t</a>;</div><div class="line"><a name="l01374"></a><span class="lineno"> 1374</span> </div><div class="line"><a name="l01378"></a><span class="lineno"><a class="line" href="group__key__lifetimes.html#ga8b438870ba69489b685730d346455108"> 1378</a></span> <span class="preprocessor">#define PSA_KEY_LIFETIME_VOLATILE ((psa_key_lifetime_t)0x00000000)</span></div><div class="line"><a name="l01379"></a><span class="lineno"> 1379</span> </div><div class="line"><a name="l01392"></a><span class="lineno"><a class="line" href="group__key__lifetimes.html#ga3713a01c5fcd5f7eae46ff22ceaf6d02"> 1392</a></span> <span class="preprocessor">#define PSA_KEY_LIFETIME_PERSISTENT ((psa_key_lifetime_t)0x00000001)</span></div><div class="line"><a name="l01393"></a><span class="lineno"> 1393</span> </div><div class="line"><a name="l01401"></a><span class="lineno"><a class="line" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25"> 1401</a></span> <span class="keyword">typedef</span> uint32_t <a class="code" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a>;</div><div class="line"><a name="l01402"></a><span class="lineno"> 1402</span> </div><div class="line"><a name="l01414"></a><span class="lineno"><a class="line" href="group__policy.html#ga7dddccdd1303176e87a4d20c87b589ed"> 1414</a></span> <span class="preprocessor">#define PSA_KEY_USAGE_EXPORT ((psa_key_usage_t)0x00000001)</span></div><div class="line"><a name="l01415"></a><span class="lineno"> 1415</span> </div><div class="line"><a name="l01425"></a><span class="lineno"><a class="line" href="group__policy.html#ga75153b296d045d529d97203a6a995dad"> 1425</a></span> <span class="preprocessor">#define PSA_KEY_USAGE_ENCRYPT ((psa_key_usage_t)0x00000100)</span></div><div class="line"><a name="l01426"></a><span class="lineno"> 1426</span> </div><div class="line"><a name="l01436"></a><span class="lineno"><a class="line" href="group__policy.html#gac3f2d2e5983db1edde9f142ca9bf8e6a"> 1436</a></span> <span class="preprocessor">#define PSA_KEY_USAGE_DECRYPT ((psa_key_usage_t)0x00000200)</span></div><div class="line"><a name="l01437"></a><span class="lineno"> 1437</span> </div><div class="line"><a name="l01446"></a><span class="lineno"><a class="line" href="group__policy.html#ga99b9f456cf59efc4b5579465407aef5a"> 1446</a></span> <span class="preprocessor">#define PSA_KEY_USAGE_SIGN ((psa_key_usage_t)0x00000400)</span></div><div class="line"><a name="l01447"></a><span class="lineno"> 1447</span> </div><div class="line"><a name="l01456"></a><span class="lineno"><a class="line" href="group__policy.html#ga39b54ffd5958b69634607924fa53cea6"> 1456</a></span> <span class="preprocessor">#define PSA_KEY_USAGE_VERIFY ((psa_key_usage_t)0x00000800)</span></div><div class="line"><a name="l01457"></a><span class="lineno"> 1457</span> </div><div class="line"><a name="l01460"></a><span class="lineno"><a class="line" href="group__policy.html#gaf19022acc5ef23cf12477f632b48a0b2"> 1460</a></span> <span class="preprocessor">#define PSA_KEY_USAGE_DERIVE ((psa_key_usage_t)0x00001000)</span></div><div class="line"><a name="l01461"></a><span class="lineno"> 1461</span> </div><div class="line"><a name="l01464"></a><span class="lineno"> 1464</span> <span class="preprocessor">#endif </span><span class="comment">/* PSA_CRYPTO_ENUM_H */</span><span class="preprocessor"></span></div><div class="ttc" id="group__crypto__types_html_ga4e8977c145cce5077c4bce7fec890ad9"><div class="ttname"><a href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a></div><div class="ttdeci">uint16_t psa_ecc_curve_t</div><div class="ttdef"><b>Definition:</b> crypto_enum.h:480</div></div>
-<div class="ttc" id="group__key__lifetimes_html_ga11e986351c65bd3dc3c0fe2cd9926e4b"><div class="ttname"><a href="group__key__lifetimes.html#ga11e986351c65bd3dc3c0fe2cd9926e4b">psa_key_id_t</a></div><div class="ttdeci">uint32_t psa_key_id_t</div><div class="ttdef"><b>Definition:</b> crypto_enum.h:1373</div></div>
-<div class="ttc" id="group__crypto__types_html_gac2e4d47f1300d73c2f829a6d99252d69"><div class="ttname"><a href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a></div><div class="ttdeci">uint32_t psa_algorithm_t</div><div class="ttdoc">Encoding of a cryptographic algorithm. </div><div class="ttdef"><b>Definition:</b> crypto_enum.h:557</div></div>
-<div class="ttc" id="group__policy_html_ga7bb9de71337e0e98de843aa7f9b55f25"><div class="ttname"><a href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a></div><div class="ttdeci">uint32_t psa_key_usage_t</div><div class="ttdoc">Encoding of permitted usage on a key. </div><div class="ttdef"><b>Definition:</b> crypto_enum.h:1401</div></div>
-<div class="ttc" id="group__crypto__types_html_ga578159487dfc7096cb191b0d2befe628"><div class="ttname"><a href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a></div><div class="ttdeci">uint32_t psa_key_type_t</div><div class="ttdoc">Encoding of a key type. </div><div class="ttdef"><b>Definition:</b> crypto_enum.h:315</div></div>
-<div class="ttc" id="group__key__lifetimes_html_ga6821ff6dd39dc2bc370ded760ad8b0cf"><div class="ttname"><a href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">psa_key_lifetime_t</a></div><div class="ttdeci">uint32_t psa_key_lifetime_t</div><div class="ttdef"><b>Definition:</b> crypto_enum.h:1369</div></div>
-<div class="ttc" id="group__error_html_ga05676e70ba5c6a7565aff3c36677c1f9"><div class="ttname"><a href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a></div><div class="ttdeci">int32_t psa_status_t</div><div class="ttdoc">Function return status. </div><div class="ttdef"><b>Definition:</b> crypto_enum.h:66</div></div>
-</div><!-- fragment --></div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/crypto__sizes_8h.html b/docs/html/crypto__sizes_8h.html
deleted file mode 100644
index e09d0f1..0000000
--- a/docs/html/crypto__sizes_8h.html
+++ /dev/null
@@ -1,710 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: psa/crypto_sizes.h File Reference</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li class="current"><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
- <div id="navrow2" class="tabs2">
- <ul class="tablist">
- <li><a href="files.html"><span>File List</span></a></li>
- <li><a href="globals.html"><span>File Members</span></a></li>
- </ul>
- </div>
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div id="nav-path" class="navpath">
- <ul>
-<li class="navelem"><a class="el" href="dir_7dae9cfde651cd3cb034485ce5e391b9.html">psa</a></li> </ul>
-</div>
-</div><!-- top -->
-<div class="header">
- <div class="summary">
-<a href="#define-members">Macros</a> </div>
- <div class="headertitle">
-<div class="title">crypto_sizes.h File Reference</div> </div>
-</div><!--header-->
-<div class="contents">
-
-<p>PSA cryptography module: Mbed TLS buffer size macros.
-<a href="#details">More...</a></p>
-<div class="textblock"><code>#include "../mbedtls/config.h"</code><br />
-</div><div class="textblock"><div class="dynheader">
-Include dependency graph for crypto_sizes.h:</div>
-<div class="dyncontent">
-<div class="center"><img src="crypto__sizes_8h__incl.png" border="0" usemap="#psa_2crypto__sizes_8h" alt=""/></div>
-</div>
-</div><div class="textblock"><div class="dynheader">
-This graph shows which files directly or indirectly include this file:</div>
-<div class="dyncontent">
-<div class="center"><img src="crypto__sizes_8h__dep__incl.png" border="0" usemap="#psa_2crypto__sizes_8hdep" alt=""/></div>
-<map name="psa_2crypto__sizes_8hdep" id="psa_2crypto__sizes_8hdep">
-<area shape="rect" id="node2" href="crypto_8h.html" title="Platform Security Architecture cryptography module. " alt="" coords="24,80,119,107"/>
-</map>
-</div>
-</div>
-<p><a href="crypto__sizes_8h_source.html">Go to the source code of this file.</a></p>
-<table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="define-members"></a>
-Macros</h2></td></tr>
-<tr class="memitem:af2edfe992db358f8eefd4bc82d069592"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="af2edfe992db358f8eefd4bc82d069592"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_BITS_TO_BYTES</b>(bits)   (((bits) + 7) / 8)</td></tr>
-<tr class="separator:af2edfe992db358f8eefd4bc82d069592"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:a997f71feb68cca794f7ed676600e06db"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a997f71feb68cca794f7ed676600e06db"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_BYTES_TO_BITS</b>(bytes)   ((bytes) * 8)</td></tr>
-<tr class="separator:a997f71feb68cca794f7ed676600e06db"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:aef340331ce3cba2b57e1fc5624bf1f99"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="crypto__sizes_8h.html#aef340331ce3cba2b57e1fc5624bf1f99">PSA_HASH_SIZE</a>(alg)</td></tr>
-<tr class="separator:aef340331ce3cba2b57e1fc5624bf1f99"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:a6ce1014efbbc0bcca286ef7f9a72cb29"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="crypto__sizes_8h.html#a6ce1014efbbc0bcca286ef7f9a72cb29">PSA_HASH_MAX_SIZE</a>   64</td></tr>
-<tr class="separator:a6ce1014efbbc0bcca286ef7f9a72cb29"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:a123539632874601194b1d86a398e14ff"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a123539632874601194b1d86a398e14ff"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_HMAC_MAX_HASH_BLOCK_SIZE</b>   128</td></tr>
-<tr class="separator:a123539632874601194b1d86a398e14ff"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:a4681cc4f6226883a2160122c562ca682"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="crypto__sizes_8h.html#a4681cc4f6226883a2160122c562ca682">PSA_MAC_MAX_SIZE</a>   <a class="el" href="crypto__sizes_8h.html#a6ce1014efbbc0bcca286ef7f9a72cb29">PSA_HASH_MAX_SIZE</a></td></tr>
-<tr class="separator:a4681cc4f6226883a2160122c562ca682"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:a8e3079b2e624cb8d32b94843cddada49"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="crypto__sizes_8h.html#a8e3079b2e624cb8d32b94843cddada49">PSA_AEAD_TAG_LENGTH</a>(alg)</td></tr>
-<tr class="separator:a8e3079b2e624cb8d32b94843cddada49"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:a2ab9324235c63e9e8cdee5bb1793eabe"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a2ab9324235c63e9e8cdee5bb1793eabe"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_VENDOR_RSA_MAX_KEY_BITS</b>   4096</td></tr>
-<tr class="separator:a2ab9324235c63e9e8cdee5bb1793eabe"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:a81080a6cbbab87f35b114cb991e3f550"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a81080a6cbbab87f35b114cb991e3f550"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_VENDOR_ECC_MAX_CURVE_BITS</b>   521</td></tr>
-<tr class="separator:a81080a6cbbab87f35b114cb991e3f550"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ab589ea3b86f2bfa18880459299c58f8a"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="crypto__sizes_8h.html#ab589ea3b86f2bfa18880459299c58f8a">PSA_ALG_TLS12_PSK_TO_MS_MAX_PSK_LEN</a>   128</td></tr>
-<tr class="separator:ab589ea3b86f2bfa18880459299c58f8a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ad755101764dba14589e5919ee41be7ca"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="crypto__sizes_8h.html#ad755101764dba14589e5919ee41be7ca">PSA_ASYMMETRIC_SIGNATURE_MAX_SIZE</a></td></tr>
-<tr class="separator:ad755101764dba14589e5919ee41be7ca"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:aa3cfcff0291d6da279fec8fe834d5dec"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="crypto__sizes_8h.html#aa3cfcff0291d6da279fec8fe834d5dec">PSA_MAX_BLOCK_CIPHER_BLOCK_SIZE</a>   16</td></tr>
-<tr class="separator:aa3cfcff0291d6da279fec8fe834d5dec"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:aa84c5fb384ac7cb1bfc52adde96588ee"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="crypto__sizes_8h.html#aa84c5fb384ac7cb1bfc52adde96588ee">PSA_MAC_FINAL_SIZE</a>(key_type, key_bits, alg)</td></tr>
-<tr class="separator:aa84c5fb384ac7cb1bfc52adde96588ee"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:a85667d47a7aa6c7b99a80e5273671266"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="crypto__sizes_8h.html#a85667d47a7aa6c7b99a80e5273671266">PSA_AEAD_ENCRYPT_OUTPUT_SIZE</a>(alg, plaintext_length)</td></tr>
-<tr class="separator:a85667d47a7aa6c7b99a80e5273671266"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ab097f6e054f1a73e975d597ade9029a6"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="crypto__sizes_8h.html#ab097f6e054f1a73e975d597ade9029a6">PSA_AEAD_FINISH_OUTPUT_SIZE</a>(alg)   ((size_t)0)</td></tr>
-<tr class="separator:ab097f6e054f1a73e975d597ade9029a6"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:a1d057796166c16eb673ad1997e48a60b"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="crypto__sizes_8h.html#a1d057796166c16eb673ad1997e48a60b">PSA_AEAD_DECRYPT_OUTPUT_SIZE</a>(alg, ciphertext_length)</td></tr>
-<tr class="separator:a1d057796166c16eb673ad1997e48a60b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:aec0bcba60e7514b83f967b171d494ed3"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><b>PSA_RSA_MINIMUM_PADDING_SIZE</b>(alg)</td></tr>
-<tr class="separator:aec0bcba60e7514b83f967b171d494ed3"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:a10c472a35f04051add6b20cc228ffc11"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="crypto__sizes_8h.html#a10c472a35f04051add6b20cc228ffc11">PSA_ECDSA_SIGNATURE_SIZE</a>(curve_bits)   (PSA_BITS_TO_BYTES(curve_bits) * 2)</td></tr>
-<tr class="memdesc:a10c472a35f04051add6b20cc228ffc11"><td class="mdescLeft"> </td><td class="mdescRight">ECDSA signature size for a given curve bit size. <a href="#a10c472a35f04051add6b20cc228ffc11">More...</a><br /></td></tr>
-<tr class="separator:a10c472a35f04051add6b20cc228ffc11"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:a77565b9b4fe6d8730fd2120f4c8378ab"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="crypto__sizes_8h.html#a77565b9b4fe6d8730fd2120f4c8378ab">PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE</a>(key_type, key_bits, alg)</td></tr>
-<tr class="separator:a77565b9b4fe6d8730fd2120f4c8378ab"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:a66ba3bd93e5ec52870ccc3848778bad8"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="crypto__sizes_8h.html#a66ba3bd93e5ec52870ccc3848778bad8">PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE</a>(key_type, key_bits, alg)</td></tr>
-<tr class="separator:a66ba3bd93e5ec52870ccc3848778bad8"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:a61a246f3eac41989821d982e56fea6c1"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="crypto__sizes_8h.html#a61a246f3eac41989821d982e56fea6c1">PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE</a>(key_type, key_bits, alg)</td></tr>
-<tr class="separator:a61a246f3eac41989821d982e56fea6c1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:a6a30ddc479486f4c5db1c759c3d052c2"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a6a30ddc479486f4c5db1c759c3d052c2"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE</b>(bits)   ((bits) / 8 + 5)</td></tr>
-<tr class="separator:a6a30ddc479486f4c5db1c759c3d052c2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:a0fffdb6216268eb6455cc83a854c8acf"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a0fffdb6216268eb6455cc83a854c8acf"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_EXPORT_RSA_PUBLIC_KEY_MAX_SIZE</b>(key_bits)   (PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE(key_bits) + 36)</td></tr>
-<tr class="separator:a0fffdb6216268eb6455cc83a854c8acf"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:a590f9d3da465c0422d7ba60ac2e9d98d"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a590f9d3da465c0422d7ba60ac2e9d98d"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_EXPORT_RSA_KEYPAIR_MAX_SIZE</b>(key_bits)   (9 * PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE((key_bits) / 2 + 1) + 14)</td></tr>
-<tr class="separator:a590f9d3da465c0422d7ba60ac2e9d98d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:aaee3efce949efb49d0d13110051ad2a0"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="aaee3efce949efb49d0d13110051ad2a0"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_EXPORT_DSA_PUBLIC_KEY_MAX_SIZE</b>(key_bits)   (PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE(key_bits) * 3 + 59)</td></tr>
-<tr class="separator:aaee3efce949efb49d0d13110051ad2a0"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:aee0cfc7f7b7b80374a0d7b03c9b91e01"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="aee0cfc7f7b7b80374a0d7b03c9b91e01"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_EXPORT_DSA_KEYPAIR_MAX_SIZE</b>(key_bits)   (PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE(key_bits) * 3 + 75)</td></tr>
-<tr class="separator:aee0cfc7f7b7b80374a0d7b03c9b91e01"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:a221b29f08b4e5e0509a1c7cc11b623d0"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a221b29f08b4e5e0509a1c7cc11b623d0"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE</b>(key_bits)   (2 * PSA_BITS_TO_BYTES(key_bits) + 36)</td></tr>
-<tr class="separator:a221b29f08b4e5e0509a1c7cc11b623d0"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ae105bb3d5a09d323eb3e457d26bddd04"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ae105bb3d5a09d323eb3e457d26bddd04"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_EXPORT_ECC_KEYPAIR_MAX_SIZE</b>(key_bits)   (PSA_BITS_TO_BYTES(key_bits))</td></tr>
-<tr class="separator:ae105bb3d5a09d323eb3e457d26bddd04"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:a0aae885cc8ff92e00fb5248420b939c3"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="crypto__sizes_8h.html#a0aae885cc8ff92e00fb5248420b939c3">PSA_KEY_EXPORT_MAX_SIZE</a>(key_type, key_bits)</td></tr>
-<tr class="separator:a0aae885cc8ff92e00fb5248420b939c3"><td class="memSeparator" colspan="2"> </td></tr>
-</table>
-<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
-<div class="textblock"><p>PSA cryptography module: Mbed TLS buffer size macros. </p>
-<dl class="section note"><dt>Note</dt><dd>This file may not be included directly. Applications must include <a class="el" href="crypto_8h.html" title="Platform Security Architecture cryptography module. ">psa/crypto.h</a>.</dd></dl>
-<p>This file contains the definitions of macros that are useful to compute buffer sizes. The signatures and semantics of these macros are standardized, but the definitions are not, because they depend on the available algorithms and, in some cases, on permitted tolerances on buffer sizes.</p>
-<p>In implementations with isolation between the application and the cryptography module, implementers should take care to ensure that the definitions that are exposed to applications match what the module implements.</p>
-<p>Macros that compute sizes whose values do not depend on the implementation are in <a class="el" href="crypto_8h.html" title="Platform Security Architecture cryptography module. ">crypto.h</a>. </p>
-</div><h2 class="groupheader">Macro Definition Documentation</h2>
-<a class="anchor" id="a1d057796166c16eb673ad1997e48a60b"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_AEAD_DECRYPT_OUTPUT_SIZE</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"> </td>
- <td class="paramname">ciphertext_length </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">(<a class="code" href="crypto__sizes_8h.html#a8e3079b2e624cb8d32b94843cddada49">PSA_AEAD_TAG_LENGTH</a>(alg) != 0 ? \</div><div class="line"> (plaintext_length) - <a class="code" href="crypto__sizes_8h.html#a8e3079b2e624cb8d32b94843cddada49">PSA_AEAD_TAG_LENGTH</a>(alg) : \</div><div class="line"> 0)</div><div class="ttc" id="crypto__sizes_8h_html_a8e3079b2e624cb8d32b94843cddada49"><div class="ttname"><a href="crypto__sizes_8h.html#a8e3079b2e624cb8d32b94843cddada49">PSA_AEAD_TAG_LENGTH</a></div><div class="ttdeci">#define PSA_AEAD_TAG_LENGTH(alg)</div><div class="ttdef"><b>Definition:</b> crypto_sizes.h:138</div></div>
-</div><!-- fragment --><p>The maximum size of the output of <a class="el" href="group__aead.html#gaa8ce6527f2e227f1071fadbf2099793b">psa_aead_decrypt()</a>, in bytes.</p>
-<p>If the size of the plaintext buffer is at least this large, it is guaranteed that <a class="el" href="group__aead.html#gaa8ce6527f2e227f1071fadbf2099793b">psa_aead_decrypt()</a> will not fail due to an insufficient buffer size. Depending on the algorithm, the actual size of the plaintext may be smaller.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>An AEAD algorithm (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#ga1d44829d60065eaa4ac9a703e7d6abc8">PSA_ALG_IS_AEAD</a>(<code>alg</code>) is true). </td></tr>
- <tr><td class="paramname">ciphertext_length</td><td>Size of the plaintext in bytes.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>The AEAD ciphertext size for the specified algorithm. If the AEAD algorithm is not recognized, return 0. An implementation may return either 0 or a correct size for an AEAD algorithm that it recognizes, but does not support. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="a85667d47a7aa6c7b99a80e5273671266"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_AEAD_ENCRYPT_OUTPUT_SIZE</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"> </td>
- <td class="paramname">plaintext_length </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">(<a class="code" href="crypto__sizes_8h.html#a8e3079b2e624cb8d32b94843cddada49">PSA_AEAD_TAG_LENGTH</a>(alg) != 0 ? \</div><div class="line"> (plaintext_length) + <a class="code" href="crypto__sizes_8h.html#a8e3079b2e624cb8d32b94843cddada49">PSA_AEAD_TAG_LENGTH</a>(alg) : \</div><div class="line"> 0)</div><div class="ttc" id="crypto__sizes_8h_html_a8e3079b2e624cb8d32b94843cddada49"><div class="ttname"><a href="crypto__sizes_8h.html#a8e3079b2e624cb8d32b94843cddada49">PSA_AEAD_TAG_LENGTH</a></div><div class="ttdeci">#define PSA_AEAD_TAG_LENGTH(alg)</div><div class="ttdef"><b>Definition:</b> crypto_sizes.h:138</div></div>
-</div><!-- fragment --><p>The maximum size of the output of <a class="el" href="group__aead.html#ga44de092cf58bb6c820c5c80a6c51610d">psa_aead_encrypt()</a>, in bytes.</p>
-<p>If the size of the ciphertext buffer is at least this large, it is guaranteed that <a class="el" href="group__aead.html#ga44de092cf58bb6c820c5c80a6c51610d">psa_aead_encrypt()</a> will not fail due to an insufficient buffer size. Depending on the algorithm, the actual size of the ciphertext may be smaller.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>An AEAD algorithm (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#ga1d44829d60065eaa4ac9a703e7d6abc8">PSA_ALG_IS_AEAD</a>(<code>alg</code>) is true). </td></tr>
- <tr><td class="paramname">plaintext_length</td><td>Size of the plaintext in bytes.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>The AEAD ciphertext size for the specified algorithm. If the AEAD algorithm is not recognized, return 0. An implementation may return either 0 or a correct size for an AEAD algorithm that it recognizes, but does not support. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="ab097f6e054f1a73e975d597ade9029a6"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_AEAD_FINISH_OUTPUT_SIZE</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td>   ((size_t)0)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The maximum size of the output of <a class="el" href="group__aead.html#ga759791bbe1763b377c3b5447641f1fc8">psa_aead_finish()</a>, in bytes.</p>
-<p>If the size of the ciphertext buffer is at least this large, it is guaranteed that <a class="el" href="group__aead.html#ga759791bbe1763b377c3b5447641f1fc8">psa_aead_finish()</a> will not fail due to an insufficient buffer size. Depending on the algorithm, the actual size of the ciphertext may be smaller.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>An AEAD algorithm (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#ga1d44829d60065eaa4ac9a703e7d6abc8">PSA_ALG_IS_AEAD</a>(<code>alg</code>) is true).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>The maximum trailing ciphertext size for the specified algorithm. If the AEAD algorithm is not recognized, return 0. An implementation may return either 0 or a correct size for an AEAD algorithm that it recognizes, but does not support. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="a8e3079b2e624cb8d32b94843cddada49"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_AEAD_TAG_LENGTH</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">(<a class="code" href="group__crypto__types.html#ga1d44829d60065eaa4ac9a703e7d6abc8">PSA_ALG_IS_AEAD</a>(alg) ? \</div><div class="line"> (((alg) & PSA_ALG_AEAD_TAG_LENGTH_MASK) >> PSA_AEAD_TAG_LENGTH_OFFSET) : \</div><div class="line"> 0)</div><div class="ttc" id="group__crypto__types_html_ga1d44829d60065eaa4ac9a703e7d6abc8"><div class="ttname"><a href="group__crypto__types.html#ga1d44829d60065eaa4ac9a703e7d6abc8">PSA_ALG_IS_AEAD</a></div><div class="ttdeci">#define PSA_ALG_IS_AEAD(alg)</div><div class="ttdef"><b>Definition:</b> crypto_values.h:591</div></div>
-</div><!-- fragment --><p>The tag size for an AEAD algorithm, in bytes.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>An AEAD algorithm (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#ga1d44829d60065eaa4ac9a703e7d6abc8">PSA_ALG_IS_AEAD</a>(<code>alg</code>) is true).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>The tag size for the specified algorithm. If the AEAD algorithm does not have an identified tag that can be distinguished from the rest of the ciphertext, return 0. If the AEAD algorithm is not recognized, return 0. An implementation may return either 0 or a correct size for an AEAD algorithm that it recognizes, but does not support. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="ab589ea3b86f2bfa18880459299c58f8a"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_TLS12_PSK_TO_MS_MAX_PSK_LEN   128</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>This macro returns the maximum length of the PSK supported by the TLS-1.2 PSK-to-MS key derivation.</p>
-<p>Quoting RFC 4279, Sect 5.3: TLS implementations supporting these ciphersuites MUST support arbitrary PSK identities up to 128 octets in length, and arbitrary PSKs up to 64 octets in length. Supporting longer identities and keys is RECOMMENDED.</p>
-<p>Therefore, no implementation should define a value smaller than 64 for <a class="el" href="crypto__sizes_8h.html#ab589ea3b86f2bfa18880459299c58f8a">PSA_ALG_TLS12_PSK_TO_MS_MAX_PSK_LEN</a>. </p>
-
-</div>
-</div>
-<a class="anchor" id="a61a246f3eac41989821d982e56fea6c1"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">key_type, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"> </td>
- <td class="paramname">key_bits, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"> </td>
- <td class="paramname">alg </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">(<a class="code" href="group__crypto__types.html#ga0e1d8f241228e49c9cadadfb4579ef1a">PSA_KEY_TYPE_IS_RSA</a>(key_type) ? \</div><div class="line"> PSA_BITS_TO_BYTES(key_bits) - PSA_RSA_MINIMUM_PADDING_SIZE(alg) : \</div><div class="line"> 0)</div><div class="ttc" id="group__crypto__types_html_ga0e1d8f241228e49c9cadadfb4579ef1a"><div class="ttname"><a href="group__crypto__types.html#ga0e1d8f241228e49c9cadadfb4579ef1a">PSA_KEY_TYPE_IS_RSA</a></div><div class="ttdeci">#define PSA_KEY_TYPE_IS_RSA(type)</div><div class="ttdef"><b>Definition:</b> crypto_values.h:424</div></div>
-</div><!-- fragment --><p>Safe output buffer size for <a class="el" href="group__asymmetric.html#ga34b55fbaee23dba1a677186fc66a556e" title="Decrypt a short message with a private key. ">psa_asymmetric_decrypt()</a>.</p>
-<p>This macro returns a safe buffer size for a ciphertext produced using a key of the specified type and size, with the specified algorithm. Note that the actual size of the ciphertext may be smaller, depending on the algorithm.</p>
-<dl class="section warning"><dt>Warning</dt><dd>This function may call its arguments multiple times or zero times, so you should not pass arguments that contain side effects.</dd></dl>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">key_type</td><td>An asymmetric key type (this may indifferently be a key pair type or a public key type). </td></tr>
- <tr><td class="paramname">key_bits</td><td>The size of the key in bits. </td></tr>
- <tr><td class="paramname">alg</td><td>The signature algorithm.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>If the parameters are valid and supported, return a buffer size in bytes that guarantees that <a class="el" href="group__asymmetric.html#ga34b55fbaee23dba1a677186fc66a556e" title="Decrypt a short message with a private key. ">psa_asymmetric_decrypt()</a> will not fail with <a class="el" href="group__error.html#ga695025f4ec11249aee7ea3d0f65e01c8">PSA_ERROR_BUFFER_TOO_SMALL</a>. If the parameters are a valid combination that is not supported by the implementation, this macro either shall return either a sensible size or 0. If the parameters are not valid, the return value is unspecified. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="a66ba3bd93e5ec52870ccc3848778bad8"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">key_type, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"> </td>
- <td class="paramname">key_bits, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"> </td>
- <td class="paramname">alg </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">(<a class="code" href="group__crypto__types.html#ga0e1d8f241228e49c9cadadfb4579ef1a">PSA_KEY_TYPE_IS_RSA</a>(key_type) ? \</div><div class="line"> ((void)alg, PSA_BITS_TO_BYTES(key_bits)) : \</div><div class="line"> 0)</div><div class="ttc" id="group__crypto__types_html_ga0e1d8f241228e49c9cadadfb4579ef1a"><div class="ttname"><a href="group__crypto__types.html#ga0e1d8f241228e49c9cadadfb4579ef1a">PSA_KEY_TYPE_IS_RSA</a></div><div class="ttdeci">#define PSA_KEY_TYPE_IS_RSA(type)</div><div class="ttdef"><b>Definition:</b> crypto_values.h:424</div></div>
-</div><!-- fragment --><p>Safe output buffer size for <a class="el" href="group__asymmetric.html#gad429293b7b0bf2a830b9540a02552004" title="Encrypt a short message with a public key. ">psa_asymmetric_encrypt()</a>.</p>
-<p>This macro returns a safe buffer size for a ciphertext produced using a key of the specified type and size, with the specified algorithm. Note that the actual size of the ciphertext may be smaller, depending on the algorithm.</p>
-<dl class="section warning"><dt>Warning</dt><dd>This function may call its arguments multiple times or zero times, so you should not pass arguments that contain side effects.</dd></dl>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">key_type</td><td>An asymmetric key type (this may indifferently be a key pair type or a public key type). </td></tr>
- <tr><td class="paramname">key_bits</td><td>The size of the key in bits. </td></tr>
- <tr><td class="paramname">alg</td><td>The signature algorithm.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>If the parameters are valid and supported, return a buffer size in bytes that guarantees that <a class="el" href="group__asymmetric.html#gad429293b7b0bf2a830b9540a02552004" title="Encrypt a short message with a public key. ">psa_asymmetric_encrypt()</a> will not fail with <a class="el" href="group__error.html#ga695025f4ec11249aee7ea3d0f65e01c8">PSA_ERROR_BUFFER_TOO_SMALL</a>. If the parameters are a valid combination that is not supported by the implementation, this macro either shall return either a sensible size or 0. If the parameters are not valid, the return value is unspecified. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="a77565b9b4fe6d8730fd2120f4c8378ab"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">key_type, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"> </td>
- <td class="paramname">key_bits, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"> </td>
- <td class="paramname">alg </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">(<a class="code" href="group__crypto__types.html#ga0e1d8f241228e49c9cadadfb4579ef1a">PSA_KEY_TYPE_IS_RSA</a>(key_type) ? ((void)alg, PSA_BITS_TO_BYTES(key_bits)) : \</div><div class="line"> <a class="code" href="group__crypto__types.html#ga88e01fa06b585654689a99bcc06bbe66">PSA_KEY_TYPE_IS_ECC</a>(key_type) ? <a class="code" href="crypto__sizes_8h.html#a10c472a35f04051add6b20cc228ffc11">PSA_ECDSA_SIGNATURE_SIZE</a>(key_bits) : \</div><div class="line"> ((void)alg, 0))</div><div class="ttc" id="group__crypto__types_html_ga0e1d8f241228e49c9cadadfb4579ef1a"><div class="ttname"><a href="group__crypto__types.html#ga0e1d8f241228e49c9cadadfb4579ef1a">PSA_KEY_TYPE_IS_RSA</a></div><div class="ttdeci">#define PSA_KEY_TYPE_IS_RSA(type)</div><div class="ttdef"><b>Definition:</b> crypto_values.h:424</div></div>
-<div class="ttc" id="crypto__sizes_8h_html_a10c472a35f04051add6b20cc228ffc11"><div class="ttname"><a href="crypto__sizes_8h.html#a10c472a35f04051add6b20cc228ffc11">PSA_ECDSA_SIGNATURE_SIZE</a></div><div class="ttdeci">#define PSA_ECDSA_SIGNATURE_SIZE(curve_bits)</div><div class="ttdoc">ECDSA signature size for a given curve bit size. </div><div class="ttdef"><b>Definition:</b> crypto_sizes.h:329</div></div>
-<div class="ttc" id="group__crypto__types_html_ga88e01fa06b585654689a99bcc06bbe66"><div class="ttname"><a href="group__crypto__types.html#ga88e01fa06b585654689a99bcc06bbe66">PSA_KEY_TYPE_IS_ECC</a></div><div class="ttdeci">#define PSA_KEY_TYPE_IS_ECC(type)</div><div class="ttdef"><b>Definition:</b> crypto_values.h:446</div></div>
-</div><!-- fragment --><p>Safe signature buffer size for <a class="el" href="group__asymmetric.html#ga1b0db9d345b5048cdd39357ac2d56c07" title="Sign a hash or short message with a private key. ">psa_asymmetric_sign()</a>.</p>
-<p>This macro returns a safe buffer size for a signature using a key of the specified type and size, with the specified algorithm. Note that the actual size of the signature may be smaller (some algorithms produce a variable-size signature).</p>
-<dl class="section warning"><dt>Warning</dt><dd>This function may call its arguments multiple times or zero times, so you should not pass arguments that contain side effects.</dd></dl>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">key_type</td><td>An asymmetric key type (this may indifferently be a key pair type or a public key type). </td></tr>
- <tr><td class="paramname">key_bits</td><td>The size of the key in bits. </td></tr>
- <tr><td class="paramname">alg</td><td>The signature algorithm.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>If the parameters are valid and supported, return a buffer size in bytes that guarantees that <a class="el" href="group__asymmetric.html#ga1b0db9d345b5048cdd39357ac2d56c07" title="Sign a hash or short message with a private key. ">psa_asymmetric_sign()</a> will not fail with <a class="el" href="group__error.html#ga695025f4ec11249aee7ea3d0f65e01c8">PSA_ERROR_BUFFER_TOO_SMALL</a>. If the parameters are a valid combination that is not supported by the implementation, this macro either shall return either a sensible size or 0. If the parameters are not valid, the return value is unspecified. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="ad755101764dba14589e5919ee41be7ca"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ASYMMETRIC_SIGNATURE_MAX_SIZE</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">PSA_BITS_TO_BYTES( \</div><div class="line"> PSA_VENDOR_RSA_MAX_KEY_BITS > PSA_VENDOR_ECC_MAX_CURVE_BITS ? \</div><div class="line"> PSA_VENDOR_RSA_MAX_KEY_BITS : \</div><div class="line"> PSA_VENDOR_ECC_MAX_CURVE_BITS \</div><div class="line"> )</div></div><!-- fragment --><p>Maximum size of an asymmetric signature.</p>
-<p>This macro must expand to a compile-time constant integer. This value should be the maximum size of a MAC supported by the implementation, in bytes, and must be no smaller than this maximum. </p>
-
-</div>
-</div>
-<a class="anchor" id="a10c472a35f04051add6b20cc228ffc11"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ECDSA_SIGNATURE_SIZE</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">curve_bits</td><td>)</td>
- <td>   (PSA_BITS_TO_BYTES(curve_bits) * 2)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-
-<p>ECDSA signature size for a given curve bit size. </p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">curve_bits</td><td>Curve size in bits. </td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>Signature size in bytes.</dd></dl>
-<dl class="section note"><dt>Note</dt><dd>This macro returns a compile-time constant if its argument is one. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="a6ce1014efbbc0bcca286ef7f9a72cb29"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_HASH_MAX_SIZE   64</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Maximum size of a hash.</p>
-<p>This macro must expand to a compile-time constant integer. This value should be the maximum size of a hash supported by the implementation, in bytes, and must be no smaller than this maximum. </p>
-
-</div>
-</div>
-<a class="anchor" id="aef340331ce3cba2b57e1fc5624bf1f99"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_HASH_SIZE</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">( \</div><div class="line"> PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_MD2 ? 16 : \</div><div class="line"> PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_MD4 ? 16 : \</div><div class="line"> PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_MD5 ? 16 : \</div><div class="line"> PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_RIPEMD160 ? 20 : \</div><div class="line"> PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_1 ? 20 : \</div><div class="line"> PSA_ALG_HMAC_GET_HASH(alg) == <a class="code" href="group__crypto__types.html#ga25d6a3244d10a7148fe6b026d1979f7b">PSA_ALG_SHA_224</a> ? 28 : \</div><div class="line"> PSA_ALG_HMAC_GET_HASH(alg) == <a class="code" href="group__crypto__types.html#ga619471f978e13cdd0a1e37145e4bf341">PSA_ALG_SHA_256</a> ? 32 : \</div><div class="line"> PSA_ALG_HMAC_GET_HASH(alg) == <a class="code" href="group__crypto__types.html#ga58af64dd9a86a287e8da9ed7739eead4">PSA_ALG_SHA_384</a> ? 48 : \</div><div class="line"> PSA_ALG_HMAC_GET_HASH(alg) == <a class="code" href="group__crypto__types.html#gafba3ae409f46d3dd7f37a0910660c3e9">PSA_ALG_SHA_512</a> ? 64 : \</div><div class="line"> PSA_ALG_HMAC_GET_HASH(alg) == <a class="code" href="group__crypto__types.html#ga3fe2d7c3c80e3186ca78d16a35d5d931">PSA_ALG_SHA_512_224</a> ? 28 : \</div><div class="line"> PSA_ALG_HMAC_GET_HASH(alg) == <a class="code" href="group__crypto__types.html#ga5910b3964c14e9613e8643a45b09c2d4">PSA_ALG_SHA_512_256</a> ? 32 : \</div><div class="line"> PSA_ALG_HMAC_GET_HASH(alg) == <a class="code" href="group__crypto__types.html#ga16f5fe34ccce68c2fada1224c054a999">PSA_ALG_SHA3_224</a> ? 28 : \</div><div class="line"> PSA_ALG_HMAC_GET_HASH(alg) == <a class="code" href="group__crypto__types.html#gaace70d9515489bbe3c5e7ac1b7d9155b">PSA_ALG_SHA3_256</a> ? 32 : \</div><div class="line"> PSA_ALG_HMAC_GET_HASH(alg) == <a class="code" href="group__crypto__types.html#gab0f079257ea75e2acfe2fc3b38c78cd8">PSA_ALG_SHA3_384</a> ? 48 : \</div><div class="line"> PSA_ALG_HMAC_GET_HASH(alg) == <a class="code" href="group__crypto__types.html#ga37e5dbe936dddb155e76f2997de27188">PSA_ALG_SHA3_512</a> ? 64 : \</div><div class="line"> 0)</div><div class="ttc" id="group__crypto__types_html_gaace70d9515489bbe3c5e7ac1b7d9155b"><div class="ttname"><a href="group__crypto__types.html#gaace70d9515489bbe3c5e7ac1b7d9155b">PSA_ALG_SHA3_256</a></div><div class="ttdeci">#define PSA_ALG_SHA3_256</div><div class="ttdef"><b>Definition:</b> crypto_values.h:660</div></div>
-<div class="ttc" id="group__crypto__types_html_ga16f5fe34ccce68c2fada1224c054a999"><div class="ttname"><a href="group__crypto__types.html#ga16f5fe34ccce68c2fada1224c054a999">PSA_ALG_SHA3_224</a></div><div class="ttdeci">#define PSA_ALG_SHA3_224</div><div class="ttdef"><b>Definition:</b> crypto_values.h:658</div></div>
-<div class="ttc" id="group__crypto__types_html_ga37e5dbe936dddb155e76f2997de27188"><div class="ttname"><a href="group__crypto__types.html#ga37e5dbe936dddb155e76f2997de27188">PSA_ALG_SHA3_512</a></div><div class="ttdeci">#define PSA_ALG_SHA3_512</div><div class="ttdef"><b>Definition:</b> crypto_values.h:664</div></div>
-<div class="ttc" id="group__crypto__types_html_ga619471f978e13cdd0a1e37145e4bf341"><div class="ttname"><a href="group__crypto__types.html#ga619471f978e13cdd0a1e37145e4bf341">PSA_ALG_SHA_256</a></div><div class="ttdeci">#define PSA_ALG_SHA_256</div><div class="ttdef"><b>Definition:</b> crypto_values.h:648</div></div>
-<div class="ttc" id="group__crypto__types_html_gafba3ae409f46d3dd7f37a0910660c3e9"><div class="ttname"><a href="group__crypto__types.html#gafba3ae409f46d3dd7f37a0910660c3e9">PSA_ALG_SHA_512</a></div><div class="ttdeci">#define PSA_ALG_SHA_512</div><div class="ttdef"><b>Definition:</b> crypto_values.h:652</div></div>
-<div class="ttc" id="group__crypto__types_html_ga25d6a3244d10a7148fe6b026d1979f7b"><div class="ttname"><a href="group__crypto__types.html#ga25d6a3244d10a7148fe6b026d1979f7b">PSA_ALG_SHA_224</a></div><div class="ttdeci">#define PSA_ALG_SHA_224</div><div class="ttdef"><b>Definition:</b> crypto_values.h:646</div></div>
-<div class="ttc" id="group__crypto__types_html_ga58af64dd9a86a287e8da9ed7739eead4"><div class="ttname"><a href="group__crypto__types.html#ga58af64dd9a86a287e8da9ed7739eead4">PSA_ALG_SHA_384</a></div><div class="ttdeci">#define PSA_ALG_SHA_384</div><div class="ttdef"><b>Definition:</b> crypto_values.h:650</div></div>
-<div class="ttc" id="group__crypto__types_html_ga3fe2d7c3c80e3186ca78d16a35d5d931"><div class="ttname"><a href="group__crypto__types.html#ga3fe2d7c3c80e3186ca78d16a35d5d931">PSA_ALG_SHA_512_224</a></div><div class="ttdeci">#define PSA_ALG_SHA_512_224</div><div class="ttdef"><b>Definition:</b> crypto_values.h:654</div></div>
-<div class="ttc" id="group__crypto__types_html_ga5910b3964c14e9613e8643a45b09c2d4"><div class="ttname"><a href="group__crypto__types.html#ga5910b3964c14e9613e8643a45b09c2d4">PSA_ALG_SHA_512_256</a></div><div class="ttdeci">#define PSA_ALG_SHA_512_256</div><div class="ttdef"><b>Definition:</b> crypto_values.h:656</div></div>
-<div class="ttc" id="group__crypto__types_html_gab0f079257ea75e2acfe2fc3b38c78cd8"><div class="ttname"><a href="group__crypto__types.html#gab0f079257ea75e2acfe2fc3b38c78cd8">PSA_ALG_SHA3_384</a></div><div class="ttdeci">#define PSA_ALG_SHA3_384</div><div class="ttdef"><b>Definition:</b> crypto_values.h:662</div></div>
-</div><!-- fragment --><p>The size of the output of <a class="el" href="group__hash.html#ga4795fd06a0067b0adcd92e9627b8c97e">psa_hash_finish()</a>, in bytes.</p>
-<p>This is also the hash size that <a class="el" href="group__hash.html#ga7be923c5700c9c70ef77ee9b76d1a5c0">psa_hash_verify()</a> expects.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>A hash algorithm (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#gac9280662bb482590b4b33d1dcd32930f">PSA_ALG_IS_HASH</a>(<code>alg</code>) is true), or an HMAC algorithm (<a class="el" href="group__crypto__types.html#ga70f397425684b3efcde1e0e34c28261f">PSA_ALG_HMAC</a>(<code>hash_alg</code>) where <code>hash_alg</code> is a hash algorithm).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>The hash size for the specified hash algorithm. If the hash algorithm is not recognized, return 0. An implementation may return either 0 or the correct size for a hash algorithm that it recognizes, but does not support. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="a0aae885cc8ff92e00fb5248420b939c3"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_EXPORT_MAX_SIZE</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">key_type, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"> </td>
- <td class="paramname">key_bits </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">(<a class="code" href="group__crypto__types.html#gaef86ce4e810e1c2c76068ac874bfef54">PSA_KEY_TYPE_IS_UNSTRUCTURED</a>(key_type) ? PSA_BITS_TO_BYTES(key_bits) : \</div><div class="line"> (key_type) == <a class="code" href="group__crypto__types.html#ga581f50687f5d650456925278948f2799">PSA_KEY_TYPE_RSA_KEYPAIR</a> ? PSA_KEY_EXPORT_RSA_KEYPAIR_MAX_SIZE(key_bits) : \</div><div class="line"> (key_type) == <a class="code" href="group__crypto__types.html#ga9ba0878f56c8bcd1995ac017a74f513b">PSA_KEY_TYPE_RSA_PUBLIC_KEY</a> ? PSA_KEY_EXPORT_RSA_PUBLIC_KEY_MAX_SIZE(key_bits) : \</div><div class="line"> (key_type) == <a class="code" href="group__crypto__types.html#ga011010ee28c20388f3d89fb27088ed62">PSA_KEY_TYPE_DSA_KEYPAIR</a> ? PSA_KEY_EXPORT_DSA_KEYPAIR_MAX_SIZE(key_bits) : \</div><div class="line"> (key_type) == <a class="code" href="group__crypto__types.html#ga5e7439c2905136366c3a876e62e5ddfc">PSA_KEY_TYPE_DSA_PUBLIC_KEY</a> ? PSA_KEY_EXPORT_DSA_PUBLIC_KEY_MAX_SIZE(key_bits) : \</div><div class="line"> <a class="code" href="group__crypto__types.html#ga7bf101b671e8cf26f4cb08fcb679db4b">PSA_KEY_TYPE_IS_ECC_KEYPAIR</a>(key_type) ? PSA_KEY_EXPORT_ECC_KEYPAIR_MAX_SIZE(key_bits) : \</div><div class="line"> <a class="code" href="group__crypto__types.html#ga5af146a173b0c84d7e737e2fb6a3c0a7">PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY</a>(key_type) ? PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE(key_bits) : \</div><div class="line"> 0)</div><div class="ttc" id="group__crypto__types_html_ga5e7439c2905136366c3a876e62e5ddfc"><div class="ttname"><a href="group__crypto__types.html#ga5e7439c2905136366c3a876e62e5ddfc">PSA_KEY_TYPE_DSA_PUBLIC_KEY</a></div><div class="ttdeci">#define PSA_KEY_TYPE_DSA_PUBLIC_KEY</div><div class="ttdef"><b>Definition:</b> crypto_values.h:428</div></div>
-<div class="ttc" id="group__crypto__types_html_ga581f50687f5d650456925278948f2799"><div class="ttname"><a href="group__crypto__types.html#ga581f50687f5d650456925278948f2799">PSA_KEY_TYPE_RSA_KEYPAIR</a></div><div class="ttdeci">#define PSA_KEY_TYPE_RSA_KEYPAIR</div><div class="ttdef"><b>Definition:</b> crypto_values.h:422</div></div>
-<div class="ttc" id="group__crypto__types_html_gaef86ce4e810e1c2c76068ac874bfef54"><div class="ttname"><a href="group__crypto__types.html#gaef86ce4e810e1c2c76068ac874bfef54">PSA_KEY_TYPE_IS_UNSTRUCTURED</a></div><div class="ttdeci">#define PSA_KEY_TYPE_IS_UNSTRUCTURED(type)</div><div class="ttdef"><b>Definition:</b> crypto_values.h:327</div></div>
-<div class="ttc" id="group__crypto__types_html_ga9ba0878f56c8bcd1995ac017a74f513b"><div class="ttname"><a href="group__crypto__types.html#ga9ba0878f56c8bcd1995ac017a74f513b">PSA_KEY_TYPE_RSA_PUBLIC_KEY</a></div><div class="ttdeci">#define PSA_KEY_TYPE_RSA_PUBLIC_KEY</div><div class="ttdef"><b>Definition:</b> crypto_values.h:420</div></div>
-<div class="ttc" id="group__crypto__types_html_ga011010ee28c20388f3d89fb27088ed62"><div class="ttname"><a href="group__crypto__types.html#ga011010ee28c20388f3d89fb27088ed62">PSA_KEY_TYPE_DSA_KEYPAIR</a></div><div class="ttdeci">#define PSA_KEY_TYPE_DSA_KEYPAIR</div><div class="ttdef"><b>Definition:</b> crypto_values.h:430</div></div>
-<div class="ttc" id="group__crypto__types_html_ga5af146a173b0c84d7e737e2fb6a3c0a7"><div class="ttname"><a href="group__crypto__types.html#ga5af146a173b0c84d7e737e2fb6a3c0a7">PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY</a></div><div class="ttdeci">#define PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY(type)</div><div class="ttdef"><b>Definition:</b> crypto_values.h:454</div></div>
-<div class="ttc" id="group__crypto__types_html_ga7bf101b671e8cf26f4cb08fcb679db4b"><div class="ttname"><a href="group__crypto__types.html#ga7bf101b671e8cf26f4cb08fcb679db4b">PSA_KEY_TYPE_IS_ECC_KEYPAIR</a></div><div class="ttdeci">#define PSA_KEY_TYPE_IS_ECC_KEYPAIR(type)</div><div class="ttdef"><b>Definition:</b> crypto_values.h:450</div></div>
-</div><!-- fragment --><p>Safe output buffer size for <a class="el" href="group__import__export.html#ga902b9a7a6cf34d6111668be777b05eaf" title="Export a key in binary format. ">psa_export_key()</a> or <a class="el" href="group__import__export.html#gad760d1f0d4e60972c78cbb4c8a528256" title="Export a public key or the public part of a key pair in binary format. ">psa_export_public_key()</a>.</p>
-<p>This macro returns a compile-time constant if its arguments are compile-time constants.</p>
-<dl class="section warning"><dt>Warning</dt><dd>This function may call its arguments multiple times or zero times, so you should not pass arguments that contain side effects.</dd></dl>
-<p>The following code illustrates how to allocate enough memory to export a key by querying the key type and size at runtime. </p><div class="fragment"><div class="line"><a class="code" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a> key_type;</div><div class="line"><span class="keywordtype">size_t</span> key_bits;</div><div class="line"><a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> status;</div><div class="line">status = <a class="code" href="group__import__export.html#gae8939902d6977ea8ad13eb7b4db9a042">psa_get_key_information</a>(key, &key_type, &key_bits);</div><div class="line"><span class="keywordflow">if</span> (status != <a class="code" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a>) handle_error(...);</div><div class="line"><span class="keywordtype">size_t</span> buffer_size = <a class="code" href="crypto__sizes_8h.html#a0aae885cc8ff92e00fb5248420b939c3">PSA_KEY_EXPORT_MAX_SIZE</a>(key_type, key_bits);</div><div class="line"><span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> *buffer = malloc(buffer_size);</div><div class="line"><span class="keywordflow">if</span> (buffer != NULL) handle_error(...);</div><div class="line"><span class="keywordtype">size_t</span> buffer_length;</div><div class="line">status = <a class="code" href="group__import__export.html#ga902b9a7a6cf34d6111668be777b05eaf">psa_export_key</a>(key, buffer, buffer_size, &buffer_length);</div><div class="line"><span class="keywordflow">if</span> (status != <a class="code" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a>) handle_error(...);</div></div><!-- fragment --><p>For <a class="el" href="group__import__export.html#gad760d1f0d4e60972c78cbb4c8a528256" title="Export a public key or the public part of a key pair in binary format. ">psa_export_public_key()</a>, calculate the buffer size from the public key type. You can use the macro <a class="el" href="group__crypto__types.html#gace08e46dd7cbf642d50d982a25d02bec">PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR</a> to convert a key pair type to the corresponding public key type. </p><div class="fragment"><div class="line"><a class="code" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a> key_type;</div><div class="line"><span class="keywordtype">size_t</span> key_bits;</div><div class="line"><a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> status;</div><div class="line">status = <a class="code" href="group__import__export.html#gae8939902d6977ea8ad13eb7b4db9a042">psa_get_key_information</a>(key, &key_type, &key_bits);</div><div class="line"><span class="keywordflow">if</span> (status != <a class="code" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a>) handle_error(...);</div><div class="line"><a class="code" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a> public_key_type = <a class="code" href="group__crypto__types.html#gace08e46dd7cbf642d50d982a25d02bec">PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR</a>(key_type);</div><div class="line"><span class="keywordtype">size_t</span> buffer_size = <a class="code" href="crypto__sizes_8h.html#a0aae885cc8ff92e00fb5248420b939c3">PSA_KEY_EXPORT_MAX_SIZE</a>(public_key_type, key_bits);</div><div class="line"><span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> *buffer = malloc(buffer_size);</div><div class="line"><span class="keywordflow">if</span> (buffer != NULL) handle_error(...);</div><div class="line"><span class="keywordtype">size_t</span> buffer_length;</div><div class="line">status = <a class="code" href="group__import__export.html#gad760d1f0d4e60972c78cbb4c8a528256">psa_export_public_key</a>(key, buffer, buffer_size, &buffer_length);</div><div class="line"><span class="keywordflow">if</span> (status != <a class="code" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a>) handle_error(...);</div></div><!-- fragment --><dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">key_type</td><td>A supported key type. </td></tr>
- <tr><td class="paramname">key_bits</td><td>The size of the key in bits.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>If the parameters are valid and supported, return a buffer size in bytes that guarantees that <a class="el" href="group__asymmetric.html#ga1b0db9d345b5048cdd39357ac2d56c07" title="Sign a hash or short message with a private key. ">psa_asymmetric_sign()</a> will not fail with <a class="el" href="group__error.html#ga695025f4ec11249aee7ea3d0f65e01c8">PSA_ERROR_BUFFER_TOO_SMALL</a>. If the parameters are a valid combination that is not supported by the implementation, this macro either shall return either a sensible size or 0. If the parameters are not valid, the return value is unspecified. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="aa84c5fb384ac7cb1bfc52adde96588ee"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_MAC_FINAL_SIZE</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">key_type, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"> </td>
- <td class="paramname">key_bits, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"> </td>
- <td class="paramname">alg </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">((alg) & PSA_ALG_MAC_TRUNCATION_MASK ? <a class="code" href="group__crypto__types.html#gab03726c4476174e019a08e2a04018ce8">PSA_MAC_TRUNCATED_LENGTH</a>(alg) : <a class="code" href="group__crypto__types.html#ga4a050c3c3cbc6eb96418f18847601c8a">\</a></div><div class="line"><a class="code" href="group__crypto__types.html#ga4a050c3c3cbc6eb96418f18847601c8a"> PSA_ALG_IS_HMAC</a>(alg) ? <a class="code" href="crypto__sizes_8h.html#aef340331ce3cba2b57e1fc5624bf1f99">PSA_HASH_SIZE</a>(PSA_ALG_HMAC_GET_HASH(alg)) : \</div><div class="line"> <a class="code" href="group__crypto__types.html#gae49d1eb601125d65a5c5b252aa45479e">PSA_ALG_IS_BLOCK_CIPHER_MAC</a>(alg) ? <a class="code" href="group__crypto__types.html#gacaa366bdeb0413e63e87a667c5457b2e">PSA_BLOCK_CIPHER_BLOCK_SIZE</a>(key_type) : \</div><div class="line"> ((void)(key_type), (void)(key_bits), 0))</div><div class="ttc" id="crypto__sizes_8h_html_aef340331ce3cba2b57e1fc5624bf1f99"><div class="ttname"><a href="crypto__sizes_8h.html#aef340331ce3cba2b57e1fc5624bf1f99">PSA_HASH_SIZE</a></div><div class="ttdeci">#define PSA_HASH_SIZE(alg)</div><div class="ttdef"><b>Definition:</b> crypto_sizes.h:70</div></div>
-<div class="ttc" id="group__crypto__types_html_gae49d1eb601125d65a5c5b252aa45479e"><div class="ttname"><a href="group__crypto__types.html#gae49d1eb601125d65a5c5b252aa45479e">PSA_ALG_IS_BLOCK_CIPHER_MAC</a></div><div class="ttdeci">#define PSA_ALG_IS_BLOCK_CIPHER_MAC(alg)</div><div class="ttdef"><b>Definition:</b> crypto_values.h:823</div></div>
-<div class="ttc" id="group__crypto__types_html_gacaa366bdeb0413e63e87a667c5457b2e"><div class="ttname"><a href="group__crypto__types.html#gacaa366bdeb0413e63e87a667c5457b2e">PSA_BLOCK_CIPHER_BLOCK_SIZE</a></div><div class="ttdeci">#define PSA_BLOCK_CIPHER_BLOCK_SIZE(type)</div><div class="ttdef"><b>Definition:</b> crypto_values.h:527</div></div>
-<div class="ttc" id="group__crypto__types_html_gab03726c4476174e019a08e2a04018ce8"><div class="ttname"><a href="group__crypto__types.html#gab03726c4476174e019a08e2a04018ce8">PSA_MAC_TRUNCATED_LENGTH</a></div><div class="ttdeci">#define PSA_MAC_TRUNCATED_LENGTH(alg)</div><div class="ttdef"><b>Definition:</b> crypto_values.h:807</div></div>
-<div class="ttc" id="group__crypto__types_html_ga4a050c3c3cbc6eb96418f18847601c8a"><div class="ttname"><a href="group__crypto__types.html#ga4a050c3c3cbc6eb96418f18847601c8a">PSA_ALG_IS_HMAC</a></div><div class="ttdeci">#define PSA_ALG_IS_HMAC(alg)</div><div class="ttdef"><b>Definition:</b> crypto_values.h:730</div></div>
-</div><!-- fragment --><p>The size of the output of <a class="el" href="group__MAC.html#gac22bc0125580c96724a09226cfbc97f2">psa_mac_sign_finish()</a>, in bytes.</p>
-<p>This is also the MAC size that <a class="el" href="group__MAC.html#gac92b2930d6728e1be4d011c05d485822">psa_mac_verify_finish()</a> expects.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">key_type</td><td>The type of the MAC key. </td></tr>
- <tr><td class="paramname">key_bits</td><td>The size of the MAC key in bits. </td></tr>
- <tr><td class="paramname">alg</td><td>A MAC algorithm (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#gaca7aee4c9dde316b3b1a150a26eab776">PSA_ALG_IS_MAC</a>(<code>alg</code>) is true).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>The MAC size for the specified algorithm with the specified key parameters. </dd>
-<dd>
-0 if the MAC algorithm is not recognized. </dd>
-<dd>
-Either 0 or the correct size for a MAC algorithm that the implementation recognizes, but does not support. </dd>
-<dd>
-Unspecified if the key parameters are not consistent with the algorithm. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="a4681cc4f6226883a2160122c562ca682"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_MAC_MAX_SIZE   <a class="el" href="crypto__sizes_8h.html#a6ce1014efbbc0bcca286ef7f9a72cb29">PSA_HASH_MAX_SIZE</a></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Maximum size of a MAC.</p>
-<p>This macro must expand to a compile-time constant integer. This value should be the maximum size of a MAC supported by the implementation, in bytes, and must be no smaller than this maximum. </p>
-
-</div>
-</div>
-<a class="anchor" id="aa3cfcff0291d6da279fec8fe834d5dec"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_MAX_BLOCK_CIPHER_BLOCK_SIZE   16</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The maximum size of a block cipher supported by the implementation. </p>
-
-</div>
-</div>
-<a class="anchor" id="aec0bcba60e7514b83f967b171d494ed3"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_RSA_MINIMUM_PADDING_SIZE</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">(PSA_ALG_IS_RSA_OAEP(alg) ? \</div><div class="line"> 2 * PSA_HASH_FINAL_SIZE(PSA_ALG_RSA_OAEP_GET_HASH(alg)) + 1 : \</div><div class="line"> 11 <span class="comment">/*PKCS#1v1.5*/</span>)</div></div><!-- fragment -->
-</div>
-</div>
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/crypto__sizes_8h__dep__incl.map b/docs/html/crypto__sizes_8h__dep__incl.map
deleted file mode 100644
index 549dc4c..0000000
--- a/docs/html/crypto__sizes_8h__dep__incl.map
+++ /dev/null
@@ -1,3 +0,0 @@
-<map id="psa/crypto_sizes.h" name="psa/crypto_sizes.h">
-<area shape="rect" id="node2" href="$crypto_8h.html" title="Platform Security Architecture cryptography module. " alt="" coords="24,80,119,107"/>
-</map>
diff --git a/docs/html/crypto__sizes_8h__dep__incl.md5 b/docs/html/crypto__sizes_8h__dep__incl.md5
deleted file mode 100644
index b4da281..0000000
--- a/docs/html/crypto__sizes_8h__dep__incl.md5
+++ /dev/null
@@ -1 +0,0 @@
-e32c7361c89b531f3dc3224bf18e2d1e
\ No newline at end of file
diff --git a/docs/html/crypto__sizes_8h__dep__incl.png b/docs/html/crypto__sizes_8h__dep__incl.png
deleted file mode 100644
index be24f96..0000000
--- a/docs/html/crypto__sizes_8h__dep__incl.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/crypto__sizes_8h__incl.map b/docs/html/crypto__sizes_8h__incl.map
deleted file mode 100644
index 8e2ba95..0000000
--- a/docs/html/crypto__sizes_8h__incl.map
+++ /dev/null
@@ -1,2 +0,0 @@
-<map id="psa/crypto_sizes.h" name="psa/crypto_sizes.h">
-</map>
diff --git a/docs/html/crypto__sizes_8h__incl.md5 b/docs/html/crypto__sizes_8h__incl.md5
deleted file mode 100644
index e3dab45..0000000
--- a/docs/html/crypto__sizes_8h__incl.md5
+++ /dev/null
@@ -1 +0,0 @@
-e658bed16c33e403901c0821826db5a9
\ No newline at end of file
diff --git a/docs/html/crypto__sizes_8h__incl.png b/docs/html/crypto__sizes_8h__incl.png
deleted file mode 100644
index f38fc21..0000000
--- a/docs/html/crypto__sizes_8h__incl.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/crypto__sizes_8h_source.html b/docs/html/crypto__sizes_8h_source.html
deleted file mode 100644
index 655f87b..0000000
--- a/docs/html/crypto__sizes_8h_source.html
+++ /dev/null
@@ -1,101 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: psa/crypto_sizes.h Source File</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li class="current"><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
- <div id="navrow2" class="tabs2">
- <ul class="tablist">
- <li><a href="files.html"><span>File List</span></a></li>
- <li><a href="globals.html"><span>File Members</span></a></li>
- </ul>
- </div>
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div id="nav-path" class="navpath">
- <ul>
-<li class="navelem"><a class="el" href="dir_7dae9cfde651cd3cb034485ce5e391b9.html">psa</a></li> </ul>
-</div>
-</div><!-- top -->
-<div class="header">
- <div class="headertitle">
-<div class="title">crypto_sizes.h</div> </div>
-</div><!--header-->
-<div class="contents">
-<a href="crypto__sizes_8h.html">Go to the documentation of this file.</a><div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> </div><div class="line"><a name="l00023"></a><span class="lineno"> 23</span> <span class="comment">/*</span></div><div class="line"><a name="l00024"></a><span class="lineno"> 24</span> <span class="comment"> * Copyright (C) 2018, ARM Limited, All Rights Reserved</span></div><div class="line"><a name="l00025"></a><span class="lineno"> 25</span> <span class="comment"> * SPDX-License-Identifier: Apache-2.0</span></div><div class="line"><a name="l00026"></a><span class="lineno"> 26</span> <span class="comment"> *</span></div><div class="line"><a name="l00027"></a><span class="lineno"> 27</span> <span class="comment"> * Licensed under the Apache License, Version 2.0 (the "License"); you may</span></div><div class="line"><a name="l00028"></a><span class="lineno"> 28</span> <span class="comment"> * not use this file except in compliance with the License.</span></div><div class="line"><a name="l00029"></a><span class="lineno"> 29</span> <span class="comment"> * You may obtain a copy of the License at</span></div><div class="line"><a name="l00030"></a><span class="lineno"> 30</span> <span class="comment"> *</span></div><div class="line"><a name="l00031"></a><span class="lineno"> 31</span> <span class="comment"> * http://www.apache.org/licenses/LICENSE-2.0</span></div><div class="line"><a name="l00032"></a><span class="lineno"> 32</span> <span class="comment"> *</span></div><div class="line"><a name="l00033"></a><span class="lineno"> 33</span> <span class="comment"> * Unless required by applicable law or agreed to in writing, software</span></div><div class="line"><a name="l00034"></a><span class="lineno"> 34</span> <span class="comment"> * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT</span></div><div class="line"><a name="l00035"></a><span class="lineno"> 35</span> <span class="comment"> * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.</span></div><div class="line"><a name="l00036"></a><span class="lineno"> 36</span> <span class="comment"> * See the License for the specific language governing permissions and</span></div><div class="line"><a name="l00037"></a><span class="lineno"> 37</span> <span class="comment"> * limitations under the License.</span></div><div class="line"><a name="l00038"></a><span class="lineno"> 38</span> <span class="comment"> *</span></div><div class="line"><a name="l00039"></a><span class="lineno"> 39</span> <span class="comment"> * This file is part of mbed TLS (https://tls.mbed.org)</span></div><div class="line"><a name="l00040"></a><span class="lineno"> 40</span> <span class="comment"> */</span></div><div class="line"><a name="l00041"></a><span class="lineno"> 41</span> </div><div class="line"><a name="l00042"></a><span class="lineno"> 42</span> <span class="preprocessor">#ifndef PSA_CRYPTO_SIZES_H</span></div><div class="line"><a name="l00043"></a><span class="lineno"> 43</span> <span class="preprocessor">#define PSA_CRYPTO_SIZES_H</span></div><div class="line"><a name="l00044"></a><span class="lineno"> 44</span> </div><div class="line"><a name="l00045"></a><span class="lineno"> 45</span> <span class="comment">/* Include the Mbed TLS configuration file, the way Mbed TLS does it</span></div><div class="line"><a name="l00046"></a><span class="lineno"> 46</span> <span class="comment"> * in each of its header files. */</span></div><div class="line"><a name="l00047"></a><span class="lineno"> 47</span> <span class="preprocessor">#if !defined(MBEDTLS_CONFIG_FILE)</span></div><div class="line"><a name="l00048"></a><span class="lineno"> 48</span> <span class="preprocessor">#include "../mbedtls/config.h"</span></div><div class="line"><a name="l00049"></a><span class="lineno"> 49</span> <span class="preprocessor">#else</span></div><div class="line"><a name="l00050"></a><span class="lineno"> 50</span> <span class="preprocessor">#include MBEDTLS_CONFIG_FILE</span></div><div class="line"><a name="l00051"></a><span class="lineno"> 51</span> <span class="preprocessor">#endif</span></div><div class="line"><a name="l00052"></a><span class="lineno"> 52</span> </div><div class="line"><a name="l00053"></a><span class="lineno"> 53</span> <span class="preprocessor">#define PSA_BITS_TO_BYTES(bits) (((bits) + 7) / 8)</span></div><div class="line"><a name="l00054"></a><span class="lineno"> 54</span> <span class="preprocessor">#define PSA_BYTES_TO_BITS(bytes) ((bytes) * 8)</span></div><div class="line"><a name="l00055"></a><span class="lineno"> 55</span> </div><div class="line"><a name="l00070"></a><span class="lineno"><a class="line" href="crypto__sizes_8h.html#aef340331ce3cba2b57e1fc5624bf1f99"> 70</a></span> <span class="preprocessor">#define PSA_HASH_SIZE(alg) \</span></div><div class="line"><a name="l00071"></a><span class="lineno"> 71</span> <span class="preprocessor"> ( \</span></div><div class="line"><a name="l00072"></a><span class="lineno"> 72</span> <span class="preprocessor"> PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_MD2 ? 16 : \</span></div><div class="line"><a name="l00073"></a><span class="lineno"> 73</span> <span class="preprocessor"> PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_MD4 ? 16 : \</span></div><div class="line"><a name="l00074"></a><span class="lineno"> 74</span> <span class="preprocessor"> PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_MD5 ? 16 : \</span></div><div class="line"><a name="l00075"></a><span class="lineno"> 75</span> <span class="preprocessor"> PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_RIPEMD160 ? 20 : \</span></div><div class="line"><a name="l00076"></a><span class="lineno"> 76</span> <span class="preprocessor"> PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_1 ? 20 : \</span></div><div class="line"><a name="l00077"></a><span class="lineno"> 77</span> <span class="preprocessor"> PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_224 ? 28 : \</span></div><div class="line"><a name="l00078"></a><span class="lineno"> 78</span> <span class="preprocessor"> PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_256 ? 32 : \</span></div><div class="line"><a name="l00079"></a><span class="lineno"> 79</span> <span class="preprocessor"> PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_384 ? 48 : \</span></div><div class="line"><a name="l00080"></a><span class="lineno"> 80</span> <span class="preprocessor"> PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_512 ? 64 : \</span></div><div class="line"><a name="l00081"></a><span class="lineno"> 81</span> <span class="preprocessor"> PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_512_224 ? 28 : \</span></div><div class="line"><a name="l00082"></a><span class="lineno"> 82</span> <span class="preprocessor"> PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_512_256 ? 32 : \</span></div><div class="line"><a name="l00083"></a><span class="lineno"> 83</span> <span class="preprocessor"> PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA3_224 ? 28 : \</span></div><div class="line"><a name="l00084"></a><span class="lineno"> 84</span> <span class="preprocessor"> PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA3_256 ? 32 : \</span></div><div class="line"><a name="l00085"></a><span class="lineno"> 85</span> <span class="preprocessor"> PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA3_384 ? 48 : \</span></div><div class="line"><a name="l00086"></a><span class="lineno"> 86</span> <span class="preprocessor"> PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA3_512 ? 64 : \</span></div><div class="line"><a name="l00087"></a><span class="lineno"> 87</span> <span class="preprocessor"> 0)</span></div><div class="line"><a name="l00088"></a><span class="lineno"> 88</span> </div><div class="line"><a name="l00097"></a><span class="lineno"> 97</span> <span class="comment">/* Note: for HMAC-SHA-3, the block size is 144 bytes for HMAC-SHA3-226,</span></div><div class="line"><a name="l00098"></a><span class="lineno"> 98</span> <span class="comment"> * 136 bytes for HMAC-SHA3-256, 104 bytes for SHA3-384, 72 bytes for</span></div><div class="line"><a name="l00099"></a><span class="lineno"> 99</span> <span class="comment"> * HMAC-SHA3-512. */</span></div><div class="line"><a name="l00100"></a><span class="lineno"> 100</span> <span class="preprocessor">#if defined(MBEDTLS_SHA512_C)</span></div><div class="line"><a name="l00101"></a><span class="lineno"><a class="line" href="crypto__sizes_8h.html#a6ce1014efbbc0bcca286ef7f9a72cb29"> 101</a></span> <span class="preprocessor">#define PSA_HASH_MAX_SIZE 64</span></div><div class="line"><a name="l00102"></a><span class="lineno"> 102</span> <span class="preprocessor">#define PSA_HMAC_MAX_HASH_BLOCK_SIZE 128</span></div><div class="line"><a name="l00103"></a><span class="lineno"> 103</span> <span class="preprocessor">#else</span></div><div class="line"><a name="l00104"></a><span class="lineno"> 104</span> <span class="preprocessor">#define PSA_HASH_MAX_SIZE 32</span></div><div class="line"><a name="l00105"></a><span class="lineno"> 105</span> <span class="preprocessor">#define PSA_HMAC_MAX_HASH_BLOCK_SIZE 64</span></div><div class="line"><a name="l00106"></a><span class="lineno"> 106</span> <span class="preprocessor">#endif</span></div><div class="line"><a name="l00107"></a><span class="lineno"> 107</span> </div><div class="line"><a name="l00116"></a><span class="lineno"> 116</span> <span class="comment">/* All non-HMAC MACs have a maximum size that's smaller than the</span></div><div class="line"><a name="l00117"></a><span class="lineno"> 117</span> <span class="comment"> * minimum possible value of PSA_HASH_MAX_SIZE in this implementation. */</span></div><div class="line"><a name="l00118"></a><span class="lineno"> 118</span> <span class="comment">/* Note that the encoding of truncated MAC algorithms limits this value</span></div><div class="line"><a name="l00119"></a><span class="lineno"> 119</span> <span class="comment"> * to 64 bytes.</span></div><div class="line"><a name="l00120"></a><span class="lineno"> 120</span> <span class="comment"> */</span></div><div class="line"><a name="l00121"></a><span class="lineno"><a class="line" href="crypto__sizes_8h.html#a4681cc4f6226883a2160122c562ca682"> 121</a></span> <span class="preprocessor">#define PSA_MAC_MAX_SIZE PSA_HASH_MAX_SIZE</span></div><div class="line"><a name="l00122"></a><span class="lineno"> 122</span> </div><div class="line"><a name="l00138"></a><span class="lineno"><a class="line" href="crypto__sizes_8h.html#a8e3079b2e624cb8d32b94843cddada49"> 138</a></span> <span class="preprocessor">#define PSA_AEAD_TAG_LENGTH(alg) \</span></div><div class="line"><a name="l00139"></a><span class="lineno"> 139</span> <span class="preprocessor"> (PSA_ALG_IS_AEAD(alg) ? \</span></div><div class="line"><a name="l00140"></a><span class="lineno"> 140</span> <span class="preprocessor"> (((alg) & PSA_ALG_AEAD_TAG_LENGTH_MASK) >> PSA_AEAD_TAG_LENGTH_OFFSET) : \</span></div><div class="line"><a name="l00141"></a><span class="lineno"> 141</span> <span class="preprocessor"> 0)</span></div><div class="line"><a name="l00142"></a><span class="lineno"> 142</span> </div><div class="line"><a name="l00143"></a><span class="lineno"> 143</span> <span class="comment">/* The maximum size of an RSA key on this implementation, in bits.</span></div><div class="line"><a name="l00144"></a><span class="lineno"> 144</span> <span class="comment"> * This is a vendor-specific macro.</span></div><div class="line"><a name="l00145"></a><span class="lineno"> 145</span> <span class="comment"> *</span></div><div class="line"><a name="l00146"></a><span class="lineno"> 146</span> <span class="comment"> * Mbed TLS does not set a hard limit on the size of RSA keys: any key</span></div><div class="line"><a name="l00147"></a><span class="lineno"> 147</span> <span class="comment"> * whose parameters fit in a bignum is accepted. However large keys can</span></div><div class="line"><a name="l00148"></a><span class="lineno"> 148</span> <span class="comment"> * induce a large memory usage and long computation times. Unlike other</span></div><div class="line"><a name="l00149"></a><span class="lineno"> 149</span> <span class="comment"> * auxiliary macros in this file and in crypto.h, which reflect how the</span></div><div class="line"><a name="l00150"></a><span class="lineno"> 150</span> <span class="comment"> * library is configured, this macro defines how the library is</span></div><div class="line"><a name="l00151"></a><span class="lineno"> 151</span> <span class="comment"> * configured. This implementation refuses to import or generate an</span></div><div class="line"><a name="l00152"></a><span class="lineno"> 152</span> <span class="comment"> * RSA key whose size is larger than the value defined here.</span></div><div class="line"><a name="l00153"></a><span class="lineno"> 153</span> <span class="comment"> *</span></div><div class="line"><a name="l00154"></a><span class="lineno"> 154</span> <span class="comment"> * Note that an implementation may set different size limits for different</span></div><div class="line"><a name="l00155"></a><span class="lineno"> 155</span> <span class="comment"> * operations, and does not need to accept all key sizes up to the limit. */</span></div><div class="line"><a name="l00156"></a><span class="lineno"> 156</span> <span class="preprocessor">#define PSA_VENDOR_RSA_MAX_KEY_BITS 4096</span></div><div class="line"><a name="l00157"></a><span class="lineno"> 157</span> </div><div class="line"><a name="l00158"></a><span class="lineno"> 158</span> <span class="comment">/* The maximum size of an ECC key on this implementation, in bits.</span></div><div class="line"><a name="l00159"></a><span class="lineno"> 159</span> <span class="comment"> * This is a vendor-specific macro. */</span></div><div class="line"><a name="l00160"></a><span class="lineno"> 160</span> <span class="preprocessor">#if defined(MBEDTLS_ECP_DP_SECP521R1_ENABLED)</span></div><div class="line"><a name="l00161"></a><span class="lineno"> 161</span> <span class="preprocessor">#define PSA_VENDOR_ECC_MAX_CURVE_BITS 521</span></div><div class="line"><a name="l00162"></a><span class="lineno"> 162</span> <span class="preprocessor">#elif defined(MBEDTLS_ECP_DP_BP512R1_ENABLED)</span></div><div class="line"><a name="l00163"></a><span class="lineno"> 163</span> <span class="preprocessor">#define PSA_VENDOR_ECC_MAX_CURVE_BITS 512</span></div><div class="line"><a name="l00164"></a><span class="lineno"> 164</span> <span class="preprocessor">#elif defined(MBEDTLS_ECP_DP_CURVE448_ENABLED)</span></div><div class="line"><a name="l00165"></a><span class="lineno"> 165</span> <span class="preprocessor">#define PSA_VENDOR_ECC_MAX_CURVE_BITS 448</span></div><div class="line"><a name="l00166"></a><span class="lineno"> 166</span> <span class="preprocessor">#elif defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)</span></div><div class="line"><a name="l00167"></a><span class="lineno"> 167</span> <span class="preprocessor">#define PSA_VENDOR_ECC_MAX_CURVE_BITS 384</span></div><div class="line"><a name="l00168"></a><span class="lineno"> 168</span> <span class="preprocessor">#elif defined(MBEDTLS_ECP_DP_BP384R1_ENABLED)</span></div><div class="line"><a name="l00169"></a><span class="lineno"> 169</span> <span class="preprocessor">#define PSA_VENDOR_ECC_MAX_CURVE_BITS 384</span></div><div class="line"><a name="l00170"></a><span class="lineno"> 170</span> <span class="preprocessor">#elif defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)</span></div><div class="line"><a name="l00171"></a><span class="lineno"> 171</span> <span class="preprocessor">#define PSA_VENDOR_ECC_MAX_CURVE_BITS 256</span></div><div class="line"><a name="l00172"></a><span class="lineno"> 172</span> <span class="preprocessor">#elif defined(MBEDTLS_ECP_DP_SECP256K1_ENABLED)</span></div><div class="line"><a name="l00173"></a><span class="lineno"> 173</span> <span class="preprocessor">#define PSA_VENDOR_ECC_MAX_CURVE_BITS 256</span></div><div class="line"><a name="l00174"></a><span class="lineno"> 174</span> <span class="preprocessor">#elif defined(MBEDTLS_ECP_DP_BP256R1_ENABLED)</span></div><div class="line"><a name="l00175"></a><span class="lineno"> 175</span> <span class="preprocessor">#define PSA_VENDOR_ECC_MAX_CURVE_BITS 256</span></div><div class="line"><a name="l00176"></a><span class="lineno"> 176</span> <span class="preprocessor">#elif defined(MBEDTLS_ECP_DP_CURVE25519_ENABLED)</span></div><div class="line"><a name="l00177"></a><span class="lineno"> 177</span> <span class="preprocessor">#define PSA_VENDOR_ECC_MAX_CURVE_BITS 255</span></div><div class="line"><a name="l00178"></a><span class="lineno"> 178</span> <span class="preprocessor">#elif defined(MBEDTLS_ECP_DP_SECP224R1_ENABLED)</span></div><div class="line"><a name="l00179"></a><span class="lineno"> 179</span> <span class="preprocessor">#define PSA_VENDOR_ECC_MAX_CURVE_BITS 224</span></div><div class="line"><a name="l00180"></a><span class="lineno"> 180</span> <span class="preprocessor">#elif defined(MBEDTLS_ECP_DP_SECP224K1_ENABLED)</span></div><div class="line"><a name="l00181"></a><span class="lineno"> 181</span> <span class="preprocessor">#define PSA_VENDOR_ECC_MAX_CURVE_BITS 224</span></div><div class="line"><a name="l00182"></a><span class="lineno"> 182</span> <span class="preprocessor">#elif defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED)</span></div><div class="line"><a name="l00183"></a><span class="lineno"> 183</span> <span class="preprocessor">#define PSA_VENDOR_ECC_MAX_CURVE_BITS 192</span></div><div class="line"><a name="l00184"></a><span class="lineno"> 184</span> <span class="preprocessor">#elif defined(MBEDTLS_ECP_DP_SECP192K1_ENABLED)</span></div><div class="line"><a name="l00185"></a><span class="lineno"> 185</span> <span class="preprocessor">#define PSA_VENDOR_ECC_MAX_CURVE_BITS 192</span></div><div class="line"><a name="l00186"></a><span class="lineno"> 186</span> <span class="preprocessor">#else</span></div><div class="line"><a name="l00187"></a><span class="lineno"> 187</span> <span class="preprocessor">#define PSA_VENDOR_ECC_MAX_CURVE_BITS 0</span></div><div class="line"><a name="l00188"></a><span class="lineno"> 188</span> <span class="preprocessor">#endif</span></div><div class="line"><a name="l00189"></a><span class="lineno"> 189</span> </div><div class="line"><a name="l00204"></a><span class="lineno"><a class="line" href="crypto__sizes_8h.html#ab589ea3b86f2bfa18880459299c58f8a"> 204</a></span> <span class="preprocessor">#define PSA_ALG_TLS12_PSK_TO_MS_MAX_PSK_LEN 128</span></div><div class="line"><a name="l00205"></a><span class="lineno"> 205</span> </div><div class="line"><a name="l00214"></a><span class="lineno"><a class="line" href="crypto__sizes_8h.html#ad755101764dba14589e5919ee41be7ca"> 214</a></span> <span class="preprocessor">#define PSA_ASYMMETRIC_SIGNATURE_MAX_SIZE \</span></div><div class="line"><a name="l00215"></a><span class="lineno"> 215</span> <span class="preprocessor"> PSA_BITS_TO_BYTES( \</span></div><div class="line"><a name="l00216"></a><span class="lineno"> 216</span> <span class="preprocessor"> PSA_VENDOR_RSA_MAX_KEY_BITS > PSA_VENDOR_ECC_MAX_CURVE_BITS ? \</span></div><div class="line"><a name="l00217"></a><span class="lineno"> 217</span> <span class="preprocessor"> PSA_VENDOR_RSA_MAX_KEY_BITS : \</span></div><div class="line"><a name="l00218"></a><span class="lineno"> 218</span> <span class="preprocessor"> PSA_VENDOR_ECC_MAX_CURVE_BITS \</span></div><div class="line"><a name="l00219"></a><span class="lineno"> 219</span> <span class="preprocessor"> )</span></div><div class="line"><a name="l00220"></a><span class="lineno"> 220</span> </div><div class="line"><a name="l00222"></a><span class="lineno"><a class="line" href="crypto__sizes_8h.html#aa3cfcff0291d6da279fec8fe834d5dec"> 222</a></span> <span class="preprocessor">#define PSA_MAX_BLOCK_CIPHER_BLOCK_SIZE 16</span></div><div class="line"><a name="l00223"></a><span class="lineno"> 223</span> </div><div class="line"><a name="l00241"></a><span class="lineno"><a class="line" href="crypto__sizes_8h.html#aa84c5fb384ac7cb1bfc52adde96588ee"> 241</a></span> <span class="preprocessor">#define PSA_MAC_FINAL_SIZE(key_type, key_bits, alg) \</span></div><div class="line"><a name="l00242"></a><span class="lineno"> 242</span> <span class="preprocessor"> ((alg) & PSA_ALG_MAC_TRUNCATION_MASK ? PSA_MAC_TRUNCATED_LENGTH(alg) : \</span></div><div class="line"><a name="l00243"></a><span class="lineno"> 243</span> <span class="preprocessor"> PSA_ALG_IS_HMAC(alg) ? PSA_HASH_SIZE(PSA_ALG_HMAC_GET_HASH(alg)) : \</span></div><div class="line"><a name="l00244"></a><span class="lineno"> 244</span> <span class="preprocessor"> PSA_ALG_IS_BLOCK_CIPHER_MAC(alg) ? PSA_BLOCK_CIPHER_BLOCK_SIZE(key_type) : \</span></div><div class="line"><a name="l00245"></a><span class="lineno"> 245</span> <span class="preprocessor"> ((void)(key_type), (void)(key_bits), 0))</span></div><div class="line"><a name="l00246"></a><span class="lineno"> 246</span> </div><div class="line"><a name="l00266"></a><span class="lineno"><a class="line" href="crypto__sizes_8h.html#a85667d47a7aa6c7b99a80e5273671266"> 266</a></span> <span class="preprocessor">#define PSA_AEAD_ENCRYPT_OUTPUT_SIZE(alg, plaintext_length) \</span></div><div class="line"><a name="l00267"></a><span class="lineno"> 267</span> <span class="preprocessor"> (PSA_AEAD_TAG_LENGTH(alg) != 0 ? \</span></div><div class="line"><a name="l00268"></a><span class="lineno"> 268</span> <span class="preprocessor"> (plaintext_length) + PSA_AEAD_TAG_LENGTH(alg) : \</span></div><div class="line"><a name="l00269"></a><span class="lineno"> 269</span> <span class="preprocessor"> 0)</span></div><div class="line"><a name="l00270"></a><span class="lineno"> 270</span> </div><div class="line"><a name="l00289"></a><span class="lineno"><a class="line" href="crypto__sizes_8h.html#ab097f6e054f1a73e975d597ade9029a6"> 289</a></span> <span class="preprocessor">#define PSA_AEAD_FINISH_OUTPUT_SIZE(alg) \</span></div><div class="line"><a name="l00290"></a><span class="lineno"> 290</span> <span class="preprocessor"> ((size_t)0)</span></div><div class="line"><a name="l00291"></a><span class="lineno"> 291</span> </div><div class="line"><a name="l00311"></a><span class="lineno"><a class="line" href="crypto__sizes_8h.html#a1d057796166c16eb673ad1997e48a60b"> 311</a></span> <span class="preprocessor">#define PSA_AEAD_DECRYPT_OUTPUT_SIZE(alg, ciphertext_length) \</span></div><div class="line"><a name="l00312"></a><span class="lineno"> 312</span> <span class="preprocessor"> (PSA_AEAD_TAG_LENGTH(alg) != 0 ? \</span></div><div class="line"><a name="l00313"></a><span class="lineno"> 313</span> <span class="preprocessor"> (plaintext_length) - PSA_AEAD_TAG_LENGTH(alg) : \</span></div><div class="line"><a name="l00314"></a><span class="lineno"> 314</span> <span class="preprocessor"> 0)</span></div><div class="line"><a name="l00315"></a><span class="lineno"> 315</span> </div><div class="line"><a name="l00316"></a><span class="lineno"> 316</span> <span class="preprocessor">#define PSA_RSA_MINIMUM_PADDING_SIZE(alg) \</span></div><div class="line"><a name="l00317"></a><span class="lineno"> 317</span> <span class="preprocessor"> (PSA_ALG_IS_RSA_OAEP(alg) ? \</span></div><div class="line"><a name="l00318"></a><span class="lineno"> 318</span> <span class="preprocessor"> 2 * PSA_HASH_FINAL_SIZE(PSA_ALG_RSA_OAEP_GET_HASH(alg)) + 1 : \</span></div><div class="line"><a name="l00319"></a><span class="lineno"> 319</span> <span class="preprocessor"> 11 </span><span class="comment">/*PKCS#1v1.5*/</span><span class="preprocessor">)</span></div><div class="line"><a name="l00320"></a><span class="lineno"> 320</span> </div><div class="line"><a name="l00329"></a><span class="lineno"><a class="line" href="crypto__sizes_8h.html#a10c472a35f04051add6b20cc228ffc11"> 329</a></span> <span class="preprocessor">#define PSA_ECDSA_SIGNATURE_SIZE(curve_bits) \</span></div><div class="line"><a name="l00330"></a><span class="lineno"> 330</span> <span class="preprocessor"> (PSA_BITS_TO_BYTES(curve_bits) * 2)</span></div><div class="line"><a name="l00331"></a><span class="lineno"> 331</span> </div><div class="line"><a name="l00358"></a><span class="lineno"><a class="line" href="crypto__sizes_8h.html#a77565b9b4fe6d8730fd2120f4c8378ab"> 358</a></span> <span class="preprocessor">#define PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE(key_type, key_bits, alg) \</span></div><div class="line"><a name="l00359"></a><span class="lineno"> 359</span> <span class="preprocessor"> (PSA_KEY_TYPE_IS_RSA(key_type) ? ((void)alg, PSA_BITS_TO_BYTES(key_bits)) : \</span></div><div class="line"><a name="l00360"></a><span class="lineno"> 360</span> <span class="preprocessor"> PSA_KEY_TYPE_IS_ECC(key_type) ? PSA_ECDSA_SIGNATURE_SIZE(key_bits) : \</span></div><div class="line"><a name="l00361"></a><span class="lineno"> 361</span> <span class="preprocessor"> ((void)alg, 0))</span></div><div class="line"><a name="l00362"></a><span class="lineno"> 362</span> </div><div class="line"><a name="l00389"></a><span class="lineno"><a class="line" href="crypto__sizes_8h.html#a66ba3bd93e5ec52870ccc3848778bad8"> 389</a></span> <span class="preprocessor">#define PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE(key_type, key_bits, alg) \</span></div><div class="line"><a name="l00390"></a><span class="lineno"> 390</span> <span class="preprocessor"> (PSA_KEY_TYPE_IS_RSA(key_type) ? \</span></div><div class="line"><a name="l00391"></a><span class="lineno"> 391</span> <span class="preprocessor"> ((void)alg, PSA_BITS_TO_BYTES(key_bits)) : \</span></div><div class="line"><a name="l00392"></a><span class="lineno"> 392</span> <span class="preprocessor"> 0)</span></div><div class="line"><a name="l00393"></a><span class="lineno"> 393</span> </div><div class="line"><a name="l00420"></a><span class="lineno"><a class="line" href="crypto__sizes_8h.html#a61a246f3eac41989821d982e56fea6c1"> 420</a></span> <span class="preprocessor">#define PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE(key_type, key_bits, alg) \</span></div><div class="line"><a name="l00421"></a><span class="lineno"> 421</span> <span class="preprocessor"> (PSA_KEY_TYPE_IS_RSA(key_type) ? \</span></div><div class="line"><a name="l00422"></a><span class="lineno"> 422</span> <span class="preprocessor"> PSA_BITS_TO_BYTES(key_bits) - PSA_RSA_MINIMUM_PADDING_SIZE(alg) : \</span></div><div class="line"><a name="l00423"></a><span class="lineno"> 423</span> <span class="preprocessor"> 0)</span></div><div class="line"><a name="l00424"></a><span class="lineno"> 424</span> </div><div class="line"><a name="l00425"></a><span class="lineno"> 425</span> <span class="comment">/* Maximum size of the ASN.1 encoding of an INTEGER with the specified</span></div><div class="line"><a name="l00426"></a><span class="lineno"> 426</span> <span class="comment"> * number of bits.</span></div><div class="line"><a name="l00427"></a><span class="lineno"> 427</span> <span class="comment"> *</span></div><div class="line"><a name="l00428"></a><span class="lineno"> 428</span> <span class="comment"> * This definition assumes that bits <= 2^19 - 9 so that the length field</span></div><div class="line"><a name="l00429"></a><span class="lineno"> 429</span> <span class="comment"> * is at most 3 bytes. The length of the encoding is the length of the</span></div><div class="line"><a name="l00430"></a><span class="lineno"> 430</span> <span class="comment"> * bit string padded to a whole number of bytes plus:</span></div><div class="line"><a name="l00431"></a><span class="lineno"> 431</span> <span class="comment"> * - 1 type byte;</span></div><div class="line"><a name="l00432"></a><span class="lineno"> 432</span> <span class="comment"> * - 1 to 3 length bytes;</span></div><div class="line"><a name="l00433"></a><span class="lineno"> 433</span> <span class="comment"> * - 0 to 1 bytes of leading 0 due to the sign bit.</span></div><div class="line"><a name="l00434"></a><span class="lineno"> 434</span> <span class="comment"> */</span></div><div class="line"><a name="l00435"></a><span class="lineno"> 435</span> <span class="preprocessor">#define PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE(bits) \</span></div><div class="line"><a name="l00436"></a><span class="lineno"> 436</span> <span class="preprocessor"> ((bits) / 8 + 5)</span></div><div class="line"><a name="l00437"></a><span class="lineno"> 437</span> </div><div class="line"><a name="l00438"></a><span class="lineno"> 438</span> <span class="comment">/* Maximum size of the export encoding of an RSA public key.</span></div><div class="line"><a name="l00439"></a><span class="lineno"> 439</span> <span class="comment"> * Assumes that the public exponent is less than 2^32.</span></div><div class="line"><a name="l00440"></a><span class="lineno"> 440</span> <span class="comment"> *</span></div><div class="line"><a name="l00441"></a><span class="lineno"> 441</span> <span class="comment"> * SubjectPublicKeyInfo ::= SEQUENCE {</span></div><div class="line"><a name="l00442"></a><span class="lineno"> 442</span> <span class="comment"> * algorithm AlgorithmIdentifier,</span></div><div class="line"><a name="l00443"></a><span class="lineno"> 443</span> <span class="comment"> * subjectPublicKey BIT STRING } -- contains RSAPublicKey</span></div><div class="line"><a name="l00444"></a><span class="lineno"> 444</span> <span class="comment"> * AlgorithmIdentifier ::= SEQUENCE {</span></div><div class="line"><a name="l00445"></a><span class="lineno"> 445</span> <span class="comment"> * algorithm OBJECT IDENTIFIER,</span></div><div class="line"><a name="l00446"></a><span class="lineno"> 446</span> <span class="comment"> * parameters NULL }</span></div><div class="line"><a name="l00447"></a><span class="lineno"> 447</span> <span class="comment"> * RSAPublicKey ::= SEQUENCE {</span></div><div class="line"><a name="l00448"></a><span class="lineno"> 448</span> <span class="comment"> * modulus INTEGER, -- n</span></div><div class="line"><a name="l00449"></a><span class="lineno"> 449</span> <span class="comment"> * publicExponent INTEGER } -- e</span></div><div class="line"><a name="l00450"></a><span class="lineno"> 450</span> <span class="comment"> *</span></div><div class="line"><a name="l00451"></a><span class="lineno"> 451</span> <span class="comment"> * - 3 * 4 bytes of SEQUENCE overhead;</span></div><div class="line"><a name="l00452"></a><span class="lineno"> 452</span> <span class="comment"> * - 1 + 1 + 9 bytes of algorithm (RSA OID);</span></div><div class="line"><a name="l00453"></a><span class="lineno"> 453</span> <span class="comment"> * - 2 bytes of NULL;</span></div><div class="line"><a name="l00454"></a><span class="lineno"> 454</span> <span class="comment"> * - 4 bytes of BIT STRING overhead;</span></div><div class="line"><a name="l00455"></a><span class="lineno"> 455</span> <span class="comment"> * - n : INTEGER;</span></div><div class="line"><a name="l00456"></a><span class="lineno"> 456</span> <span class="comment"> * - 7 bytes for the public exponent.</span></div><div class="line"><a name="l00457"></a><span class="lineno"> 457</span> <span class="comment"> */</span></div><div class="line"><a name="l00458"></a><span class="lineno"> 458</span> <span class="preprocessor">#define PSA_KEY_EXPORT_RSA_PUBLIC_KEY_MAX_SIZE(key_bits) \</span></div><div class="line"><a name="l00459"></a><span class="lineno"> 459</span> <span class="preprocessor"> (PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE(key_bits) + 36)</span></div><div class="line"><a name="l00460"></a><span class="lineno"> 460</span> </div><div class="line"><a name="l00461"></a><span class="lineno"> 461</span> <span class="comment">/* Maximum size of the export encoding of an RSA key pair.</span></div><div class="line"><a name="l00462"></a><span class="lineno"> 462</span> <span class="comment"> * Assumes thatthe public exponent is less than 2^32 and that the size</span></div><div class="line"><a name="l00463"></a><span class="lineno"> 463</span> <span class="comment"> * difference between the two primes is at most 1 bit.</span></div><div class="line"><a name="l00464"></a><span class="lineno"> 464</span> <span class="comment"> *</span></div><div class="line"><a name="l00465"></a><span class="lineno"> 465</span> <span class="comment"> * RSAPrivateKey ::= SEQUENCE {</span></div><div class="line"><a name="l00466"></a><span class="lineno"> 466</span> <span class="comment"> * version Version, -- 0</span></div><div class="line"><a name="l00467"></a><span class="lineno"> 467</span> <span class="comment"> * modulus INTEGER, -- N-bit</span></div><div class="line"><a name="l00468"></a><span class="lineno"> 468</span> <span class="comment"> * publicExponent INTEGER, -- 32-bit</span></div><div class="line"><a name="l00469"></a><span class="lineno"> 469</span> <span class="comment"> * privateExponent INTEGER, -- N-bit</span></div><div class="line"><a name="l00470"></a><span class="lineno"> 470</span> <span class="comment"> * prime1 INTEGER, -- N/2-bit</span></div><div class="line"><a name="l00471"></a><span class="lineno"> 471</span> <span class="comment"> * prime2 INTEGER, -- N/2-bit</span></div><div class="line"><a name="l00472"></a><span class="lineno"> 472</span> <span class="comment"> * exponent1 INTEGER, -- N/2-bit</span></div><div class="line"><a name="l00473"></a><span class="lineno"> 473</span> <span class="comment"> * exponent2 INTEGER, -- N/2-bit</span></div><div class="line"><a name="l00474"></a><span class="lineno"> 474</span> <span class="comment"> * coefficient INTEGER, -- N/2-bit</span></div><div class="line"><a name="l00475"></a><span class="lineno"> 475</span> <span class="comment"> * }</span></div><div class="line"><a name="l00476"></a><span class="lineno"> 476</span> <span class="comment"> *</span></div><div class="line"><a name="l00477"></a><span class="lineno"> 477</span> <span class="comment"> * - 4 bytes of SEQUENCE overhead;</span></div><div class="line"><a name="l00478"></a><span class="lineno"> 478</span> <span class="comment"> * - 3 bytes of version;</span></div><div class="line"><a name="l00479"></a><span class="lineno"> 479</span> <span class="comment"> * - 7 half-size INTEGERs plus 2 full-size INTEGERs,</span></div><div class="line"><a name="l00480"></a><span class="lineno"> 480</span> <span class="comment"> * overapproximated as 9 half-size INTEGERS;</span></div><div class="line"><a name="l00481"></a><span class="lineno"> 481</span> <span class="comment"> * - 7 bytes for the public exponent.</span></div><div class="line"><a name="l00482"></a><span class="lineno"> 482</span> <span class="comment"> */</span></div><div class="line"><a name="l00483"></a><span class="lineno"> 483</span> <span class="preprocessor">#define PSA_KEY_EXPORT_RSA_KEYPAIR_MAX_SIZE(key_bits) \</span></div><div class="line"><a name="l00484"></a><span class="lineno"> 484</span> <span class="preprocessor"> (9 * PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE((key_bits) / 2 + 1) + 14)</span></div><div class="line"><a name="l00485"></a><span class="lineno"> 485</span> </div><div class="line"><a name="l00486"></a><span class="lineno"> 486</span> <span class="comment">/* Maximum size of the export encoding of a DSA public key.</span></div><div class="line"><a name="l00487"></a><span class="lineno"> 487</span> <span class="comment"> *</span></div><div class="line"><a name="l00488"></a><span class="lineno"> 488</span> <span class="comment"> * SubjectPublicKeyInfo ::= SEQUENCE {</span></div><div class="line"><a name="l00489"></a><span class="lineno"> 489</span> <span class="comment"> * algorithm AlgorithmIdentifier,</span></div><div class="line"><a name="l00490"></a><span class="lineno"> 490</span> <span class="comment"> * subjectPublicKey BIT STRING } -- contains DSAPublicKey</span></div><div class="line"><a name="l00491"></a><span class="lineno"> 491</span> <span class="comment"> * AlgorithmIdentifier ::= SEQUENCE {</span></div><div class="line"><a name="l00492"></a><span class="lineno"> 492</span> <span class="comment"> * algorithm OBJECT IDENTIFIER,</span></div><div class="line"><a name="l00493"></a><span class="lineno"> 493</span> <span class="comment"> * parameters Dss-Parms } -- SEQUENCE of 3 INTEGERs</span></div><div class="line"><a name="l00494"></a><span class="lineno"> 494</span> <span class="comment"> * DSAPublicKey ::= INTEGER -- public key, Y</span></div><div class="line"><a name="l00495"></a><span class="lineno"> 495</span> <span class="comment"> *</span></div><div class="line"><a name="l00496"></a><span class="lineno"> 496</span> <span class="comment"> * - 3 * 4 bytes of SEQUENCE overhead;</span></div><div class="line"><a name="l00497"></a><span class="lineno"> 497</span> <span class="comment"> * - 1 + 1 + 7 bytes of algorithm (DSA OID);</span></div><div class="line"><a name="l00498"></a><span class="lineno"> 498</span> <span class="comment"> * - 4 bytes of BIT STRING overhead;</span></div><div class="line"><a name="l00499"></a><span class="lineno"> 499</span> <span class="comment"> * - 3 full-size INTEGERs (p, g, y);</span></div><div class="line"><a name="l00500"></a><span class="lineno"> 500</span> <span class="comment"> * - 1 + 1 + 32 bytes for 1 sub-size INTEGER (q <= 256 bits).</span></div><div class="line"><a name="l00501"></a><span class="lineno"> 501</span> <span class="comment"> */</span></div><div class="line"><a name="l00502"></a><span class="lineno"> 502</span> <span class="preprocessor">#define PSA_KEY_EXPORT_DSA_PUBLIC_KEY_MAX_SIZE(key_bits) \</span></div><div class="line"><a name="l00503"></a><span class="lineno"> 503</span> <span class="preprocessor"> (PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE(key_bits) * 3 + 59)</span></div><div class="line"><a name="l00504"></a><span class="lineno"> 504</span> </div><div class="line"><a name="l00505"></a><span class="lineno"> 505</span> <span class="comment">/* Maximum size of the export encoding of a DSA key pair.</span></div><div class="line"><a name="l00506"></a><span class="lineno"> 506</span> <span class="comment"> *</span></div><div class="line"><a name="l00507"></a><span class="lineno"> 507</span> <span class="comment"> * DSAPrivateKey ::= SEQUENCE {</span></div><div class="line"><a name="l00508"></a><span class="lineno"> 508</span> <span class="comment"> * version Version, -- 0</span></div><div class="line"><a name="l00509"></a><span class="lineno"> 509</span> <span class="comment"> * prime INTEGER, -- p</span></div><div class="line"><a name="l00510"></a><span class="lineno"> 510</span> <span class="comment"> * subprime INTEGER, -- q</span></div><div class="line"><a name="l00511"></a><span class="lineno"> 511</span> <span class="comment"> * generator INTEGER, -- g</span></div><div class="line"><a name="l00512"></a><span class="lineno"> 512</span> <span class="comment"> * public INTEGER, -- y</span></div><div class="line"><a name="l00513"></a><span class="lineno"> 513</span> <span class="comment"> * private INTEGER, -- x</span></div><div class="line"><a name="l00514"></a><span class="lineno"> 514</span> <span class="comment"> * }</span></div><div class="line"><a name="l00515"></a><span class="lineno"> 515</span> <span class="comment"> *</span></div><div class="line"><a name="l00516"></a><span class="lineno"> 516</span> <span class="comment"> * - 4 bytes of SEQUENCE overhead;</span></div><div class="line"><a name="l00517"></a><span class="lineno"> 517</span> <span class="comment"> * - 3 bytes of version;</span></div><div class="line"><a name="l00518"></a><span class="lineno"> 518</span> <span class="comment"> * - 3 full-size INTEGERs (p, g, y);</span></div><div class="line"><a name="l00519"></a><span class="lineno"> 519</span> <span class="comment"> * - 2 * (1 + 1 + 32) bytes for 2 sub-size INTEGERs (q, x <= 256 bits).</span></div><div class="line"><a name="l00520"></a><span class="lineno"> 520</span> <span class="comment"> */</span></div><div class="line"><a name="l00521"></a><span class="lineno"> 521</span> <span class="preprocessor">#define PSA_KEY_EXPORT_DSA_KEYPAIR_MAX_SIZE(key_bits) \</span></div><div class="line"><a name="l00522"></a><span class="lineno"> 522</span> <span class="preprocessor"> (PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE(key_bits) * 3 + 75)</span></div><div class="line"><a name="l00523"></a><span class="lineno"> 523</span> </div><div class="line"><a name="l00524"></a><span class="lineno"> 524</span> <span class="comment">/* Maximum size of the export encoding of an ECC public key.</span></div><div class="line"><a name="l00525"></a><span class="lineno"> 525</span> <span class="comment"> *</span></div><div class="line"><a name="l00526"></a><span class="lineno"> 526</span> <span class="comment"> * SubjectPublicKeyInfo ::= SEQUENCE {</span></div><div class="line"><a name="l00527"></a><span class="lineno"> 527</span> <span class="comment"> * algorithm AlgorithmIdentifier,</span></div><div class="line"><a name="l00528"></a><span class="lineno"> 528</span> <span class="comment"> * subjectPublicKey BIT STRING } -- contains ECPoint</span></div><div class="line"><a name="l00529"></a><span class="lineno"> 529</span> <span class="comment"> * AlgorithmIdentifier ::= SEQUENCE {</span></div><div class="line"><a name="l00530"></a><span class="lineno"> 530</span> <span class="comment"> * algorithm OBJECT IDENTIFIER,</span></div><div class="line"><a name="l00531"></a><span class="lineno"> 531</span> <span class="comment"> * parameters OBJECT IDENTIFIER } -- namedCurve</span></div><div class="line"><a name="l00532"></a><span class="lineno"> 532</span> <span class="comment"> * ECPoint ::= ...</span></div><div class="line"><a name="l00533"></a><span class="lineno"> 533</span> <span class="comment"> * -- first 8 bits: 0x04;</span></div><div class="line"><a name="l00534"></a><span class="lineno"> 534</span> <span class="comment"> * -- then x_P as a `ceiling(m/8)`-byte string, big endian;</span></div><div class="line"><a name="l00535"></a><span class="lineno"> 535</span> <span class="comment"> * -- then y_P as a `ceiling(m/8)`-byte string, big endian;</span></div><div class="line"><a name="l00536"></a><span class="lineno"> 536</span> <span class="comment"> * -- where `m` is the bit size associated with the curve.</span></div><div class="line"><a name="l00537"></a><span class="lineno"> 537</span> <span class="comment"> *</span></div><div class="line"><a name="l00538"></a><span class="lineno"> 538</span> <span class="comment"> * - 2 * 4 bytes of SEQUENCE overhead;</span></div><div class="line"><a name="l00539"></a><span class="lineno"> 539</span> <span class="comment"> * - 1 + 1 + 7 bytes of algorithm (id-ecPublicKey OID);</span></div><div class="line"><a name="l00540"></a><span class="lineno"> 540</span> <span class="comment"> * - 1 + 1 + 12 bytes of namedCurve OID;</span></div><div class="line"><a name="l00541"></a><span class="lineno"> 541</span> <span class="comment"> * - 4 bytes of BIT STRING overhead;</span></div><div class="line"><a name="l00542"></a><span class="lineno"> 542</span> <span class="comment"> * - 1 byte + 2 * point size in ECPoint.</span></div><div class="line"><a name="l00543"></a><span class="lineno"> 543</span> <span class="comment"> */</span></div><div class="line"><a name="l00544"></a><span class="lineno"> 544</span> <span class="preprocessor">#define PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE(key_bits) \</span></div><div class="line"><a name="l00545"></a><span class="lineno"> 545</span> <span class="preprocessor"> (2 * PSA_BITS_TO_BYTES(key_bits) + 36)</span></div><div class="line"><a name="l00546"></a><span class="lineno"> 546</span> </div><div class="line"><a name="l00547"></a><span class="lineno"> 547</span> <span class="comment">/* Maximum size of the export encoding of an ECC key pair.</span></div><div class="line"><a name="l00548"></a><span class="lineno"> 548</span> <span class="comment"> *</span></div><div class="line"><a name="l00549"></a><span class="lineno"> 549</span> <span class="comment"> * An ECC key pair is represented by the secret value.</span></div><div class="line"><a name="l00550"></a><span class="lineno"> 550</span> <span class="comment"> */</span></div><div class="line"><a name="l00551"></a><span class="lineno"> 551</span> <span class="preprocessor">#define PSA_KEY_EXPORT_ECC_KEYPAIR_MAX_SIZE(key_bits) \</span></div><div class="line"><a name="l00552"></a><span class="lineno"> 552</span> <span class="preprocessor"> (PSA_BITS_TO_BYTES(key_bits))</span></div><div class="line"><a name="l00553"></a><span class="lineno"> 553</span> </div><div class="line"><a name="l00610"></a><span class="lineno"><a class="line" href="crypto__sizes_8h.html#a0aae885cc8ff92e00fb5248420b939c3"> 610</a></span> <span class="preprocessor">#define PSA_KEY_EXPORT_MAX_SIZE(key_type, key_bits) \</span></div><div class="line"><a name="l00611"></a><span class="lineno"> 611</span> <span class="preprocessor"> (PSA_KEY_TYPE_IS_UNSTRUCTURED(key_type) ? PSA_BITS_TO_BYTES(key_bits) : \</span></div><div class="line"><a name="l00612"></a><span class="lineno"> 612</span> <span class="preprocessor"> (key_type) == PSA_KEY_TYPE_RSA_KEYPAIR ? PSA_KEY_EXPORT_RSA_KEYPAIR_MAX_SIZE(key_bits) : \</span></div><div class="line"><a name="l00613"></a><span class="lineno"> 613</span> <span class="preprocessor"> (key_type) == PSA_KEY_TYPE_RSA_PUBLIC_KEY ? PSA_KEY_EXPORT_RSA_PUBLIC_KEY_MAX_SIZE(key_bits) : \</span></div><div class="line"><a name="l00614"></a><span class="lineno"> 614</span> <span class="preprocessor"> (key_type) == PSA_KEY_TYPE_DSA_KEYPAIR ? PSA_KEY_EXPORT_DSA_KEYPAIR_MAX_SIZE(key_bits) : \</span></div><div class="line"><a name="l00615"></a><span class="lineno"> 615</span> <span class="preprocessor"> (key_type) == PSA_KEY_TYPE_DSA_PUBLIC_KEY ? PSA_KEY_EXPORT_DSA_PUBLIC_KEY_MAX_SIZE(key_bits) : \</span></div><div class="line"><a name="l00616"></a><span class="lineno"> 616</span> <span class="preprocessor"> PSA_KEY_TYPE_IS_ECC_KEYPAIR(key_type) ? PSA_KEY_EXPORT_ECC_KEYPAIR_MAX_SIZE(key_bits) : \</span></div><div class="line"><a name="l00617"></a><span class="lineno"> 617</span> <span class="preprocessor"> PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY(key_type) ? PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE(key_bits) : \</span></div><div class="line"><a name="l00618"></a><span class="lineno"> 618</span> <span class="preprocessor"> 0)</span></div><div class="line"><a name="l00619"></a><span class="lineno"> 619</span> </div><div class="line"><a name="l00620"></a><span class="lineno"> 620</span> <span class="preprocessor">#endif </span><span class="comment">/* PSA_CRYPTO_SIZES_H */</span><span class="preprocessor"></span></div></div><!-- fragment --></div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/crypto__types_8h.html b/docs/html/crypto__types_8h.html
deleted file mode 100644
index a7f6955..0000000
--- a/docs/html/crypto__types_8h.html
+++ /dev/null
@@ -1,155 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: psa/crypto_types.h File Reference</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li class="current"><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
- <div id="navrow2" class="tabs2">
- <ul class="tablist">
- <li><a href="files.html"><span>File List</span></a></li>
- <li><a href="globals.html"><span>File Members</span></a></li>
- </ul>
- </div>
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div id="nav-path" class="navpath">
- <ul>
-<li class="navelem"><a class="el" href="dir_7dae9cfde651cd3cb034485ce5e391b9.html">psa</a></li> </ul>
-</div>
-</div><!-- top -->
-<div class="header">
- <div class="summary">
-<a href="#typedef-members">Typedefs</a> </div>
- <div class="headertitle">
-<div class="title">crypto_types.h File Reference</div> </div>
-</div><!--header-->
-<div class="contents">
-
-<p>PSA cryptography module: type aliases.
-<a href="#details">More...</a></p>
-<div class="textblock"><code>#include <stdint.h></code><br />
-</div><div class="textblock"><div class="dynheader">
-Include dependency graph for crypto_types.h:</div>
-<div class="dyncontent">
-<div class="center"><img src="crypto__types_8h__incl.png" border="0" usemap="#psa_2crypto__types_8h" alt=""/></div>
-</div>
-</div><div class="textblock"><div class="dynheader">
-This graph shows which files directly or indirectly include this file:</div>
-<div class="dyncontent">
-<div class="center"><img src="crypto__types_8h__dep__incl.png" border="0" usemap="#psa_2crypto__types_8hdep" alt=""/></div>
-<map name="psa_2crypto__types_8hdep" id="psa_2crypto__types_8hdep">
-<area shape="rect" id="node2" href="crypto_8h.html" title="Platform Security Architecture cryptography module. " alt="" coords="25,80,119,107"/>
-</map>
-</div>
-</div>
-<p><a href="crypto__types_8h_source.html">Go to the source code of this file.</a></p>
-<table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="typedef-members"></a>
-Typedefs</h2></td></tr>
-<tr class="memitem:ga05676e70ba5c6a7565aff3c36677c1f9"><td class="memItemLeft" align="right" valign="top">typedef int32_t </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a></td></tr>
-<tr class="memdesc:ga05676e70ba5c6a7565aff3c36677c1f9"><td class="mdescLeft"> </td><td class="mdescRight">Function return status. <a href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">More...</a><br /></td></tr>
-<tr class="separator:ga05676e70ba5c6a7565aff3c36677c1f9"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga578159487dfc7096cb191b0d2befe628"><td class="memItemLeft" align="right" valign="top">
-typedef uint32_t </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a></td></tr>
-<tr class="memdesc:ga578159487dfc7096cb191b0d2befe628"><td class="mdescLeft"> </td><td class="mdescRight">Encoding of a key type. <br /></td></tr>
-<tr class="separator:ga578159487dfc7096cb191b0d2befe628"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4e8977c145cce5077c4bce7fec890ad9"><td class="memItemLeft" align="right" valign="top">typedef uint16_t </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a></td></tr>
-<tr class="separator:ga4e8977c145cce5077c4bce7fec890ad9"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac2e4d47f1300d73c2f829a6d99252d69"><td class="memItemLeft" align="right" valign="top">typedef uint32_t </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a></td></tr>
-<tr class="memdesc:gac2e4d47f1300d73c2f829a6d99252d69"><td class="mdescLeft"> </td><td class="mdescRight">Encoding of a cryptographic algorithm. <a href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">More...</a><br /></td></tr>
-<tr class="separator:gac2e4d47f1300d73c2f829a6d99252d69"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6821ff6dd39dc2bc370ded760ad8b0cf"><td class="memItemLeft" align="right" valign="top">typedef uint32_t </td><td class="memItemRight" valign="bottom"><a class="el" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">psa_key_lifetime_t</a></td></tr>
-<tr class="separator:ga6821ff6dd39dc2bc370ded760ad8b0cf"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga11e986351c65bd3dc3c0fe2cd9926e4b"><td class="memItemLeft" align="right" valign="top">typedef uint32_t </td><td class="memItemRight" valign="bottom"><a class="el" href="group__key__lifetimes.html#ga11e986351c65bd3dc3c0fe2cd9926e4b">psa_key_id_t</a></td></tr>
-<tr class="separator:ga11e986351c65bd3dc3c0fe2cd9926e4b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga7bb9de71337e0e98de843aa7f9b55f25"><td class="memItemLeft" align="right" valign="top">
-typedef uint32_t </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a></td></tr>
-<tr class="memdesc:ga7bb9de71337e0e98de843aa7f9b55f25"><td class="mdescLeft"> </td><td class="mdescRight">Encoding of permitted usage on a key. <br /></td></tr>
-<tr class="separator:ga7bb9de71337e0e98de843aa7f9b55f25"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaac4eeacd36596c548b3a48fc06c5048b"><td class="memItemLeft" align="right" valign="top">
-typedef uint16_t </td><td class="memItemRight" valign="bottom"><a class="el" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">psa_key_derivation_step_t</a></td></tr>
-<tr class="memdesc:gaac4eeacd36596c548b3a48fc06c5048b"><td class="mdescLeft"> </td><td class="mdescRight">Encoding of the step of a key derivation. <br /></td></tr>
-<tr class="separator:gaac4eeacd36596c548b3a48fc06c5048b"><td class="memSeparator" colspan="2"> </td></tr>
-</table>
-<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
-<div class="textblock"><p>PSA cryptography module: type aliases. </p>
-<dl class="section note"><dt>Note</dt><dd>This file may not be included directly. Applications must include <a class="el" href="crypto_8h.html" title="Platform Security Architecture cryptography module. ">psa/crypto.h</a>. Drivers must include the appropriate driver header file.</dd></dl>
-<p>This file contains portable definitions of integral types for properties of cryptographic keys, designations of cryptographic algorithms, and error codes returned by the library.</p>
-<p>This header file does not declare any function. </p>
-</div></div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/crypto__types_8h__dep__incl.map b/docs/html/crypto__types_8h__dep__incl.map
deleted file mode 100644
index 016a938..0000000
--- a/docs/html/crypto__types_8h__dep__incl.map
+++ /dev/null
@@ -1,3 +0,0 @@
-<map id="psa/crypto_types.h" name="psa/crypto_types.h">
-<area shape="rect" id="node2" href="$crypto_8h.html" title="Platform Security Architecture cryptography module. " alt="" coords="25,80,119,107"/>
-</map>
diff --git a/docs/html/crypto__types_8h__dep__incl.md5 b/docs/html/crypto__types_8h__dep__incl.md5
deleted file mode 100644
index cc8e252..0000000
--- a/docs/html/crypto__types_8h__dep__incl.md5
+++ /dev/null
@@ -1 +0,0 @@
-19ffd65c9274efafd90318d61b94f227
\ No newline at end of file
diff --git a/docs/html/crypto__types_8h__dep__incl.png b/docs/html/crypto__types_8h__dep__incl.png
deleted file mode 100644
index c1bd721..0000000
--- a/docs/html/crypto__types_8h__dep__incl.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/crypto__types_8h__incl.map b/docs/html/crypto__types_8h__incl.map
deleted file mode 100644
index 11067e3..0000000
--- a/docs/html/crypto__types_8h__incl.map
+++ /dev/null
@@ -1,2 +0,0 @@
-<map id="psa/crypto_types.h" name="psa/crypto_types.h">
-</map>
diff --git a/docs/html/crypto__types_8h__incl.md5 b/docs/html/crypto__types_8h__incl.md5
deleted file mode 100644
index a8f817c..0000000
--- a/docs/html/crypto__types_8h__incl.md5
+++ /dev/null
@@ -1 +0,0 @@
-db0e3c891220b01bcf6c8127efbdc53b
\ No newline at end of file
diff --git a/docs/html/crypto__types_8h__incl.png b/docs/html/crypto__types_8h__incl.png
deleted file mode 100644
index f23f127..0000000
--- a/docs/html/crypto__types_8h__incl.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/crypto__types_8h_source.html b/docs/html/crypto__types_8h_source.html
deleted file mode 100644
index 6eedd36..0000000
--- a/docs/html/crypto__types_8h_source.html
+++ /dev/null
@@ -1,109 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: psa/crypto_types.h Source File</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li class="current"><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
- <div id="navrow2" class="tabs2">
- <ul class="tablist">
- <li><a href="files.html"><span>File List</span></a></li>
- <li><a href="globals.html"><span>File Members</span></a></li>
- </ul>
- </div>
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div id="nav-path" class="navpath">
- <ul>
-<li class="navelem"><a class="el" href="dir_7dae9cfde651cd3cb034485ce5e391b9.html">psa</a></li> </ul>
-</div>
-</div><!-- top -->
-<div class="header">
- <div class="headertitle">
-<div class="title">crypto_types.h</div> </div>
-</div><!--header-->
-<div class="contents">
-<a href="crypto__types_8h.html">Go to the documentation of this file.</a><div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> </div><div class="line"><a name="l00016"></a><span class="lineno"> 16</span> <span class="comment">/*</span></div><div class="line"><a name="l00017"></a><span class="lineno"> 17</span> <span class="comment"> * Copyright (C) 2018, ARM Limited, All Rights Reserved</span></div><div class="line"><a name="l00018"></a><span class="lineno"> 18</span> <span class="comment"> * SPDX-License-Identifier: Apache-2.0</span></div><div class="line"><a name="l00019"></a><span class="lineno"> 19</span> <span class="comment"> *</span></div><div class="line"><a name="l00020"></a><span class="lineno"> 20</span> <span class="comment"> * Licensed under the Apache License, Version 2.0 (the "License"); you may</span></div><div class="line"><a name="l00021"></a><span class="lineno"> 21</span> <span class="comment"> * not use this file except in compliance with the License.</span></div><div class="line"><a name="l00022"></a><span class="lineno"> 22</span> <span class="comment"> * You may obtain a copy of the License at</span></div><div class="line"><a name="l00023"></a><span class="lineno"> 23</span> <span class="comment"> *</span></div><div class="line"><a name="l00024"></a><span class="lineno"> 24</span> <span class="comment"> * http://www.apache.org/licenses/LICENSE-2.0</span></div><div class="line"><a name="l00025"></a><span class="lineno"> 25</span> <span class="comment"> *</span></div><div class="line"><a name="l00026"></a><span class="lineno"> 26</span> <span class="comment"> * Unless required by applicable law or agreed to in writing, software</span></div><div class="line"><a name="l00027"></a><span class="lineno"> 27</span> <span class="comment"> * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT</span></div><div class="line"><a name="l00028"></a><span class="lineno"> 28</span> <span class="comment"> * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.</span></div><div class="line"><a name="l00029"></a><span class="lineno"> 29</span> <span class="comment"> * See the License for the specific language governing permissions and</span></div><div class="line"><a name="l00030"></a><span class="lineno"> 30</span> <span class="comment"> * limitations under the License.</span></div><div class="line"><a name="l00031"></a><span class="lineno"> 31</span> <span class="comment"> *</span></div><div class="line"><a name="l00032"></a><span class="lineno"> 32</span> <span class="comment"> * This file is part of mbed TLS (https://tls.mbed.org)</span></div><div class="line"><a name="l00033"></a><span class="lineno"> 33</span> <span class="comment"> */</span></div><div class="line"><a name="l00034"></a><span class="lineno"> 34</span> </div><div class="line"><a name="l00035"></a><span class="lineno"> 35</span> <span class="preprocessor">#ifndef PSA_CRYPTO_TYPES_H</span></div><div class="line"><a name="l00036"></a><span class="lineno"> 36</span> <span class="preprocessor">#define PSA_CRYPTO_TYPES_H</span></div><div class="line"><a name="l00037"></a><span class="lineno"> 37</span> </div><div class="line"><a name="l00038"></a><span class="lineno"> 38</span> <span class="preprocessor">#include <stdint.h></span></div><div class="line"><a name="l00039"></a><span class="lineno"> 39</span> </div><div class="line"><a name="l00051"></a><span class="lineno"><a class="line" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9"> 51</a></span> <span class="keyword">typedef</span> int32_t <a class="code" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>;</div><div class="line"><a name="l00052"></a><span class="lineno"> 52</span> </div><div class="line"><a name="l00061"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628"> 61</a></span> <span class="keyword">typedef</span> uint32_t <a class="code" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>;</div><div class="line"><a name="l00062"></a><span class="lineno"> 62</span> </div><div class="line"><a name="l00064"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9"> 64</a></span> <span class="keyword">typedef</span> uint16_t <a class="code" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>;</div><div class="line"><a name="l00065"></a><span class="lineno"> 65</span> </div><div class="line"><a name="l00074"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69"> 74</a></span> <span class="keyword">typedef</span> uint32_t <a class="code" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>;</div><div class="line"><a name="l00075"></a><span class="lineno"> 75</span> </div><div class="line"><a name="l00084"></a><span class="lineno"><a class="line" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf"> 84</a></span> <span class="keyword">typedef</span> uint32_t <a class="code" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">psa_key_lifetime_t</a>;</div><div class="line"><a name="l00085"></a><span class="lineno"> 85</span> </div><div class="line"><a name="l00088"></a><span class="lineno"><a class="line" href="group__key__lifetimes.html#ga11e986351c65bd3dc3c0fe2cd9926e4b"> 88</a></span> <span class="keyword">typedef</span> uint32_t <a class="code" href="group__key__lifetimes.html#ga11e986351c65bd3dc3c0fe2cd9926e4b">psa_key_id_t</a>;</div><div class="line"><a name="l00089"></a><span class="lineno"> 89</span> </div><div class="line"><a name="l00097"></a><span class="lineno"><a class="line" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25"> 97</a></span> <span class="keyword">typedef</span> uint32_t <a class="code" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a>;</div><div class="line"><a name="l00098"></a><span class="lineno"> 98</span> </div><div class="line"><a name="l00106"></a><span class="lineno"><a class="line" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b"> 106</a></span> <span class="keyword">typedef</span> uint16_t <a class="code" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">psa_key_derivation_step_t</a>;</div><div class="line"><a name="l00107"></a><span class="lineno"> 107</span> </div><div class="line"><a name="l00110"></a><span class="lineno"> 110</span> <span class="preprocessor">#endif </span><span class="comment">/* PSA_CRYPTO_TYPES_H */</span><span class="preprocessor"></span></div><div class="ttc" id="group__crypto__types_html_ga4e8977c145cce5077c4bce7fec890ad9"><div class="ttname"><a href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a></div><div class="ttdeci">uint16_t psa_ecc_curve_t</div><div class="ttdef"><b>Definition:</b> crypto_types.h:64</div></div>
-<div class="ttc" id="group__derivation_html_gaac4eeacd36596c548b3a48fc06c5048b"><div class="ttname"><a href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">psa_key_derivation_step_t</a></div><div class="ttdeci">uint16_t psa_key_derivation_step_t</div><div class="ttdoc">Encoding of the step of a key derivation. </div><div class="ttdef"><b>Definition:</b> crypto_types.h:106</div></div>
-<div class="ttc" id="group__key__lifetimes_html_ga11e986351c65bd3dc3c0fe2cd9926e4b"><div class="ttname"><a href="group__key__lifetimes.html#ga11e986351c65bd3dc3c0fe2cd9926e4b">psa_key_id_t</a></div><div class="ttdeci">uint32_t psa_key_id_t</div><div class="ttdef"><b>Definition:</b> crypto_types.h:88</div></div>
-<div class="ttc" id="group__crypto__types_html_gac2e4d47f1300d73c2f829a6d99252d69"><div class="ttname"><a href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a></div><div class="ttdeci">uint32_t psa_algorithm_t</div><div class="ttdoc">Encoding of a cryptographic algorithm. </div><div class="ttdef"><b>Definition:</b> crypto_types.h:74</div></div>
-<div class="ttc" id="group__policy_html_ga7bb9de71337e0e98de843aa7f9b55f25"><div class="ttname"><a href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a></div><div class="ttdeci">uint32_t psa_key_usage_t</div><div class="ttdoc">Encoding of permitted usage on a key. </div><div class="ttdef"><b>Definition:</b> crypto_types.h:97</div></div>
-<div class="ttc" id="group__crypto__types_html_ga578159487dfc7096cb191b0d2befe628"><div class="ttname"><a href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a></div><div class="ttdeci">uint32_t psa_key_type_t</div><div class="ttdoc">Encoding of a key type. </div><div class="ttdef"><b>Definition:</b> crypto_types.h:61</div></div>
-<div class="ttc" id="group__key__lifetimes_html_ga6821ff6dd39dc2bc370ded760ad8b0cf"><div class="ttname"><a href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">psa_key_lifetime_t</a></div><div class="ttdeci">uint32_t psa_key_lifetime_t</div><div class="ttdef"><b>Definition:</b> crypto_types.h:84</div></div>
-<div class="ttc" id="group__error_html_ga05676e70ba5c6a7565aff3c36677c1f9"><div class="ttname"><a href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a></div><div class="ttdeci">int32_t psa_status_t</div><div class="ttdoc">Function return status. </div><div class="ttdef"><b>Definition:</b> crypto_types.h:51</div></div>
-</div><!-- fragment --></div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/crypto__values_8h.html b/docs/html/crypto__values_8h.html
deleted file mode 100644
index 59328e4..0000000
--- a/docs/html/crypto__values_8h.html
+++ /dev/null
@@ -1,678 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: psa/crypto_values.h File Reference</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li class="current"><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
- <div id="navrow2" class="tabs2">
- <ul class="tablist">
- <li><a href="files.html"><span>File List</span></a></li>
- <li><a href="globals.html"><span>File Members</span></a></li>
- </ul>
- </div>
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div id="nav-path" class="navpath">
- <ul>
-<li class="navelem"><a class="el" href="dir_7dae9cfde651cd3cb034485ce5e391b9.html">psa</a></li> </ul>
-</div>
-</div><!-- top -->
-<div class="header">
- <div class="summary">
-<a href="#define-members">Macros</a> </div>
- <div class="headertitle">
-<div class="title">crypto_values.h File Reference</div> </div>
-</div><!--header-->
-<div class="contents">
-
-<p>PSA cryptography module: macros to build and analyze integer values.
-<a href="#details">More...</a></p>
-<div class="textblock"><div class="dynheader">
-This graph shows which files directly or indirectly include this file:</div>
-<div class="dyncontent">
-<div class="center"><img src="crypto__values_8h__dep__incl.png" border="0" usemap="#psa_2crypto__values_8hdep" alt=""/></div>
-<map name="psa_2crypto__values_8hdep" id="psa_2crypto__values_8hdep">
-<area shape="rect" id="node2" href="crypto_8h.html" title="Platform Security Architecture cryptography module. " alt="" coords="27,80,122,107"/>
-</map>
-</div>
-</div>
-<p><a href="crypto__values_8h_source.html">Go to the source code of this file.</a></p>
-<table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="define-members"></a>
-Macros</h2></td></tr>
-<tr class="memitem:ga4cc859e2c66ca381c7418db3527a65e1"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)0)</td></tr>
-<tr class="separator:ga4cc859e2c66ca381c7418db3527a65e1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga24d5fdcdd759f846f79d9e581c63a83f"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga24d5fdcdd759f846f79d9e581c63a83f">PSA_ERROR_UNKNOWN_ERROR</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)1)</td></tr>
-<tr class="separator:ga24d5fdcdd759f846f79d9e581c63a83f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1dcc6d130633ed5db8942257581b55dd"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)2)</td></tr>
-<tr class="separator:ga1dcc6d130633ed5db8942257581b55dd"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4d1b8dd8526177a15a210b7afc1accb1"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga4d1b8dd8526177a15a210b7afc1accb1">PSA_ERROR_NOT_PERMITTED</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)3)</td></tr>
-<tr class="separator:ga4d1b8dd8526177a15a210b7afc1accb1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga695025f4ec11249aee7ea3d0f65e01c8"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga695025f4ec11249aee7ea3d0f65e01c8">PSA_ERROR_BUFFER_TOO_SMALL</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)4)</td></tr>
-<tr class="separator:ga695025f4ec11249aee7ea3d0f65e01c8"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac2fee3a51249fbea45360aaa911f3e58"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#gac2fee3a51249fbea45360aaa911f3e58">PSA_ERROR_OCCUPIED_SLOT</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)5)</td></tr>
-<tr class="separator:gac2fee3a51249fbea45360aaa911f3e58"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaba00e3e6ceb2b12965a81e5ac02ae040"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040">PSA_ERROR_EMPTY_SLOT</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)6)</td></tr>
-<tr class="separator:gaba00e3e6ceb2b12965a81e5ac02ae040"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga933d40fa2a591004f2e93aa91e11db84"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)7)</td></tr>
-<tr class="separator:ga933d40fa2a591004f2e93aa91e11db84"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga798df25a505ebf931f7bec1f80f1f85f"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)8)</td></tr>
-<tr class="separator:ga798df25a505ebf931f7bec1f80f1f85f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga91b2ad8a867517a2651f1b076c5216e5"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)9)</td></tr>
-<tr class="separator:ga91b2ad8a867517a2651f1b076c5216e5"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga897a45eb206a6f6b7be7ffbe36f0d766"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga897a45eb206a6f6b7be7ffbe36f0d766">PSA_ERROR_INSUFFICIENT_STORAGE</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)10)</td></tr>
-<tr class="separator:ga897a45eb206a6f6b7be7ffbe36f0d766"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga5cdb6948371d49e916106249020ea3f7"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)11)</td></tr>
-<tr class="separator:ga5cdb6948371d49e916106249020ea3f7"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gadd169a1af2707862b95fb9df91dfc37d"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#gadd169a1af2707862b95fb9df91dfc37d">PSA_ERROR_STORAGE_FAILURE</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)12)</td></tr>
-<tr class="separator:gadd169a1af2707862b95fb9df91dfc37d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga08b10e70fa5ff0b05c631d9f8f6b2c6b"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)13)</td></tr>
-<tr class="separator:ga08b10e70fa5ff0b05c631d9f8f6b2c6b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga2c5dda1485cb54f2385cb9c1279a7004"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)14)</td></tr>
-<tr class="separator:ga2c5dda1485cb54f2385cb9c1279a7004"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4deb59fec02297ec5d8b42178323f675"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga4deb59fec02297ec5d8b42178323f675">PSA_ERROR_INSUFFICIENT_ENTROPY</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)15)</td></tr>
-<tr class="separator:ga4deb59fec02297ec5d8b42178323f675"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga35927f755d232c4766de600f2c49e9f2"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga35927f755d232c4766de600f2c49e9f2">PSA_ERROR_INVALID_SIGNATURE</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)16)</td></tr>
-<tr class="separator:ga35927f755d232c4766de600f2c49e9f2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gabe29594edbfb152cf153975b0597ac48"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#gabe29594edbfb152cf153975b0597ac48">PSA_ERROR_INVALID_PADDING</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)17)</td></tr>
-<tr class="separator:gabe29594edbfb152cf153975b0597ac48"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaf1fa61f72e9e5b4a848c991bea495767"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#gaf1fa61f72e9e5b4a848c991bea495767">PSA_ERROR_INSUFFICIENT_CAPACITY</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)18)</td></tr>
-<tr class="separator:gaf1fa61f72e9e5b4a848c991bea495767"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gadf22718935657c2c3168c228204085f9"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)19)</td></tr>
-<tr class="separator:gadf22718935657c2c3168c228204085f9"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gafce7ab2b54ce97ea5bff73f13a9f3e5b"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gafce7ab2b54ce97ea5bff73f13a9f3e5b">PSA_KEY_TYPE_NONE</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x00000000)</td></tr>
-<tr class="separator:gafce7ab2b54ce97ea5bff73f13a9f3e5b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga8dbaed2fdb1ebae8aa127ad3988516f7"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga8dbaed2fdb1ebae8aa127ad3988516f7">PSA_KEY_TYPE_VENDOR_FLAG</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x80000000)</td></tr>
-<tr class="separator:ga8dbaed2fdb1ebae8aa127ad3988516f7"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6eeda1b2a1550050cf68dbcac35ad8ac"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_TYPE_CATEGORY_MASK</b>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x70000000)</td></tr>
-<tr class="separator:ga6eeda1b2a1550050cf68dbcac35ad8ac"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga8f214beb04334be08f927f227f097ef1"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_TYPE_CATEGORY_SYMMETRIC</b>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x40000000)</td></tr>
-<tr class="separator:ga8f214beb04334be08f927f227f097ef1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab8af75718c5e7b8987720a3fe8abb18f"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_TYPE_CATEGORY_RAW</b>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x50000000)</td></tr>
-<tr class="separator:gab8af75718c5e7b8987720a3fe8abb18f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga58b975beeee1f937cecb71c8051c6357"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY</b>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x60000000)</td></tr>
-<tr class="separator:ga58b975beeee1f937cecb71c8051c6357"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga708196a91ec0384de98e092b9a16f5e8"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_TYPE_CATEGORY_KEY_PAIR</b>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x70000000)</td></tr>
-<tr class="separator:ga708196a91ec0384de98e092b9a16f5e8"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga5a77cb4db2d02ffce77631339e3240f4"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_TYPE_CATEGORY_FLAG_PAIR</b>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x10000000)</td></tr>
-<tr class="separator:ga5a77cb4db2d02ffce77631339e3240f4"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gadbe4c086a6562aefe344bc79e51bdfd3"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gadbe4c086a6562aefe344bc79e51bdfd3">PSA_KEY_TYPE_IS_VENDOR_DEFINED</a>(type)   (((type) & <a class="el" href="group__crypto__types.html#ga8dbaed2fdb1ebae8aa127ad3988516f7">PSA_KEY_TYPE_VENDOR_FLAG</a>) != 0)</td></tr>
-<tr class="separator:gadbe4c086a6562aefe344bc79e51bdfd3"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaef86ce4e810e1c2c76068ac874bfef54"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaef86ce4e810e1c2c76068ac874bfef54">PSA_KEY_TYPE_IS_UNSTRUCTURED</a>(type)</td></tr>
-<tr class="separator:gaef86ce4e810e1c2c76068ac874bfef54"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab138ae2ebf2905dfbaf4154db2620939"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gab138ae2ebf2905dfbaf4154db2620939">PSA_KEY_TYPE_IS_ASYMMETRIC</a>(type)</td></tr>
-<tr class="separator:gab138ae2ebf2905dfbaf4154db2620939"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac674a0f059bc0cb72b47f0c517b4f45b"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gac674a0f059bc0cb72b47f0c517b4f45b">PSA_KEY_TYPE_IS_PUBLIC_KEY</a>(type)   (((type) & PSA_KEY_TYPE_CATEGORY_MASK) == PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY)</td></tr>
-<tr class="separator:gac674a0f059bc0cb72b47f0c517b4f45b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac14c6d6e1b2b7f4a92a7b757465cff29"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gac14c6d6e1b2b7f4a92a7b757465cff29">PSA_KEY_TYPE_IS_KEYPAIR</a>(type)   (((type) & PSA_KEY_TYPE_CATEGORY_MASK) == PSA_KEY_TYPE_CATEGORY_KEY_PAIR)</td></tr>
-<tr class="separator:gac14c6d6e1b2b7f4a92a7b757465cff29"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaf09f1ca1de6a7e7cff0fe516f3f6c91d"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaf09f1ca1de6a7e7cff0fe516f3f6c91d">PSA_KEY_TYPE_KEYPAIR_OF_PUBLIC_KEY</a>(type)   ((type) | PSA_KEY_TYPE_CATEGORY_FLAG_PAIR)</td></tr>
-<tr class="separator:gaf09f1ca1de6a7e7cff0fe516f3f6c91d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gace08e46dd7cbf642d50d982a25d02bec"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gace08e46dd7cbf642d50d982a25d02bec">PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR</a>(type)   ((type) & ~PSA_KEY_TYPE_CATEGORY_FLAG_PAIR)</td></tr>
-<tr class="separator:gace08e46dd7cbf642d50d982a25d02bec"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa97f92025533102616b32d571c940d80"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaa97f92025533102616b32d571c940d80">PSA_KEY_TYPE_RAW_DATA</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x50000001)</td></tr>
-<tr class="separator:gaa97f92025533102616b32d571c940d80"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga92d989f4ca64abd00f463defd773a6f8"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga92d989f4ca64abd00f463defd773a6f8">PSA_KEY_TYPE_HMAC</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x51000000)</td></tr>
-<tr class="separator:ga92d989f4ca64abd00f463defd773a6f8"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae871b2357b8593f33bfd51abbf93ebb1"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gae871b2357b8593f33bfd51abbf93ebb1">PSA_KEY_TYPE_DERIVE</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x52000000)</td></tr>
-<tr class="separator:gae871b2357b8593f33bfd51abbf93ebb1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6ee54579dcf278c677eda4bb1a29575e"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga6ee54579dcf278c677eda4bb1a29575e">PSA_KEY_TYPE_AES</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x40000001)</td></tr>
-<tr class="separator:ga6ee54579dcf278c677eda4bb1a29575e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga577562bfbbc691c820d55ec308333138"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga577562bfbbc691c820d55ec308333138">PSA_KEY_TYPE_DES</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x40000002)</td></tr>
-<tr class="separator:ga577562bfbbc691c820d55ec308333138"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gad8e5da742343fd5519f9d8a630c2ed81"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gad8e5da742343fd5519f9d8a630c2ed81">PSA_KEY_TYPE_CAMELLIA</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x40000003)</td></tr>
-<tr class="separator:gad8e5da742343fd5519f9d8a630c2ed81"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae4d46e83f910dcaa126000a8ed03cde9"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gae4d46e83f910dcaa126000a8ed03cde9">PSA_KEY_TYPE_ARC4</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x40000004)</td></tr>
-<tr class="separator:gae4d46e83f910dcaa126000a8ed03cde9"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga9ba0878f56c8bcd1995ac017a74f513b"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga9ba0878f56c8bcd1995ac017a74f513b">PSA_KEY_TYPE_RSA_PUBLIC_KEY</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x60010000)</td></tr>
-<tr class="separator:ga9ba0878f56c8bcd1995ac017a74f513b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga581f50687f5d650456925278948f2799"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga581f50687f5d650456925278948f2799">PSA_KEY_TYPE_RSA_KEYPAIR</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x70010000)</td></tr>
-<tr class="separator:ga581f50687f5d650456925278948f2799"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga0e1d8f241228e49c9cadadfb4579ef1a"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga0e1d8f241228e49c9cadadfb4579ef1a">PSA_KEY_TYPE_IS_RSA</a>(type)   (<a class="el" href="group__crypto__types.html#gace08e46dd7cbf642d50d982a25d02bec">PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR</a>(type) == <a class="el" href="group__crypto__types.html#ga9ba0878f56c8bcd1995ac017a74f513b">PSA_KEY_TYPE_RSA_PUBLIC_KEY</a>)</td></tr>
-<tr class="separator:ga0e1d8f241228e49c9cadadfb4579ef1a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga5e7439c2905136366c3a876e62e5ddfc"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga5e7439c2905136366c3a876e62e5ddfc">PSA_KEY_TYPE_DSA_PUBLIC_KEY</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x60020000)</td></tr>
-<tr class="separator:ga5e7439c2905136366c3a876e62e5ddfc"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga011010ee28c20388f3d89fb27088ed62"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga011010ee28c20388f3d89fb27088ed62">PSA_KEY_TYPE_DSA_KEYPAIR</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x70020000)</td></tr>
-<tr class="separator:ga011010ee28c20388f3d89fb27088ed62"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga273fdfcf23eb0624f8b63d2321cf95c1"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga273fdfcf23eb0624f8b63d2321cf95c1">PSA_KEY_TYPE_IS_DSA</a>(type)   (<a class="el" href="group__crypto__types.html#gace08e46dd7cbf642d50d982a25d02bec">PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR</a>(type) == <a class="el" href="group__crypto__types.html#ga5e7439c2905136366c3a876e62e5ddfc">PSA_KEY_TYPE_DSA_PUBLIC_KEY</a>)</td></tr>
-<tr class="separator:ga273fdfcf23eb0624f8b63d2321cf95c1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gad8d37a32a305dda9fb4af1707aace47c"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE</b>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x60030000)</td></tr>
-<tr class="separator:gad8d37a32a305dda9fb4af1707aace47c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6754658749714c6ac674bdf6d2d40767"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_TYPE_ECC_KEYPAIR_BASE</b>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x70030000)</td></tr>
-<tr class="separator:ga6754658749714c6ac674bdf6d2d40767"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gadc2a3c0041ac1d0a2b6f421d8e089b25"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_TYPE_ECC_CURVE_MASK</b>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x0000ffff)</td></tr>
-<tr class="separator:gadc2a3c0041ac1d0a2b6f421d8e089b25"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gadf3ad65d157bf5282849c954bf3f51af"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gadf3ad65d157bf5282849c954bf3f51af">PSA_KEY_TYPE_ECC_KEYPAIR</a>(curve)   (PSA_KEY_TYPE_ECC_KEYPAIR_BASE | (curve))</td></tr>
-<tr class="separator:gadf3ad65d157bf5282849c954bf3f51af"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gad54c03d3b47020e571a72cd01d978cf2"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gad54c03d3b47020e571a72cd01d978cf2">PSA_KEY_TYPE_ECC_PUBLIC_KEY</a>(curve)   (PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE | (curve))</td></tr>
-<tr class="separator:gad54c03d3b47020e571a72cd01d978cf2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga88e01fa06b585654689a99bcc06bbe66"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga88e01fa06b585654689a99bcc06bbe66">PSA_KEY_TYPE_IS_ECC</a>(type)</td></tr>
-<tr class="separator:ga88e01fa06b585654689a99bcc06bbe66"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga7bf101b671e8cf26f4cb08fcb679db4b"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga7bf101b671e8cf26f4cb08fcb679db4b">PSA_KEY_TYPE_IS_ECC_KEYPAIR</a>(type)</td></tr>
-<tr class="separator:ga7bf101b671e8cf26f4cb08fcb679db4b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga5af146a173b0c84d7e737e2fb6a3c0a7"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga5af146a173b0c84d7e737e2fb6a3c0a7">PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY</a>(type)</td></tr>
-<tr class="separator:ga5af146a173b0c84d7e737e2fb6a3c0a7"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga0c567210e6f80aa8f2aa87efa7a3a3f9"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga0c567210e6f80aa8f2aa87efa7a3a3f9">PSA_KEY_TYPE_GET_CURVE</a>(type)</td></tr>
-<tr class="separator:ga0c567210e6f80aa8f2aa87efa7a3a3f9"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4201013d5947c375fae7311b0f98bac7"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT163K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0001)</td></tr>
-<tr class="separator:ga4201013d5947c375fae7311b0f98bac7"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaca8816b785f492a8795b5276977d1369"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT163R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0002)</td></tr>
-<tr class="separator:gaca8816b785f492a8795b5276977d1369"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4ab7a853ceb3ad0a525ecb571633a1ca"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT163R2</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0003)</td></tr>
-<tr class="separator:ga4ab7a853ceb3ad0a525ecb571633a1ca"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac9fd11da90ca67649a5f51a158afe5f3"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT193R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0004)</td></tr>
-<tr class="separator:gac9fd11da90ca67649a5f51a158afe5f3"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga7a77f5e385f6439dae5857a7f35756eb"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT193R2</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0005)</td></tr>
-<tr class="separator:ga7a77f5e385f6439dae5857a7f35756eb"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga36e409c36983e41db5db202b1d2095b5"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT233K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0006)</td></tr>
-<tr class="separator:ga36e409c36983e41db5db202b1d2095b5"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga54997a9f8ef752c6d717171e01c31019"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT233R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0007)</td></tr>
-<tr class="separator:ga54997a9f8ef752c6d717171e01c31019"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaabccf2759188c3e98d82faa5d8dfcd8c"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT239K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0008)</td></tr>
-<tr class="separator:gaabccf2759188c3e98d82faa5d8dfcd8c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga28c765d75773b5fe083219e7c0b054f9"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT283K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0009)</td></tr>
-<tr class="separator:ga28c765d75773b5fe083219e7c0b054f9"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gafd8ecacea0d9e7e1a0247c047baf3372"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT283R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x000a)</td></tr>
-<tr class="separator:gafd8ecacea0d9e7e1a0247c047baf3372"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga2bf301617cc84a6f2b36a86cc29eaf4d"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT409K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x000b)</td></tr>
-<tr class="separator:ga2bf301617cc84a6f2b36a86cc29eaf4d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae41caa1cc16d3c35769b6edcb62c8957"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT409R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x000c)</td></tr>
-<tr class="separator:gae41caa1cc16d3c35769b6edcb62c8957"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga2043aa519549a6194d132d81816879bc"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT571K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x000d)</td></tr>
-<tr class="separator:ga2043aa519549a6194d132d81816879bc"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1607d2cb9591b56dbe1295bedc33e19e"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT571R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x000e)</td></tr>
-<tr class="separator:ga1607d2cb9591b56dbe1295bedc33e19e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga2ad14935d244d93ee0e4cfe9b1f218a4"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP160K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x000f)</td></tr>
-<tr class="separator:ga2ad14935d244d93ee0e4cfe9b1f218a4"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga35ed41203039e94eb4855cc70f28f7f0"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP160R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0010)</td></tr>
-<tr class="separator:ga35ed41203039e94eb4855cc70f28f7f0"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac465f57c34914a01aea8c220a613dfe6"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP160R2</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0011)</td></tr>
-<tr class="separator:gac465f57c34914a01aea8c220a613dfe6"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga58c806d45ab350287ddc49da833bd558"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP192K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0012)</td></tr>
-<tr class="separator:ga58c806d45ab350287ddc49da833bd558"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga5aa3ceff4603fa3fafd8f2286c5d3e4a"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP192R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0013)</td></tr>
-<tr class="separator:ga5aa3ceff4603fa3fafd8f2286c5d3e4a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gabfaaab2eaab0ac360e41c1aff6133cdf"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP224K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0014)</td></tr>
-<tr class="separator:gabfaaab2eaab0ac360e41c1aff6133cdf"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga8d1d21b6b87ba4158235b876ae79031d"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP224R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0015)</td></tr>
-<tr class="separator:ga8d1d21b6b87ba4158235b876ae79031d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaaa61941f815aff976a1debd910b1704c"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP256K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0016)</td></tr>
-<tr class="separator:gaaa61941f815aff976a1debd910b1704c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga11224270225c2b2dbfa2ab01073a4e93"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP256R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0017)</td></tr>
-<tr class="separator:ga11224270225c2b2dbfa2ab01073a4e93"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga3e870a36493143507a01a28c70790fa3"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP384R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0018)</td></tr>
-<tr class="separator:ga3e870a36493143507a01a28c70790fa3"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4482ff6155006ff509071c32ce263fdf"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP521R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0019)</td></tr>
-<tr class="separator:ga4482ff6155006ff509071c32ce263fdf"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa999b69c56af0cc1cebf4596f8578191"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_BRAINPOOL_P256R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x001a)</td></tr>
-<tr class="separator:gaa999b69c56af0cc1cebf4596f8578191"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga79f95ed8050f2dc7750cbac212c6e687"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_BRAINPOOL_P384R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x001b)</td></tr>
-<tr class="separator:ga79f95ed8050f2dc7750cbac212c6e687"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa03a2dc6096f336be3d68a1f7405e86c"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_BRAINPOOL_P512R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x001c)</td></tr>
-<tr class="separator:gaa03a2dc6096f336be3d68a1f7405e86c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac94faf3b8d9884221541f51f26b11c7a"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_CURVE25519</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x001d)</td></tr>
-<tr class="separator:gac94faf3b8d9884221541f51f26b11c7a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga902b0e91eff920873b3b59c740854305"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_CURVE448</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x001e)</td></tr>
-<tr class="separator:ga902b0e91eff920873b3b59c740854305"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga325a340d7c72d99d3a678eb210bf6e0a"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga325a340d7c72d99d3a678eb210bf6e0a">PSA_KEY_TYPE_DH_PUBLIC_KEY</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x60040000)</td></tr>
-<tr class="separator:ga325a340d7c72d99d3a678eb210bf6e0a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga39b63c6b97a62a316c0660bf72b2fdd5"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga39b63c6b97a62a316c0660bf72b2fdd5">PSA_KEY_TYPE_DH_KEYPAIR</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x70040000)</td></tr>
-<tr class="separator:ga39b63c6b97a62a316c0660bf72b2fdd5"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga248ae35c0e2becaebbf479fc1c3a3b0e"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga248ae35c0e2becaebbf479fc1c3a3b0e">PSA_KEY_TYPE_IS_DH</a>(type)   (<a class="el" href="group__crypto__types.html#gace08e46dd7cbf642d50d982a25d02bec">PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR</a>(type) == <a class="el" href="group__crypto__types.html#ga325a340d7c72d99d3a678eb210bf6e0a">PSA_KEY_TYPE_DH_PUBLIC_KEY</a>)</td></tr>
-<tr class="separator:ga248ae35c0e2becaebbf479fc1c3a3b0e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gacaa366bdeb0413e63e87a667c5457b2e"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gacaa366bdeb0413e63e87a667c5457b2e">PSA_BLOCK_CIPHER_BLOCK_SIZE</a>(type)</td></tr>
-<tr class="separator:gacaa366bdeb0413e63e87a667c5457b2e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaf5d76750b6cfe3e7f0c8e9eee1162318"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_VENDOR_FLAG</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x80000000)</td></tr>
-<tr class="separator:gaf5d76750b6cfe3e7f0c8e9eee1162318"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga25e918c465b4421dbfaedad6b693d110"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CATEGORY_MASK</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x7f000000)</td></tr>
-<tr class="separator:ga25e918c465b4421dbfaedad6b693d110"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gafd048e1835b80e6daaff7fddce699757"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CATEGORY_HASH</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000000)</td></tr>
-<tr class="separator:gafd048e1835b80e6daaff7fddce699757"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga5e6e0039d0b0d18afb3e13e5b9602b3a"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CATEGORY_MAC</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x02000000)</td></tr>
-<tr class="separator:ga5e6e0039d0b0d18afb3e13e5b9602b3a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga68228a619db59eba93fd13e9129dbfe2"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CATEGORY_CIPHER</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x04000000)</td></tr>
-<tr class="separator:ga68228a619db59eba93fd13e9129dbfe2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga37fdd9cac2552f1568f38e091a826549"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CATEGORY_AEAD</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x06000000)</td></tr>
-<tr class="separator:ga37fdd9cac2552f1568f38e091a826549"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga68a0af1dd89b33fb1e53139f654988f6"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CATEGORY_SIGN</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x10000000)</td></tr>
-<tr class="separator:ga68a0af1dd89b33fb1e53139f654988f6"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga72f46c8256b760b174e6db61a61cd608"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x12000000)</td></tr>
-<tr class="separator:ga72f46c8256b760b174e6db61a61cd608"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac185b2274dd4e5f0b97c43334c2e478f"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CATEGORY_KEY_DERIVATION</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x20000000)</td></tr>
-<tr class="separator:gac185b2274dd4e5f0b97c43334c2e478f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga808e397a4891c612df4a5b20eebc2fac"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CATEGORY_KEY_AGREEMENT</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x30000000)</td></tr>
-<tr class="separator:ga808e397a4891c612df4a5b20eebc2fac"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga2396d8ba67096b3ebc69bc351a74c78b"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_VENDOR_DEFINED</b>(alg)   (((alg) & PSA_ALG_VENDOR_FLAG) != 0)</td></tr>
-<tr class="separator:ga2396d8ba67096b3ebc69bc351a74c78b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac9280662bb482590b4b33d1dcd32930f"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gac9280662bb482590b4b33d1dcd32930f">PSA_ALG_IS_HASH</a>(alg)   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_HASH)</td></tr>
-<tr class="separator:gac9280662bb482590b4b33d1dcd32930f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaca7aee4c9dde316b3b1a150a26eab776"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaca7aee4c9dde316b3b1a150a26eab776">PSA_ALG_IS_MAC</a>(alg)   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_MAC)</td></tr>
-<tr class="separator:gaca7aee4c9dde316b3b1a150a26eab776"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1d1a5a402ad89a2e68f12bfb535490eb"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga1d1a5a402ad89a2e68f12bfb535490eb">PSA_ALG_IS_CIPHER</a>(alg)   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_CIPHER)</td></tr>
-<tr class="separator:ga1d1a5a402ad89a2e68f12bfb535490eb"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1d44829d60065eaa4ac9a703e7d6abc8"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga1d44829d60065eaa4ac9a703e7d6abc8">PSA_ALG_IS_AEAD</a>(alg)   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_AEAD)</td></tr>
-<tr class="separator:ga1d44829d60065eaa4ac9a703e7d6abc8"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6d490d0904e0698f6c1268a89d72ff31"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga6d490d0904e0698f6c1268a89d72ff31">PSA_ALG_IS_SIGN</a>(alg)   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_SIGN)</td></tr>
-<tr class="separator:ga6d490d0904e0698f6c1268a89d72ff31"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga41d2ee937d54efd76bd54a97b2ebc08a"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga41d2ee937d54efd76bd54a97b2ebc08a">PSA_ALG_IS_ASYMMETRIC_ENCRYPTION</a>(alg)   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION)</td></tr>
-<tr class="separator:ga41d2ee937d54efd76bd54a97b2ebc08a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga59753742cb06553bd22751bbef472b6f"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga59753742cb06553bd22751bbef472b6f">PSA_ALG_IS_KEY_AGREEMENT</a>(alg)   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_KEY_AGREEMENT)</td></tr>
-<tr class="separator:ga59753742cb06553bd22751bbef472b6f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaf8b90c648aa53dbd06c236695e300cd0"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaf8b90c648aa53dbd06c236695e300cd0">PSA_ALG_IS_KEY_DERIVATION</a>(alg)   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_KEY_DERIVATION)</td></tr>
-<tr class="separator:gaf8b90c648aa53dbd06c236695e300cd0"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac41a7077aef55bb20c629c8949d43c57"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_HASH_MASK</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x000000ff)</td></tr>
-<tr class="separator:gac41a7077aef55bb20c629c8949d43c57"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab076ca67238cb4ebd81556db8f3dbac1"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_MD2</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000001)</td></tr>
-<tr class="separator:gab076ca67238cb4ebd81556db8f3dbac1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaac7ab8c28c117ef4ddf01affc8d3ceb2"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_MD4</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000002)</td></tr>
-<tr class="separator:gaac7ab8c28c117ef4ddf01affc8d3ceb2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gade591d9286d23382eb5cec099c84180d"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_MD5</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000003)</td></tr>
-<tr class="separator:gade591d9286d23382eb5cec099c84180d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6c5d3a32cda59086f07b85ef007033dd"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_RIPEMD160</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000004)</td></tr>
-<tr class="separator:ga6c5d3a32cda59086f07b85ef007033dd"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga3fca4e9f9ad4a1158817d1850dee82e5"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_SHA_1</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000005)</td></tr>
-<tr class="separator:ga3fca4e9f9ad4a1158817d1850dee82e5"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga25d6a3244d10a7148fe6b026d1979f7b"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga25d6a3244d10a7148fe6b026d1979f7b">PSA_ALG_SHA_224</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000008)</td></tr>
-<tr class="separator:ga25d6a3244d10a7148fe6b026d1979f7b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga619471f978e13cdd0a1e37145e4bf341"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga619471f978e13cdd0a1e37145e4bf341">PSA_ALG_SHA_256</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000009)</td></tr>
-<tr class="separator:ga619471f978e13cdd0a1e37145e4bf341"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga58af64dd9a86a287e8da9ed7739eead4"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga58af64dd9a86a287e8da9ed7739eead4">PSA_ALG_SHA_384</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x0100000a)</td></tr>
-<tr class="separator:ga58af64dd9a86a287e8da9ed7739eead4"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gafba3ae409f46d3dd7f37a0910660c3e9"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gafba3ae409f46d3dd7f37a0910660c3e9">PSA_ALG_SHA_512</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x0100000b)</td></tr>
-<tr class="separator:gafba3ae409f46d3dd7f37a0910660c3e9"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga3fe2d7c3c80e3186ca78d16a35d5d931"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga3fe2d7c3c80e3186ca78d16a35d5d931">PSA_ALG_SHA_512_224</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x0100000c)</td></tr>
-<tr class="separator:ga3fe2d7c3c80e3186ca78d16a35d5d931"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga5910b3964c14e9613e8643a45b09c2d4"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga5910b3964c14e9613e8643a45b09c2d4">PSA_ALG_SHA_512_256</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x0100000d)</td></tr>
-<tr class="separator:ga5910b3964c14e9613e8643a45b09c2d4"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga16f5fe34ccce68c2fada1224c054a999"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga16f5fe34ccce68c2fada1224c054a999">PSA_ALG_SHA3_224</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000010)</td></tr>
-<tr class="separator:ga16f5fe34ccce68c2fada1224c054a999"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaace70d9515489bbe3c5e7ac1b7d9155b"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaace70d9515489bbe3c5e7ac1b7d9155b">PSA_ALG_SHA3_256</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000011)</td></tr>
-<tr class="separator:gaace70d9515489bbe3c5e7ac1b7d9155b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab0f079257ea75e2acfe2fc3b38c78cd8"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gab0f079257ea75e2acfe2fc3b38c78cd8">PSA_ALG_SHA3_384</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000012)</td></tr>
-<tr class="separator:gab0f079257ea75e2acfe2fc3b38c78cd8"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga37e5dbe936dddb155e76f2997de27188"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga37e5dbe936dddb155e76f2997de27188">PSA_ALG_SHA3_512</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000013)</td></tr>
-<tr class="separator:ga37e5dbe936dddb155e76f2997de27188"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa1288ea8bd397a8a3f5e19e94110f2e4"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaa1288ea8bd397a8a3f5e19e94110f2e4">PSA_ALG_ANY_HASH</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x010000ff)</td></tr>
-<tr class="separator:gaa1288ea8bd397a8a3f5e19e94110f2e4"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gabba3fcfee55533b0e25350e78a942e07"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_MAC_SUBCATEGORY_MASK</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x00c00000)</td></tr>
-<tr class="separator:gabba3fcfee55533b0e25350e78a942e07"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga0675192b82720fb8c9037a95bdeb6c88"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_HMAC_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x02800000)</td></tr>
-<tr class="separator:ga0675192b82720fb8c9037a95bdeb6c88"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga70f397425684b3efcde1e0e34c28261f"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga70f397425684b3efcde1e0e34c28261f">PSA_ALG_HMAC</a>(hash_alg)   (PSA_ALG_HMAC_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga70f397425684b3efcde1e0e34c28261f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaee84269106a947cb6ac353e15e6c4687"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_HMAC_GET_HASH</b>(hmac_alg)   (PSA_ALG_CATEGORY_HASH | ((hmac_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:gaee84269106a947cb6ac353e15e6c4687"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4a050c3c3cbc6eb96418f18847601c8a"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga4a050c3c3cbc6eb96418f18847601c8a">PSA_ALG_IS_HMAC</a>(alg)</td></tr>
-<tr class="separator:ga4a050c3c3cbc6eb96418f18847601c8a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga8c48784065c65c623a21b9a3ccc56b1d"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_MAC_TRUNCATION_MASK</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x00003f00)</td></tr>
-<tr class="separator:ga8c48784065c65c623a21b9a3ccc56b1d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6db5ce573e6ad52068aba31c3afdce31"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_MAC_TRUNCATION_OFFSET</b>   8</td></tr>
-<tr class="separator:ga6db5ce573e6ad52068aba31c3afdce31"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaf36137110baf7bb13c5028fd62c64276"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaf36137110baf7bb13c5028fd62c64276">PSA_ALG_TRUNCATED_MAC</a>(alg, mac_length)</td></tr>
-<tr class="separator:gaf36137110baf7bb13c5028fd62c64276"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa05a8d99634f3350597ac9284fb70cb1"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaa05a8d99634f3350597ac9284fb70cb1">PSA_ALG_FULL_LENGTH_MAC</a>(alg)   ((alg) & ~PSA_ALG_MAC_TRUNCATION_MASK)</td></tr>
-<tr class="separator:gaa05a8d99634f3350597ac9284fb70cb1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab03726c4476174e019a08e2a04018ce8"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gab03726c4476174e019a08e2a04018ce8">PSA_MAC_TRUNCATED_LENGTH</a>(alg)   (((alg) & PSA_ALG_MAC_TRUNCATION_MASK) >> PSA_MAC_TRUNCATION_OFFSET)</td></tr>
-<tr class="separator:gab03726c4476174e019a08e2a04018ce8"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaee0c29980b08305f6d0e7b3fbb588ade"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CIPHER_MAC_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x02c00000)</td></tr>
-<tr class="separator:gaee0c29980b08305f6d0e7b3fbb588ade"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga20bdc755de7b90f6621ccb1e6bb5d9e1"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CBC_MAC</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x02c00001)</td></tr>
-<tr class="separator:ga20bdc755de7b90f6621ccb1e6bb5d9e1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga146328a1e0023a02464e232d6ecefdc2"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CMAC</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x02c00002)</td></tr>
-<tr class="separator:ga146328a1e0023a02464e232d6ecefdc2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga69a012ce150219a2d97c3ab5582f0004"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_GMAC</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x02c00003)</td></tr>
-<tr class="separator:ga69a012ce150219a2d97c3ab5582f0004"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae49d1eb601125d65a5c5b252aa45479e"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gae49d1eb601125d65a5c5b252aa45479e">PSA_ALG_IS_BLOCK_CIPHER_MAC</a>(alg)</td></tr>
-<tr class="separator:gae49d1eb601125d65a5c5b252aa45479e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac79618293c4254143caa75f6c5c82fa1"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CIPHER_STREAM_FLAG</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x00800000)</td></tr>
-<tr class="separator:gac79618293c4254143caa75f6c5c82fa1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gabc80d19d140032e3b138db4ed37d0bd7"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CIPHER_FROM_BLOCK_FLAG</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x00400000)</td></tr>
-<tr class="separator:gabc80d19d140032e3b138db4ed37d0bd7"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gacfec68e0c6175e02e1b2ebc97df383c0"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gacfec68e0c6175e02e1b2ebc97df383c0">PSA_ALG_IS_STREAM_CIPHER</a>(alg)</td></tr>
-<tr class="separator:gacfec68e0c6175e02e1b2ebc97df383c0"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab6a5284decb0e5e1b5b8740a41ef3c5e"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gab6a5284decb0e5e1b5b8740a41ef3c5e">PSA_ALG_ARC4</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x04800001)</td></tr>
-<tr class="separator:gab6a5284decb0e5e1b5b8740a41ef3c5e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gad318309706a769cffdc64e4c7e06b2e9"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gad318309706a769cffdc64e4c7e06b2e9">PSA_ALG_CTR</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x04c00001)</td></tr>
-<tr class="separator:gad318309706a769cffdc64e4c7e06b2e9"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga0088c933e01d671f263a9a1f177cb5bc"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CFB</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x04c00002)</td></tr>
-<tr class="separator:ga0088c933e01d671f263a9a1f177cb5bc"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae96bb421fa634c6fa8f571f0112f1ddb"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_OFB</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x04c00003)</td></tr>
-<tr class="separator:gae96bb421fa634c6fa8f571f0112f1ddb"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa722c0e426a797fd6d99623f59748125"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaa722c0e426a797fd6d99623f59748125">PSA_ALG_XTS</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x044000ff)</td></tr>
-<tr class="separator:gaa722c0e426a797fd6d99623f59748125"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gacb332d72716958880ee7f97d8365ae66"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gacb332d72716958880ee7f97d8365ae66">PSA_ALG_CBC_NO_PADDING</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x04600100)</td></tr>
-<tr class="separator:gacb332d72716958880ee7f97d8365ae66"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaef50d2e9716eb6d476046608e4e0c78c"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaef50d2e9716eb6d476046608e4e0c78c">PSA_ALG_CBC_PKCS7</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x04600101)</td></tr>
-<tr class="separator:gaef50d2e9716eb6d476046608e4e0c78c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac2c0e7d21f1b2df5e76bcb4a8f84273c"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gac2c0e7d21f1b2df5e76bcb4a8f84273c">PSA_ALG_CCM</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x06001001)</td></tr>
-<tr class="separator:gac2c0e7d21f1b2df5e76bcb4a8f84273c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga0d7d02b15aaae490d38277d99f1c637c"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga0d7d02b15aaae490d38277d99f1c637c">PSA_ALG_GCM</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x06001002)</td></tr>
-<tr class="separator:ga0d7d02b15aaae490d38277d99f1c637c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga575d9082463a06a86c2a22dd63c2e772"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_AEAD_TAG_LENGTH_MASK</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x00003f00)</td></tr>
-<tr class="separator:ga575d9082463a06a86c2a22dd63c2e772"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga987d416146048906d40dd1d9572e3193"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_AEAD_TAG_LENGTH_OFFSET</b>   8</td></tr>
-<tr class="separator:ga987d416146048906d40dd1d9572e3193"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa63c520b62ab001d54d28801742fc9db"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaa63c520b62ab001d54d28801742fc9db">PSA_ALG_AEAD_WITH_TAG_LENGTH</a>(alg, tag_length)</td></tr>
-<tr class="separator:gaa63c520b62ab001d54d28801742fc9db"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaddea507e062250cda8a29407a9480d2b"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaddea507e062250cda8a29407a9480d2b">PSA_ALG_AEAD_WITH_DEFAULT_TAG_LENGTH</a>(alg)</td></tr>
-<tr class="separator:gaddea507e062250cda8a29407a9480d2b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6e52012ca3be6acb4c756c372f18c3eb"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><b>PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE</b>(alg, ref)</td></tr>
-<tr class="separator:ga6e52012ca3be6acb4c756c372f18c3eb"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga819b23c9899e92e9f867c7b2ae8f264c"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_RSA_PKCS1V15_SIGN_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x10020000)</td></tr>
-<tr class="separator:ga819b23c9899e92e9f867c7b2ae8f264c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga702ff75385a6ae7d4247033f479439af"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga702ff75385a6ae7d4247033f479439af">PSA_ALG_RSA_PKCS1V15_SIGN</a>(hash_alg)   (PSA_ALG_RSA_PKCS1V15_SIGN_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga702ff75385a6ae7d4247033f479439af"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4215e2a78dcf834e9a625927faa2a817"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga4215e2a78dcf834e9a625927faa2a817">PSA_ALG_RSA_PKCS1V15_SIGN_RAW</a>   PSA_ALG_RSA_PKCS1V15_SIGN_BASE</td></tr>
-<tr class="separator:ga4215e2a78dcf834e9a625927faa2a817"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga9d545279f23d43b1b2a744d0dd6826d0"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_RSA_PKCS1V15_SIGN</b>(alg)   (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_RSA_PKCS1V15_SIGN_BASE)</td></tr>
-<tr class="separator:ga9d545279f23d43b1b2a744d0dd6826d0"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga49d39a343790971b7a74644f4faea0c0"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_RSA_PSS_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x10030000)</td></tr>
-<tr class="separator:ga49d39a343790971b7a74644f4faea0c0"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga62152bf4cb4bf6aace5e1be8f143564d"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga62152bf4cb4bf6aace5e1be8f143564d">PSA_ALG_RSA_PSS</a>(hash_alg)   (PSA_ALG_RSA_PSS_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga62152bf4cb4bf6aace5e1be8f143564d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gafa04fae7393a76d5161558768cb82a78"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_RSA_PSS</b>(alg)   (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_RSA_PSS_BASE)</td></tr>
-<tr class="separator:gafa04fae7393a76d5161558768cb82a78"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga863284106894476e3a8524805410b55b"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_DSA_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x10040000)</td></tr>
-<tr class="separator:ga863284106894476e3a8524805410b55b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga9a68efdddff5ae95f104a1416b12742e"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga9a68efdddff5ae95f104a1416b12742e">PSA_ALG_DSA</a>(hash_alg)   (PSA_ALG_DSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga9a68efdddff5ae95f104a1416b12742e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gad3800dafc62d6a17bcae4bce98402e68"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_DETERMINISTIC_DSA_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x10050000)</td></tr>
-<tr class="separator:gad3800dafc62d6a17bcae4bce98402e68"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1d2a96f788cce4f8fc156d13342e70de"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_DSA_DETERMINISTIC_FLAG</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x00010000)</td></tr>
-<tr class="separator:ga1d2a96f788cce4f8fc156d13342e70de"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab8eb98fb6d2e094e47f3b44dfe128f94"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gab8eb98fb6d2e094e47f3b44dfe128f94">PSA_ALG_DETERMINISTIC_DSA</a>(hash_alg)   (PSA_ALG_DETERMINISTIC_DSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:gab8eb98fb6d2e094e47f3b44dfe128f94"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gacfc3cd50ef0c4bf694cf936079bcbaee"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_DSA</b>(alg)</td></tr>
-<tr class="separator:gacfc3cd50ef0c4bf694cf936079bcbaee"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae01ae792228c16eac05102f8e900efd1"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_DSA_IS_DETERMINISTIC</b>(alg)   (((alg) & PSA_ALG_DSA_DETERMINISTIC_FLAG) != 0)</td></tr>
-<tr class="separator:gae01ae792228c16eac05102f8e900efd1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga11f7d6fe7a4441143ed398420b7d1980"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_DETERMINISTIC_DSA</b>(alg)   (PSA_ALG_IS_DSA(alg) && PSA_ALG_DSA_IS_DETERMINISTIC(alg))</td></tr>
-<tr class="separator:ga11f7d6fe7a4441143ed398420b7d1980"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga474c0582c4726d0c0274e470f4199cf9"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_RANDOMIZED_DSA</b>(alg)   (PSA_ALG_IS_DSA(alg) && !PSA_ALG_DSA_IS_DETERMINISTIC(alg))</td></tr>
-<tr class="separator:ga474c0582c4726d0c0274e470f4199cf9"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gafd9800fdbe6ea881e0ac0ce03d145928"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_ECDSA_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x10060000)</td></tr>
-<tr class="separator:gafd9800fdbe6ea881e0ac0ce03d145928"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga7e3ce9f514a227d5ba5d8318870452e3"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga7e3ce9f514a227d5ba5d8318870452e3">PSA_ALG_ECDSA</a>(hash_alg)   (PSA_ALG_ECDSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga7e3ce9f514a227d5ba5d8318870452e3"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga51d6b6044a62e33cae0cf64bfc3b22a4"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga51d6b6044a62e33cae0cf64bfc3b22a4">PSA_ALG_ECDSA_ANY</a>   PSA_ALG_ECDSA_BASE</td></tr>
-<tr class="separator:ga51d6b6044a62e33cae0cf64bfc3b22a4"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6c08b65200140aeb46ee9db9c8ed878c"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_DETERMINISTIC_ECDSA_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x10070000)</td></tr>
-<tr class="separator:ga6c08b65200140aeb46ee9db9c8ed878c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga11da566bcd341661c8de921e2ca5ed03"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga11da566bcd341661c8de921e2ca5ed03">PSA_ALG_DETERMINISTIC_ECDSA</a>(hash_alg)   (PSA_ALG_DETERMINISTIC_ECDSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga11da566bcd341661c8de921e2ca5ed03"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gafb92dc138c9d2388033ff5fc1dab7b48"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_ECDSA</b>(alg)</td></tr>
-<tr class="separator:gafb92dc138c9d2388033ff5fc1dab7b48"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaced29d8e3a1740aaec01e9ef8211df4f"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_ECDSA_IS_DETERMINISTIC</b>(alg)   (((alg) & PSA_ALG_DSA_DETERMINISTIC_FLAG) != 0)</td></tr>
-<tr class="separator:gaced29d8e3a1740aaec01e9ef8211df4f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gacd8766fe0fb8c1e2d32644e0d092c43a"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_DETERMINISTIC_ECDSA</b>(alg)   (PSA_ALG_IS_ECDSA(alg) && PSA_ALG_ECDSA_IS_DETERMINISTIC(alg))</td></tr>
-<tr class="separator:gacd8766fe0fb8c1e2d32644e0d092c43a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae7b0fafebd139f6f815285b7cad622ea"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_RANDOMIZED_ECDSA</b>(alg)   (PSA_ALG_IS_ECDSA(alg) && !PSA_ALG_ECDSA_IS_DETERMINISTIC(alg))</td></tr>
-<tr class="separator:gae7b0fafebd139f6f815285b7cad622ea"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gad8a8ea0536975363b66410cdeafe38b6"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gad8a8ea0536975363b66410cdeafe38b6">PSA_ALG_IS_HASH_AND_SIGN</a>(alg)</td></tr>
-<tr class="separator:gad8a8ea0536975363b66410cdeafe38b6"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga24cf6d7bcd2b9aeeeff86f07b6c674e3"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga24cf6d7bcd2b9aeeeff86f07b6c674e3">PSA_ALG_SIGN_GET_HASH</a>(alg)</td></tr>
-<tr class="separator:ga24cf6d7bcd2b9aeeeff86f07b6c674e3"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4c540d3abe43fb9abcb94f2bc51acef9"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga4c540d3abe43fb9abcb94f2bc51acef9">PSA_ALG_RSA_PKCS1V15_CRYPT</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x12020000)</td></tr>
-<tr class="separator:ga4c540d3abe43fb9abcb94f2bc51acef9"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga67ba62fbd154f5d3098866ae68ba66eb"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_RSA_OAEP_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x12030000)</td></tr>
-<tr class="separator:ga67ba62fbd154f5d3098866ae68ba66eb"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa1235dc3fdd9839c6c1b1a9857344c76"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaa1235dc3fdd9839c6c1b1a9857344c76">PSA_ALG_RSA_OAEP</a>(hash_alg)   (PSA_ALG_RSA_OAEP_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:gaa1235dc3fdd9839c6c1b1a9857344c76"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga9a85c05fd5c39ca63bbc47fb0755da39"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_RSA_OAEP</b>(alg)   (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_RSA_OAEP_BASE)</td></tr>
-<tr class="separator:ga9a85c05fd5c39ca63bbc47fb0755da39"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae6b0b87aabe82a1b3113824f022c52e8"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_RSA_OAEP_GET_HASH</b>(alg)</td></tr>
-<tr class="separator:gae6b0b87aabe82a1b3113824f022c52e8"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga85fe668f95a1e65b573dc5acb798be6f"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_HKDF_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x20000100)</td></tr>
-<tr class="separator:ga85fe668f95a1e65b573dc5acb798be6f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga32a888fb360e6e25cab8a343772c4a82"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga32a888fb360e6e25cab8a343772c4a82">PSA_ALG_HKDF</a>(hash_alg)   (PSA_ALG_HKDF_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga32a888fb360e6e25cab8a343772c4a82"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1979d0a76fcee6164cf2e65960f38db2"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga1979d0a76fcee6164cf2e65960f38db2">PSA_ALG_IS_HKDF</a>(alg)   (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_HKDF_BASE)</td></tr>
-<tr class="separator:ga1979d0a76fcee6164cf2e65960f38db2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga643df48b529b176995927b697ff07a4c"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_HKDF_GET_HASH</b>(hkdf_alg)   (PSA_ALG_CATEGORY_HASH | ((hkdf_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga643df48b529b176995927b697ff07a4c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gadb328698047e32da8e16551b28b50a35"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_TLS12_PRF_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x20000200)</td></tr>
-<tr class="separator:gadb328698047e32da8e16551b28b50a35"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6d5623c2ccda1d4a84e34351af8382d5"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga6d5623c2ccda1d4a84e34351af8382d5">PSA_ALG_TLS12_PRF</a>(hash_alg)   (PSA_ALG_TLS12_PRF_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga6d5623c2ccda1d4a84e34351af8382d5"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa3c18890c50222e5219f40ade8927e66"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaa3c18890c50222e5219f40ade8927e66">PSA_ALG_IS_TLS12_PRF</a>(alg)   (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_TLS12_PRF_BASE)</td></tr>
-<tr class="separator:gaa3c18890c50222e5219f40ade8927e66"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga403b2695655c7e03d6c07c061c606ab7"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_TLS12_PRF_GET_HASH</b>(hkdf_alg)   (PSA_ALG_CATEGORY_HASH | ((hkdf_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga403b2695655c7e03d6c07c061c606ab7"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaaca4b1953a3f31f1a285a48454aa4a6f"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_TLS12_PSK_TO_MS_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x20000300)</td></tr>
-<tr class="separator:gaaca4b1953a3f31f1a285a48454aa4a6f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga039ec797f15d1635d9b2e09a611f8a68"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga039ec797f15d1635d9b2e09a611f8a68">PSA_ALG_TLS12_PSK_TO_MS</a>(hash_alg)   (PSA_ALG_TLS12_PSK_TO_MS_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga039ec797f15d1635d9b2e09a611f8a68"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab25ecc074a93fd11069bedfbba5a287b"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gab25ecc074a93fd11069bedfbba5a287b">PSA_ALG_IS_TLS12_PSK_TO_MS</a>(alg)   (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_TLS12_PSK_TO_MS_BASE)</td></tr>
-<tr class="separator:gab25ecc074a93fd11069bedfbba5a287b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga49f873d8cf9fb0042118e626330eec9d"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_TLS12_PSK_TO_MS_GET_HASH</b>(hkdf_alg)   (PSA_ALG_CATEGORY_HASH | ((hkdf_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga49f873d8cf9fb0042118e626330eec9d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga914b52f4be62633b3350c5e03bf32ecb"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_KEY_DERIVATION_MASK</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x080fffff)</td></tr>
-<tr class="separator:ga914b52f4be62633b3350c5e03bf32ecb"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gad39afc70a46a0ed399e3a1b931fd108b"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_KEY_AGREEMENT_MASK</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x10f00000)</td></tr>
-<tr class="separator:gad39afc70a46a0ed399e3a1b931fd108b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga78bb81cffb87a635c247725eeb2a2682"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga78bb81cffb87a635c247725eeb2a2682">PSA_ALG_KEY_AGREEMENT</a>(ka_alg, kdf_alg)   ((ka_alg) | (kdf_alg))</td></tr>
-<tr class="separator:ga78bb81cffb87a635c247725eeb2a2682"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga56c1189add62b59e8e6a28a809b57037"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_KEY_AGREEMENT_GET_KDF</b>(alg)   (((alg) & PSA_ALG_KEY_DERIVATION_MASK) | PSA_ALG_CATEGORY_KEY_DERIVATION)</td></tr>
-<tr class="separator:ga56c1189add62b59e8e6a28a809b57037"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaf837c55ba698b488b6e63300e3470abf"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_KEY_AGREEMENT_GET_BASE</b>(alg)   (((alg) & PSA_ALG_KEY_AGREEMENT_MASK) | PSA_ALG_CATEGORY_KEY_AGREEMENT)</td></tr>
-<tr class="separator:gaf837c55ba698b488b6e63300e3470abf"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa40ab362ce141ce541d69b2eb1f41438"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaa40ab362ce141ce541d69b2eb1f41438">PSA_ALG_IS_RAW_KEY_AGREEMENT</a>(alg)</td></tr>
-<tr class="separator:gaa40ab362ce141ce541d69b2eb1f41438"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga14529588c008091de0ad2716170dbd48"><td class="memItemLeft" align="right" valign="top">
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_KEY_DERIVATION_OR_AGREEMENT</b>(alg)   ((<a class="el" href="group__crypto__types.html#gaf8b90c648aa53dbd06c236695e300cd0">PSA_ALG_IS_KEY_DERIVATION</a>(alg) || <a class="el" href="group__crypto__types.html#ga59753742cb06553bd22751bbef472b6f">PSA_ALG_IS_KEY_AGREEMENT</a>(alg)))</td></tr>
-<tr class="separator:ga14529588c008091de0ad2716170dbd48"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga0ebbb6f93a05b6511e6f108ffd2d1eb4"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga0ebbb6f93a05b6511e6f108ffd2d1eb4">PSA_ALG_FFDH</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x30100000)</td></tr>
-<tr class="separator:ga0ebbb6f93a05b6511e6f108ffd2d1eb4"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa3cf76164cd9375af4fb8a291078a19e"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaa3cf76164cd9375af4fb8a291078a19e">PSA_ALG_IS_FFDH</a>(alg)   (PSA_ALG_KEY_AGREEMENT_GET_BASE(alg) == <a class="el" href="group__crypto__types.html#ga0ebbb6f93a05b6511e6f108ffd2d1eb4">PSA_ALG_FFDH</a>)</td></tr>
-<tr class="separator:gaa3cf76164cd9375af4fb8a291078a19e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab2dbcf71b63785e7dd7b54a100edee43"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gab2dbcf71b63785e7dd7b54a100edee43">PSA_ALG_ECDH</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x30200000)</td></tr>
-<tr class="separator:gab2dbcf71b63785e7dd7b54a100edee43"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga9d9b6533d2a6bea7bac7ae01facb820d"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga9d9b6533d2a6bea7bac7ae01facb820d">PSA_ALG_IS_ECDH</a>(alg)   (PSA_ALG_KEY_AGREEMENT_GET_BASE(alg) == <a class="el" href="group__crypto__types.html#gab2dbcf71b63785e7dd7b54a100edee43">PSA_ALG_ECDH</a>)</td></tr>
-<tr class="separator:ga9d9b6533d2a6bea7bac7ae01facb820d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gacf83d7430e82b97cecb8b26ca6fa1426"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gacf83d7430e82b97cecb8b26ca6fa1426">PSA_ALG_IS_WILDCARD</a>(alg)</td></tr>
-<tr class="separator:gacf83d7430e82b97cecb8b26ca6fa1426"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga8b438870ba69489b685730d346455108"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__key__lifetimes.html#ga8b438870ba69489b685730d346455108">PSA_KEY_LIFETIME_VOLATILE</a>   ((<a class="el" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">psa_key_lifetime_t</a>)0x00000000)</td></tr>
-<tr class="separator:ga8b438870ba69489b685730d346455108"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga3713a01c5fcd5f7eae46ff22ceaf6d02"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__key__lifetimes.html#ga3713a01c5fcd5f7eae46ff22ceaf6d02">PSA_KEY_LIFETIME_PERSISTENT</a>   ((<a class="el" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">psa_key_lifetime_t</a>)0x00000001)</td></tr>
-<tr class="separator:ga3713a01c5fcd5f7eae46ff22ceaf6d02"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga7dddccdd1303176e87a4d20c87b589ed"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#ga7dddccdd1303176e87a4d20c87b589ed">PSA_KEY_USAGE_EXPORT</a>   ((<a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a>)0x00000001)</td></tr>
-<tr class="separator:ga7dddccdd1303176e87a4d20c87b589ed"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga75153b296d045d529d97203a6a995dad"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#ga75153b296d045d529d97203a6a995dad">PSA_KEY_USAGE_ENCRYPT</a>   ((<a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a>)0x00000100)</td></tr>
-<tr class="separator:ga75153b296d045d529d97203a6a995dad"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac3f2d2e5983db1edde9f142ca9bf8e6a"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#gac3f2d2e5983db1edde9f142ca9bf8e6a">PSA_KEY_USAGE_DECRYPT</a>   ((<a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a>)0x00000200)</td></tr>
-<tr class="separator:gac3f2d2e5983db1edde9f142ca9bf8e6a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga99b9f456cf59efc4b5579465407aef5a"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#ga99b9f456cf59efc4b5579465407aef5a">PSA_KEY_USAGE_SIGN</a>   ((<a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a>)0x00000400)</td></tr>
-<tr class="separator:ga99b9f456cf59efc4b5579465407aef5a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga39b54ffd5958b69634607924fa53cea6"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#ga39b54ffd5958b69634607924fa53cea6">PSA_KEY_USAGE_VERIFY</a>   ((<a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a>)0x00000800)</td></tr>
-<tr class="separator:ga39b54ffd5958b69634607924fa53cea6"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaf19022acc5ef23cf12477f632b48a0b2"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#gaf19022acc5ef23cf12477f632b48a0b2">PSA_KEY_USAGE_DERIVE</a>   ((<a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a>)0x00001000)</td></tr>
-<tr class="separator:gaf19022acc5ef23cf12477f632b48a0b2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga90a1995a41e26ed5ca30d2d4641d1168"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__derivation.html#ga90a1995a41e26ed5ca30d2d4641d1168">PSA_KDF_STEP_SECRET</a>   ((<a class="el" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">psa_key_derivation_step_t</a>)0x0101)</td></tr>
-<tr class="separator:ga90a1995a41e26ed5ca30d2d4641d1168"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga9f4da10191bcb690b88756ed8470b03c"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__derivation.html#ga9f4da10191bcb690b88756ed8470b03c">PSA_KDF_STEP_LABEL</a>   ((<a class="el" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">psa_key_derivation_step_t</a>)0x0201)</td></tr>
-<tr class="separator:ga9f4da10191bcb690b88756ed8470b03c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga384777dac55791d8f3a1af72c847b327"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__derivation.html#ga384777dac55791d8f3a1af72c847b327">PSA_KDF_STEP_SALT</a>   ((<a class="el" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">psa_key_derivation_step_t</a>)0x0202)</td></tr>
-<tr class="separator:ga384777dac55791d8f3a1af72c847b327"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga836afe760bbda3dafc6c29631560b1a0"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__derivation.html#ga836afe760bbda3dafc6c29631560b1a0">PSA_KDF_STEP_INFO</a>   ((<a class="el" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">psa_key_derivation_step_t</a>)0x0203)</td></tr>
-<tr class="separator:ga836afe760bbda3dafc6c29631560b1a0"><td class="memSeparator" colspan="2"> </td></tr>
-</table>
-<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
-<div class="textblock"><p>PSA cryptography module: macros to build and analyze integer values. </p>
-<dl class="section note"><dt>Note</dt><dd>This file may not be included directly. Applications must include <a class="el" href="crypto_8h.html" title="Platform Security Architecture cryptography module. ">psa/crypto.h</a>. Drivers must include the appropriate driver header file.</dd></dl>
-<p>This file contains portable definitions of macros to build and analyze values of integral types that encode properties of cryptographic keys, designations of cryptographic algorithms, and error codes returned by the library.</p>
-<p>This header file only defines preprocessor macros. </p>
-</div></div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/crypto__values_8h__dep__incl.map b/docs/html/crypto__values_8h__dep__incl.map
deleted file mode 100644
index 654328e..0000000
--- a/docs/html/crypto__values_8h__dep__incl.map
+++ /dev/null
@@ -1,3 +0,0 @@
-<map id="psa/crypto_values.h" name="psa/crypto_values.h">
-<area shape="rect" id="node2" href="$crypto_8h.html" title="Platform Security Architecture cryptography module. " alt="" coords="27,80,122,107"/>
-</map>
diff --git a/docs/html/crypto__values_8h__dep__incl.md5 b/docs/html/crypto__values_8h__dep__incl.md5
deleted file mode 100644
index e8f7acd..0000000
--- a/docs/html/crypto__values_8h__dep__incl.md5
+++ /dev/null
@@ -1 +0,0 @@
-683c96d3969716390891af2081e47531
\ No newline at end of file
diff --git a/docs/html/crypto__values_8h__dep__incl.png b/docs/html/crypto__values_8h__dep__incl.png
deleted file mode 100644
index 097506e..0000000
--- a/docs/html/crypto__values_8h__dep__incl.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/crypto__values_8h_source.html b/docs/html/crypto__values_8h_source.html
deleted file mode 100644
index 5039bab..0000000
--- a/docs/html/crypto__values_8h_source.html
+++ /dev/null
@@ -1,101 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: psa/crypto_values.h Source File</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li class="current"><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
- <div id="navrow2" class="tabs2">
- <ul class="tablist">
- <li><a href="files.html"><span>File List</span></a></li>
- <li><a href="globals.html"><span>File Members</span></a></li>
- </ul>
- </div>
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div id="nav-path" class="navpath">
- <ul>
-<li class="navelem"><a class="el" href="dir_7dae9cfde651cd3cb034485ce5e391b9.html">psa</a></li> </ul>
-</div>
-</div><!-- top -->
-<div class="header">
- <div class="headertitle">
-<div class="title">crypto_values.h</div> </div>
-</div><!--header-->
-<div class="contents">
-<a href="crypto__values_8h.html">Go to the documentation of this file.</a><div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> </div><div class="line"><a name="l00017"></a><span class="lineno"> 17</span> <span class="comment">/*</span></div><div class="line"><a name="l00018"></a><span class="lineno"> 18</span> <span class="comment"> * Copyright (C) 2018, ARM Limited, All Rights Reserved</span></div><div class="line"><a name="l00019"></a><span class="lineno"> 19</span> <span class="comment"> * SPDX-License-Identifier: Apache-2.0</span></div><div class="line"><a name="l00020"></a><span class="lineno"> 20</span> <span class="comment"> *</span></div><div class="line"><a name="l00021"></a><span class="lineno"> 21</span> <span class="comment"> * Licensed under the Apache License, Version 2.0 (the "License"); you may</span></div><div class="line"><a name="l00022"></a><span class="lineno"> 22</span> <span class="comment"> * not use this file except in compliance with the License.</span></div><div class="line"><a name="l00023"></a><span class="lineno"> 23</span> <span class="comment"> * You may obtain a copy of the License at</span></div><div class="line"><a name="l00024"></a><span class="lineno"> 24</span> <span class="comment"> *</span></div><div class="line"><a name="l00025"></a><span class="lineno"> 25</span> <span class="comment"> * http://www.apache.org/licenses/LICENSE-2.0</span></div><div class="line"><a name="l00026"></a><span class="lineno"> 26</span> <span class="comment"> *</span></div><div class="line"><a name="l00027"></a><span class="lineno"> 27</span> <span class="comment"> * Unless required by applicable law or agreed to in writing, software</span></div><div class="line"><a name="l00028"></a><span class="lineno"> 28</span> <span class="comment"> * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT</span></div><div class="line"><a name="l00029"></a><span class="lineno"> 29</span> <span class="comment"> * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.</span></div><div class="line"><a name="l00030"></a><span class="lineno"> 30</span> <span class="comment"> * See the License for the specific language governing permissions and</span></div><div class="line"><a name="l00031"></a><span class="lineno"> 31</span> <span class="comment"> * limitations under the License.</span></div><div class="line"><a name="l00032"></a><span class="lineno"> 32</span> <span class="comment"> *</span></div><div class="line"><a name="l00033"></a><span class="lineno"> 33</span> <span class="comment"> * This file is part of mbed TLS (https://tls.mbed.org)</span></div><div class="line"><a name="l00034"></a><span class="lineno"> 34</span> <span class="comment"> */</span></div><div class="line"><a name="l00035"></a><span class="lineno"> 35</span> </div><div class="line"><a name="l00036"></a><span class="lineno"> 36</span> <span class="preprocessor">#ifndef PSA_CRYPTO_VALUES_H</span></div><div class="line"><a name="l00037"></a><span class="lineno"> 37</span> <span class="preprocessor">#define PSA_CRYPTO_VALUES_H</span></div><div class="line"><a name="l00038"></a><span class="lineno"> 38</span> </div><div class="line"><a name="l00043"></a><span class="lineno"> 43</span> <span class="preprocessor">#if !defined(PSA_SUCCESS)</span></div><div class="line"><a name="l00044"></a><span class="lineno"> 44</span> <span class="comment">/* If PSA_SUCCESS is defined, assume that PSA crypto is being used</span></div><div class="line"><a name="l00045"></a><span class="lineno"> 45</span> <span class="comment"> * together with PSA IPC, which also defines the identifier</span></div><div class="line"><a name="l00046"></a><span class="lineno"> 46</span> <span class="comment"> * PSA_SUCCESS. We must not define PSA_SUCCESS ourselves in that case;</span></div><div class="line"><a name="l00047"></a><span class="lineno"> 47</span> <span class="comment"> * the other error code names don't clash. This is a temporary hack</span></div><div class="line"><a name="l00048"></a><span class="lineno"> 48</span> <span class="comment"> * until we unify error reporting in PSA IPC and PSA crypto.</span></div><div class="line"><a name="l00049"></a><span class="lineno"> 49</span> <span class="comment"> *</span></div><div class="line"><a name="l00050"></a><span class="lineno"> 50</span> <span class="comment"> * Note that psa_defs.h must be included before this header!</span></div><div class="line"><a name="l00051"></a><span class="lineno"> 51</span> <span class="comment"> */</span></div><div class="line"><a name="l00053"></a><span class="lineno"><a class="line" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1"> 53</a></span> <span class="preprocessor">#define PSA_SUCCESS ((psa_status_t)0)</span></div><div class="line"><a name="l00054"></a><span class="lineno"> 54</span> <span class="preprocessor">#endif </span><span class="comment">/* !defined(PSA_SUCCESS) */</span><span class="preprocessor"></span></div><div class="line"><a name="l00055"></a><span class="lineno"> 55</span> </div><div class="line"><a name="l00061"></a><span class="lineno"><a class="line" href="group__error.html#ga24d5fdcdd759f846f79d9e581c63a83f"> 61</a></span> <span class="preprocessor">#define PSA_ERROR_UNKNOWN_ERROR ((psa_status_t)1)</span></div><div class="line"><a name="l00062"></a><span class="lineno"> 62</span> </div><div class="line"><a name="l00070"></a><span class="lineno"><a class="line" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd"> 70</a></span> <span class="preprocessor">#define PSA_ERROR_NOT_SUPPORTED ((psa_status_t)2)</span></div><div class="line"><a name="l00071"></a><span class="lineno"> 71</span> </div><div class="line"><a name="l00083"></a><span class="lineno"><a class="line" href="group__error.html#ga4d1b8dd8526177a15a210b7afc1accb1"> 83</a></span> <span class="preprocessor">#define PSA_ERROR_NOT_PERMITTED ((psa_status_t)3)</span></div><div class="line"><a name="l00084"></a><span class="lineno"> 84</span> </div><div class="line"><a name="l00095"></a><span class="lineno"><a class="line" href="group__error.html#ga695025f4ec11249aee7ea3d0f65e01c8"> 95</a></span> <span class="preprocessor">#define PSA_ERROR_BUFFER_TOO_SMALL ((psa_status_t)4)</span></div><div class="line"><a name="l00096"></a><span class="lineno"> 96</span> </div><div class="line"><a name="l00103"></a><span class="lineno"><a class="line" href="group__error.html#gac2fee3a51249fbea45360aaa911f3e58"> 103</a></span> <span class="preprocessor">#define PSA_ERROR_OCCUPIED_SLOT ((psa_status_t)5)</span></div><div class="line"><a name="l00104"></a><span class="lineno"> 104</span> </div><div class="line"><a name="l00111"></a><span class="lineno"><a class="line" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040"> 111</a></span> <span class="preprocessor">#define PSA_ERROR_EMPTY_SLOT ((psa_status_t)6)</span></div><div class="line"><a name="l00112"></a><span class="lineno"> 112</span> </div><div class="line"><a name="l00123"></a><span class="lineno"><a class="line" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84"> 123</a></span> <span class="preprocessor">#define PSA_ERROR_BAD_STATE ((psa_status_t)7)</span></div><div class="line"><a name="l00124"></a><span class="lineno"> 124</span> </div><div class="line"><a name="l00139"></a><span class="lineno"><a class="line" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f"> 139</a></span> <span class="preprocessor">#define PSA_ERROR_INVALID_ARGUMENT ((psa_status_t)8)</span></div><div class="line"><a name="l00140"></a><span class="lineno"> 140</span> </div><div class="line"><a name="l00145"></a><span class="lineno"><a class="line" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5"> 145</a></span> <span class="preprocessor">#define PSA_ERROR_INSUFFICIENT_MEMORY ((psa_status_t)9)</span></div><div class="line"><a name="l00146"></a><span class="lineno"> 146</span> </div><div class="line"><a name="l00154"></a><span class="lineno"><a class="line" href="group__error.html#ga897a45eb206a6f6b7be7ffbe36f0d766"> 154</a></span> <span class="preprocessor">#define PSA_ERROR_INSUFFICIENT_STORAGE ((psa_status_t)10)</span></div><div class="line"><a name="l00155"></a><span class="lineno"> 155</span> </div><div class="line"><a name="l00171"></a><span class="lineno"><a class="line" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7"> 171</a></span> <span class="preprocessor">#define PSA_ERROR_COMMUNICATION_FAILURE ((psa_status_t)11)</span></div><div class="line"><a name="l00172"></a><span class="lineno"> 172</span> </div><div class="line"><a name="l00196"></a><span class="lineno"><a class="line" href="group__error.html#gadd169a1af2707862b95fb9df91dfc37d"> 196</a></span> <span class="preprocessor">#define PSA_ERROR_STORAGE_FAILURE ((psa_status_t)12)</span></div><div class="line"><a name="l00197"></a><span class="lineno"> 197</span> </div><div class="line"><a name="l00202"></a><span class="lineno"><a class="line" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b"> 202</a></span> <span class="preprocessor">#define PSA_ERROR_HARDWARE_FAILURE ((psa_status_t)13)</span></div><div class="line"><a name="l00203"></a><span class="lineno"> 203</span> </div><div class="line"><a name="l00233"></a><span class="lineno"><a class="line" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004"> 233</a></span> <span class="preprocessor">#define PSA_ERROR_TAMPERING_DETECTED ((psa_status_t)14)</span></div><div class="line"><a name="l00234"></a><span class="lineno"> 234</span> </div><div class="line"><a name="l00252"></a><span class="lineno"><a class="line" href="group__error.html#ga4deb59fec02297ec5d8b42178323f675"> 252</a></span> <span class="preprocessor">#define PSA_ERROR_INSUFFICIENT_ENTROPY ((psa_status_t)15)</span></div><div class="line"><a name="l00253"></a><span class="lineno"> 253</span> </div><div class="line"><a name="l00262"></a><span class="lineno"><a class="line" href="group__error.html#ga35927f755d232c4766de600f2c49e9f2"> 262</a></span> <span class="preprocessor">#define PSA_ERROR_INVALID_SIGNATURE ((psa_status_t)16)</span></div><div class="line"><a name="l00263"></a><span class="lineno"> 263</span> </div><div class="line"><a name="l00278"></a><span class="lineno"><a class="line" href="group__error.html#gabe29594edbfb152cf153975b0597ac48"> 278</a></span> <span class="preprocessor">#define PSA_ERROR_INVALID_PADDING ((psa_status_t)17)</span></div><div class="line"><a name="l00279"></a><span class="lineno"> 279</span> </div><div class="line"><a name="l00284"></a><span class="lineno"><a class="line" href="group__error.html#gaf1fa61f72e9e5b4a848c991bea495767"> 284</a></span> <span class="preprocessor">#define PSA_ERROR_INSUFFICIENT_CAPACITY ((psa_status_t)18)</span></div><div class="line"><a name="l00285"></a><span class="lineno"> 285</span> </div><div class="line"><a name="l00288"></a><span class="lineno"><a class="line" href="group__error.html#gadf22718935657c2c3168c228204085f9"> 288</a></span> <span class="preprocessor">#define PSA_ERROR_INVALID_HANDLE ((psa_status_t)19)</span></div><div class="line"><a name="l00289"></a><span class="lineno"> 289</span> </div><div class="line"><a name="l00300"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gafce7ab2b54ce97ea5bff73f13a9f3e5b"> 300</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_NONE ((psa_key_type_t)0x00000000)</span></div><div class="line"><a name="l00301"></a><span class="lineno"> 301</span> </div><div class="line"><a name="l00309"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga8dbaed2fdb1ebae8aa127ad3988516f7"> 309</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_VENDOR_FLAG ((psa_key_type_t)0x80000000)</span></div><div class="line"><a name="l00310"></a><span class="lineno"> 310</span> </div><div class="line"><a name="l00311"></a><span class="lineno"> 311</span> <span class="preprocessor">#define PSA_KEY_TYPE_CATEGORY_MASK ((psa_key_type_t)0x70000000)</span></div><div class="line"><a name="l00312"></a><span class="lineno"> 312</span> <span class="preprocessor">#define PSA_KEY_TYPE_CATEGORY_SYMMETRIC ((psa_key_type_t)0x40000000)</span></div><div class="line"><a name="l00313"></a><span class="lineno"> 313</span> <span class="preprocessor">#define PSA_KEY_TYPE_CATEGORY_RAW ((psa_key_type_t)0x50000000)</span></div><div class="line"><a name="l00314"></a><span class="lineno"> 314</span> <span class="preprocessor">#define PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY ((psa_key_type_t)0x60000000)</span></div><div class="line"><a name="l00315"></a><span class="lineno"> 315</span> <span class="preprocessor">#define PSA_KEY_TYPE_CATEGORY_KEY_PAIR ((psa_key_type_t)0x70000000)</span></div><div class="line"><a name="l00316"></a><span class="lineno"> 316</span> </div><div class="line"><a name="l00317"></a><span class="lineno"> 317</span> <span class="preprocessor">#define PSA_KEY_TYPE_CATEGORY_FLAG_PAIR ((psa_key_type_t)0x10000000)</span></div><div class="line"><a name="l00318"></a><span class="lineno"> 318</span> </div><div class="line"><a name="l00320"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gadbe4c086a6562aefe344bc79e51bdfd3"> 320</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_IS_VENDOR_DEFINED(type) \</span></div><div class="line"><a name="l00321"></a><span class="lineno"> 321</span> <span class="preprocessor"> (((type) & PSA_KEY_TYPE_VENDOR_FLAG) != 0)</span></div><div class="line"><a name="l00322"></a><span class="lineno"> 322</span> </div><div class="line"><a name="l00327"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaef86ce4e810e1c2c76068ac874bfef54"> 327</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_IS_UNSTRUCTURED(type) \</span></div><div class="line"><a name="l00328"></a><span class="lineno"> 328</span> <span class="preprocessor"> (((type) & PSA_KEY_TYPE_CATEGORY_MASK & ~(psa_key_type_t)0x10000000) == \</span></div><div class="line"><a name="l00329"></a><span class="lineno"> 329</span> <span class="preprocessor"> PSA_KEY_TYPE_CATEGORY_SYMMETRIC)</span></div><div class="line"><a name="l00330"></a><span class="lineno"> 330</span> </div><div class="line"><a name="l00332"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gab138ae2ebf2905dfbaf4154db2620939"> 332</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_IS_ASYMMETRIC(type) \</span></div><div class="line"><a name="l00333"></a><span class="lineno"> 333</span> <span class="preprocessor"> (((type) & PSA_KEY_TYPE_CATEGORY_MASK \</span></div><div class="line"><a name="l00334"></a><span class="lineno"> 334</span> <span class="preprocessor"> & ~PSA_KEY_TYPE_CATEGORY_FLAG_PAIR) == \</span></div><div class="line"><a name="l00335"></a><span class="lineno"> 335</span> <span class="preprocessor"> PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY)</span></div><div class="line"><a name="l00336"></a><span class="lineno"> 336</span> </div><div class="line"><a name="l00337"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gac674a0f059bc0cb72b47f0c517b4f45b"> 337</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_IS_PUBLIC_KEY(type) \</span></div><div class="line"><a name="l00338"></a><span class="lineno"> 338</span> <span class="preprocessor"> (((type) & PSA_KEY_TYPE_CATEGORY_MASK) == PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY)</span></div><div class="line"><a name="l00339"></a><span class="lineno"> 339</span> </div><div class="line"><a name="l00341"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gac14c6d6e1b2b7f4a92a7b757465cff29"> 341</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_IS_KEYPAIR(type) \</span></div><div class="line"><a name="l00342"></a><span class="lineno"> 342</span> <span class="preprocessor"> (((type) & PSA_KEY_TYPE_CATEGORY_MASK) == PSA_KEY_TYPE_CATEGORY_KEY_PAIR)</span></div><div class="line"><a name="l00343"></a><span class="lineno"> 343</span> </div><div class="line"><a name="l00353"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaf09f1ca1de6a7e7cff0fe516f3f6c91d"> 353</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_KEYPAIR_OF_PUBLIC_KEY(type) \</span></div><div class="line"><a name="l00354"></a><span class="lineno"> 354</span> <span class="preprocessor"> ((type) | PSA_KEY_TYPE_CATEGORY_FLAG_PAIR)</span></div><div class="line"><a name="l00355"></a><span class="lineno"> 355</span> </div><div class="line"><a name="l00365"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gace08e46dd7cbf642d50d982a25d02bec"> 365</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR(type) \</span></div><div class="line"><a name="l00366"></a><span class="lineno"> 366</span> <span class="preprocessor"> ((type) & ~PSA_KEY_TYPE_CATEGORY_FLAG_PAIR)</span></div><div class="line"><a name="l00367"></a><span class="lineno"> 367</span> </div><div class="line"><a name="l00372"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaa97f92025533102616b32d571c940d80"> 372</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_RAW_DATA ((psa_key_type_t)0x50000001)</span></div><div class="line"><a name="l00373"></a><span class="lineno"> 373</span> </div><div class="line"><a name="l00382"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga92d989f4ca64abd00f463defd773a6f8"> 382</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_HMAC ((psa_key_type_t)0x51000000)</span></div><div class="line"><a name="l00383"></a><span class="lineno"> 383</span> </div><div class="line"><a name="l00389"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gae871b2357b8593f33bfd51abbf93ebb1"> 389</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_DERIVE ((psa_key_type_t)0x52000000)</span></div><div class="line"><a name="l00390"></a><span class="lineno"> 390</span> </div><div class="line"><a name="l00396"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga6ee54579dcf278c677eda4bb1a29575e"> 396</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_AES ((psa_key_type_t)0x40000001)</span></div><div class="line"><a name="l00397"></a><span class="lineno"> 397</span> </div><div class="line"><a name="l00407"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga577562bfbbc691c820d55ec308333138"> 407</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_DES ((psa_key_type_t)0x40000002)</span></div><div class="line"><a name="l00408"></a><span class="lineno"> 408</span> </div><div class="line"><a name="l00411"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gad8e5da742343fd5519f9d8a630c2ed81"> 411</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_CAMELLIA ((psa_key_type_t)0x40000003)</span></div><div class="line"><a name="l00412"></a><span class="lineno"> 412</span> </div><div class="line"><a name="l00417"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gae4d46e83f910dcaa126000a8ed03cde9"> 417</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_ARC4 ((psa_key_type_t)0x40000004)</span></div><div class="line"><a name="l00418"></a><span class="lineno"> 418</span> </div><div class="line"><a name="l00420"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga9ba0878f56c8bcd1995ac017a74f513b"> 420</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_RSA_PUBLIC_KEY ((psa_key_type_t)0x60010000)</span></div><div class="line"><a name="l00421"></a><span class="lineno"> 421</span> </div><div class="line"><a name="l00422"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga581f50687f5d650456925278948f2799"> 422</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_RSA_KEYPAIR ((psa_key_type_t)0x70010000)</span></div><div class="line"><a name="l00423"></a><span class="lineno"> 423</span> </div><div class="line"><a name="l00424"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga0e1d8f241228e49c9cadadfb4579ef1a"> 424</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_IS_RSA(type) \</span></div><div class="line"><a name="l00425"></a><span class="lineno"> 425</span> <span class="preprocessor"> (PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR(type) == PSA_KEY_TYPE_RSA_PUBLIC_KEY)</span></div><div class="line"><a name="l00426"></a><span class="lineno"> 426</span> </div><div class="line"><a name="l00428"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga5e7439c2905136366c3a876e62e5ddfc"> 428</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_DSA_PUBLIC_KEY ((psa_key_type_t)0x60020000)</span></div><div class="line"><a name="l00429"></a><span class="lineno"> 429</span> </div><div class="line"><a name="l00430"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga011010ee28c20388f3d89fb27088ed62"> 430</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_DSA_KEYPAIR ((psa_key_type_t)0x70020000)</span></div><div class="line"><a name="l00431"></a><span class="lineno"> 431</span> </div><div class="line"><a name="l00432"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga273fdfcf23eb0624f8b63d2321cf95c1"> 432</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_IS_DSA(type) \</span></div><div class="line"><a name="l00433"></a><span class="lineno"> 433</span> <span class="preprocessor"> (PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR(type) == PSA_KEY_TYPE_DSA_PUBLIC_KEY)</span></div><div class="line"><a name="l00434"></a><span class="lineno"> 434</span> </div><div class="line"><a name="l00435"></a><span class="lineno"> 435</span> <span class="preprocessor">#define PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE ((psa_key_type_t)0x60030000)</span></div><div class="line"><a name="l00436"></a><span class="lineno"> 436</span> <span class="preprocessor">#define PSA_KEY_TYPE_ECC_KEYPAIR_BASE ((psa_key_type_t)0x70030000)</span></div><div class="line"><a name="l00437"></a><span class="lineno"> 437</span> <span class="preprocessor">#define PSA_KEY_TYPE_ECC_CURVE_MASK ((psa_key_type_t)0x0000ffff)</span></div><div class="line"><a name="l00438"></a><span class="lineno"> 438</span> </div><div class="line"><a name="l00439"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gadf3ad65d157bf5282849c954bf3f51af"> 439</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_ECC_KEYPAIR(curve) \</span></div><div class="line"><a name="l00440"></a><span class="lineno"> 440</span> <span class="preprocessor"> (PSA_KEY_TYPE_ECC_KEYPAIR_BASE | (curve))</span></div><div class="line"><a name="l00441"></a><span class="lineno"> 441</span> </div><div class="line"><a name="l00442"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gad54c03d3b47020e571a72cd01d978cf2"> 442</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_ECC_PUBLIC_KEY(curve) \</span></div><div class="line"><a name="l00443"></a><span class="lineno"> 443</span> <span class="preprocessor"> (PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE | (curve))</span></div><div class="line"><a name="l00444"></a><span class="lineno"> 444</span> </div><div class="line"><a name="l00446"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga88e01fa06b585654689a99bcc06bbe66"> 446</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_IS_ECC(type) \</span></div><div class="line"><a name="l00447"></a><span class="lineno"> 447</span> <span class="preprocessor"> ((PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR(type) & \</span></div><div class="line"><a name="l00448"></a><span class="lineno"> 448</span> <span class="preprocessor"> ~PSA_KEY_TYPE_ECC_CURVE_MASK) == PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE)</span></div><div class="line"><a name="l00449"></a><span class="lineno"> 449</span> </div><div class="line"><a name="l00450"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga7bf101b671e8cf26f4cb08fcb679db4b"> 450</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_IS_ECC_KEYPAIR(type) \</span></div><div class="line"><a name="l00451"></a><span class="lineno"> 451</span> <span class="preprocessor"> (((type) & ~PSA_KEY_TYPE_ECC_CURVE_MASK) == \</span></div><div class="line"><a name="l00452"></a><span class="lineno"> 452</span> <span class="preprocessor"> PSA_KEY_TYPE_ECC_KEYPAIR_BASE)</span></div><div class="line"><a name="l00453"></a><span class="lineno"> 453</span> </div><div class="line"><a name="l00454"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga5af146a173b0c84d7e737e2fb6a3c0a7"> 454</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY(type) \</span></div><div class="line"><a name="l00455"></a><span class="lineno"> 455</span> <span class="preprocessor"> (((type) & ~PSA_KEY_TYPE_ECC_CURVE_MASK) == \</span></div><div class="line"><a name="l00456"></a><span class="lineno"> 456</span> <span class="preprocessor"> PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE)</span></div><div class="line"><a name="l00457"></a><span class="lineno"> 457</span> </div><div class="line"><a name="l00459"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga0c567210e6f80aa8f2aa87efa7a3a3f9"> 459</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_GET_CURVE(type) \</span></div><div class="line"><a name="l00460"></a><span class="lineno"> 460</span> <span class="preprocessor"> ((psa_ecc_curve_t) (PSA_KEY_TYPE_IS_ECC(type) ? \</span></div><div class="line"><a name="l00461"></a><span class="lineno"> 461</span> <span class="preprocessor"> ((type) & PSA_KEY_TYPE_ECC_CURVE_MASK) : \</span></div><div class="line"><a name="l00462"></a><span class="lineno"> 462</span> <span class="preprocessor"> 0))</span></div><div class="line"><a name="l00463"></a><span class="lineno"> 463</span> </div><div class="line"><a name="l00464"></a><span class="lineno"> 464</span> <span class="comment">/* The encoding of curve identifiers is currently aligned with the</span></div><div class="line"><a name="l00465"></a><span class="lineno"> 465</span> <span class="comment"> * TLS Supported Groups Registry (formerly known as the</span></div><div class="line"><a name="l00466"></a><span class="lineno"> 466</span> <span class="comment"> * TLS EC Named Curve Registry)</span></div><div class="line"><a name="l00467"></a><span class="lineno"> 467</span> <span class="comment"> * https://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml#tls-parameters-8</span></div><div class="line"><a name="l00468"></a><span class="lineno"> 468</span> <span class="comment"> * The values are defined by RFC 8422 and RFC 7027. */</span></div><div class="line"><a name="l00469"></a><span class="lineno"> 469</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECT163K1 ((psa_ecc_curve_t) 0x0001)</span></div><div class="line"><a name="l00470"></a><span class="lineno"> 470</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECT163R1 ((psa_ecc_curve_t) 0x0002)</span></div><div class="line"><a name="l00471"></a><span class="lineno"> 471</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECT163R2 ((psa_ecc_curve_t) 0x0003)</span></div><div class="line"><a name="l00472"></a><span class="lineno"> 472</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECT193R1 ((psa_ecc_curve_t) 0x0004)</span></div><div class="line"><a name="l00473"></a><span class="lineno"> 473</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECT193R2 ((psa_ecc_curve_t) 0x0005)</span></div><div class="line"><a name="l00474"></a><span class="lineno"> 474</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECT233K1 ((psa_ecc_curve_t) 0x0006)</span></div><div class="line"><a name="l00475"></a><span class="lineno"> 475</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECT233R1 ((psa_ecc_curve_t) 0x0007)</span></div><div class="line"><a name="l00476"></a><span class="lineno"> 476</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECT239K1 ((psa_ecc_curve_t) 0x0008)</span></div><div class="line"><a name="l00477"></a><span class="lineno"> 477</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECT283K1 ((psa_ecc_curve_t) 0x0009)</span></div><div class="line"><a name="l00478"></a><span class="lineno"> 478</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECT283R1 ((psa_ecc_curve_t) 0x000a)</span></div><div class="line"><a name="l00479"></a><span class="lineno"> 479</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECT409K1 ((psa_ecc_curve_t) 0x000b)</span></div><div class="line"><a name="l00480"></a><span class="lineno"> 480</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECT409R1 ((psa_ecc_curve_t) 0x000c)</span></div><div class="line"><a name="l00481"></a><span class="lineno"> 481</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECT571K1 ((psa_ecc_curve_t) 0x000d)</span></div><div class="line"><a name="l00482"></a><span class="lineno"> 482</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECT571R1 ((psa_ecc_curve_t) 0x000e)</span></div><div class="line"><a name="l00483"></a><span class="lineno"> 483</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECP160K1 ((psa_ecc_curve_t) 0x000f)</span></div><div class="line"><a name="l00484"></a><span class="lineno"> 484</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECP160R1 ((psa_ecc_curve_t) 0x0010)</span></div><div class="line"><a name="l00485"></a><span class="lineno"> 485</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECP160R2 ((psa_ecc_curve_t) 0x0011)</span></div><div class="line"><a name="l00486"></a><span class="lineno"> 486</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECP192K1 ((psa_ecc_curve_t) 0x0012)</span></div><div class="line"><a name="l00487"></a><span class="lineno"> 487</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECP192R1 ((psa_ecc_curve_t) 0x0013)</span></div><div class="line"><a name="l00488"></a><span class="lineno"> 488</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECP224K1 ((psa_ecc_curve_t) 0x0014)</span></div><div class="line"><a name="l00489"></a><span class="lineno"> 489</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECP224R1 ((psa_ecc_curve_t) 0x0015)</span></div><div class="line"><a name="l00490"></a><span class="lineno"> 490</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECP256K1 ((psa_ecc_curve_t) 0x0016)</span></div><div class="line"><a name="l00491"></a><span class="lineno"> 491</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECP256R1 ((psa_ecc_curve_t) 0x0017)</span></div><div class="line"><a name="l00492"></a><span class="lineno"> 492</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECP384R1 ((psa_ecc_curve_t) 0x0018)</span></div><div class="line"><a name="l00493"></a><span class="lineno"> 493</span> <span class="preprocessor">#define PSA_ECC_CURVE_SECP521R1 ((psa_ecc_curve_t) 0x0019)</span></div><div class="line"><a name="l00494"></a><span class="lineno"> 494</span> <span class="preprocessor">#define PSA_ECC_CURVE_BRAINPOOL_P256R1 ((psa_ecc_curve_t) 0x001a)</span></div><div class="line"><a name="l00495"></a><span class="lineno"> 495</span> <span class="preprocessor">#define PSA_ECC_CURVE_BRAINPOOL_P384R1 ((psa_ecc_curve_t) 0x001b)</span></div><div class="line"><a name="l00496"></a><span class="lineno"> 496</span> <span class="preprocessor">#define PSA_ECC_CURVE_BRAINPOOL_P512R1 ((psa_ecc_curve_t) 0x001c)</span></div><div class="line"><a name="l00497"></a><span class="lineno"> 497</span> <span class="preprocessor">#define PSA_ECC_CURVE_CURVE25519 ((psa_ecc_curve_t) 0x001d)</span></div><div class="line"><a name="l00498"></a><span class="lineno"> 498</span> <span class="preprocessor">#define PSA_ECC_CURVE_CURVE448 ((psa_ecc_curve_t) 0x001e)</span></div><div class="line"><a name="l00499"></a><span class="lineno"> 499</span> </div><div class="line"><a name="l00501"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga325a340d7c72d99d3a678eb210bf6e0a"> 501</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_DH_PUBLIC_KEY ((psa_key_type_t)0x60040000)</span></div><div class="line"><a name="l00502"></a><span class="lineno"> 502</span> </div><div class="line"><a name="l00503"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga39b63c6b97a62a316c0660bf72b2fdd5"> 503</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_DH_KEYPAIR ((psa_key_type_t)0x70040000)</span></div><div class="line"><a name="l00504"></a><span class="lineno"> 504</span> </div><div class="line"><a name="l00506"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga248ae35c0e2becaebbf479fc1c3a3b0e"> 506</a></span> <span class="preprocessor">#define PSA_KEY_TYPE_IS_DH(type) \</span></div><div class="line"><a name="l00507"></a><span class="lineno"> 507</span> <span class="preprocessor"> (PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR(type) == PSA_KEY_TYPE_DH_PUBLIC_KEY)</span></div><div class="line"><a name="l00508"></a><span class="lineno"> 508</span> </div><div class="line"><a name="l00527"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gacaa366bdeb0413e63e87a667c5457b2e"> 527</a></span> <span class="preprocessor">#define PSA_BLOCK_CIPHER_BLOCK_SIZE(type) \</span></div><div class="line"><a name="l00528"></a><span class="lineno"> 528</span> <span class="preprocessor"> ( \</span></div><div class="line"><a name="l00529"></a><span class="lineno"> 529</span> <span class="preprocessor"> (type) == PSA_KEY_TYPE_AES ? 16 : \</span></div><div class="line"><a name="l00530"></a><span class="lineno"> 530</span> <span class="preprocessor"> (type) == PSA_KEY_TYPE_DES ? 8 : \</span></div><div class="line"><a name="l00531"></a><span class="lineno"> 531</span> <span class="preprocessor"> (type) == PSA_KEY_TYPE_CAMELLIA ? 16 : \</span></div><div class="line"><a name="l00532"></a><span class="lineno"> 532</span> <span class="preprocessor"> (type) == PSA_KEY_TYPE_ARC4 ? 1 : \</span></div><div class="line"><a name="l00533"></a><span class="lineno"> 533</span> <span class="preprocessor"> 0)</span></div><div class="line"><a name="l00534"></a><span class="lineno"> 534</span> </div><div class="line"><a name="l00535"></a><span class="lineno"> 535</span> <span class="preprocessor">#define PSA_ALG_VENDOR_FLAG ((psa_algorithm_t)0x80000000)</span></div><div class="line"><a name="l00536"></a><span class="lineno"> 536</span> <span class="preprocessor">#define PSA_ALG_CATEGORY_MASK ((psa_algorithm_t)0x7f000000)</span></div><div class="line"><a name="l00537"></a><span class="lineno"> 537</span> <span class="preprocessor">#define PSA_ALG_CATEGORY_HASH ((psa_algorithm_t)0x01000000)</span></div><div class="line"><a name="l00538"></a><span class="lineno"> 538</span> <span class="preprocessor">#define PSA_ALG_CATEGORY_MAC ((psa_algorithm_t)0x02000000)</span></div><div class="line"><a name="l00539"></a><span class="lineno"> 539</span> <span class="preprocessor">#define PSA_ALG_CATEGORY_CIPHER ((psa_algorithm_t)0x04000000)</span></div><div class="line"><a name="l00540"></a><span class="lineno"> 540</span> <span class="preprocessor">#define PSA_ALG_CATEGORY_AEAD ((psa_algorithm_t)0x06000000)</span></div><div class="line"><a name="l00541"></a><span class="lineno"> 541</span> <span class="preprocessor">#define PSA_ALG_CATEGORY_SIGN ((psa_algorithm_t)0x10000000)</span></div><div class="line"><a name="l00542"></a><span class="lineno"> 542</span> <span class="preprocessor">#define PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION ((psa_algorithm_t)0x12000000)</span></div><div class="line"><a name="l00543"></a><span class="lineno"> 543</span> <span class="preprocessor">#define PSA_ALG_CATEGORY_KEY_DERIVATION ((psa_algorithm_t)0x20000000)</span></div><div class="line"><a name="l00544"></a><span class="lineno"> 544</span> <span class="preprocessor">#define PSA_ALG_CATEGORY_KEY_AGREEMENT ((psa_algorithm_t)0x30000000)</span></div><div class="line"><a name="l00545"></a><span class="lineno"> 545</span> </div><div class="line"><a name="l00546"></a><span class="lineno"> 546</span> <span class="preprocessor">#define PSA_ALG_IS_VENDOR_DEFINED(alg) \</span></div><div class="line"><a name="l00547"></a><span class="lineno"> 547</span> <span class="preprocessor"> (((alg) & PSA_ALG_VENDOR_FLAG) != 0)</span></div><div class="line"><a name="l00548"></a><span class="lineno"> 548</span> </div><div class="line"><a name="l00557"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gac9280662bb482590b4b33d1dcd32930f"> 557</a></span> <span class="preprocessor">#define PSA_ALG_IS_HASH(alg) \</span></div><div class="line"><a name="l00558"></a><span class="lineno"> 558</span> <span class="preprocessor"> (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_HASH)</span></div><div class="line"><a name="l00559"></a><span class="lineno"> 559</span> </div><div class="line"><a name="l00568"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaca7aee4c9dde316b3b1a150a26eab776"> 568</a></span> <span class="preprocessor">#define PSA_ALG_IS_MAC(alg) \</span></div><div class="line"><a name="l00569"></a><span class="lineno"> 569</span> <span class="preprocessor"> (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_MAC)</span></div><div class="line"><a name="l00570"></a><span class="lineno"> 570</span> </div><div class="line"><a name="l00579"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga1d1a5a402ad89a2e68f12bfb535490eb"> 579</a></span> <span class="preprocessor">#define PSA_ALG_IS_CIPHER(alg) \</span></div><div class="line"><a name="l00580"></a><span class="lineno"> 580</span> <span class="preprocessor"> (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_CIPHER)</span></div><div class="line"><a name="l00581"></a><span class="lineno"> 581</span> </div><div class="line"><a name="l00591"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga1d44829d60065eaa4ac9a703e7d6abc8"> 591</a></span> <span class="preprocessor">#define PSA_ALG_IS_AEAD(alg) \</span></div><div class="line"><a name="l00592"></a><span class="lineno"> 592</span> <span class="preprocessor"> (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_AEAD)</span></div><div class="line"><a name="l00593"></a><span class="lineno"> 593</span> </div><div class="line"><a name="l00602"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga6d490d0904e0698f6c1268a89d72ff31"> 602</a></span> <span class="preprocessor">#define PSA_ALG_IS_SIGN(alg) \</span></div><div class="line"><a name="l00603"></a><span class="lineno"> 603</span> <span class="preprocessor"> (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_SIGN)</span></div><div class="line"><a name="l00604"></a><span class="lineno"> 604</span> </div><div class="line"><a name="l00613"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga41d2ee937d54efd76bd54a97b2ebc08a"> 613</a></span> <span class="preprocessor">#define PSA_ALG_IS_ASYMMETRIC_ENCRYPTION(alg) \</span></div><div class="line"><a name="l00614"></a><span class="lineno"> 614</span> <span class="preprocessor"> (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION)</span></div><div class="line"><a name="l00615"></a><span class="lineno"> 615</span> </div><div class="line"><a name="l00624"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga59753742cb06553bd22751bbef472b6f"> 624</a></span> <span class="preprocessor">#define PSA_ALG_IS_KEY_AGREEMENT(alg) \</span></div><div class="line"><a name="l00625"></a><span class="lineno"> 625</span> <span class="preprocessor"> (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_KEY_AGREEMENT)</span></div><div class="line"><a name="l00626"></a><span class="lineno"> 626</span> </div><div class="line"><a name="l00635"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaf8b90c648aa53dbd06c236695e300cd0"> 635</a></span> <span class="preprocessor">#define PSA_ALG_IS_KEY_DERIVATION(alg) \</span></div><div class="line"><a name="l00636"></a><span class="lineno"> 636</span> <span class="preprocessor"> (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_KEY_DERIVATION)</span></div><div class="line"><a name="l00637"></a><span class="lineno"> 637</span> </div><div class="line"><a name="l00638"></a><span class="lineno"> 638</span> <span class="preprocessor">#define PSA_ALG_HASH_MASK ((psa_algorithm_t)0x000000ff)</span></div><div class="line"><a name="l00639"></a><span class="lineno"> 639</span> </div><div class="line"><a name="l00640"></a><span class="lineno"> 640</span> <span class="preprocessor">#define PSA_ALG_MD2 ((psa_algorithm_t)0x01000001)</span></div><div class="line"><a name="l00641"></a><span class="lineno"> 641</span> <span class="preprocessor">#define PSA_ALG_MD4 ((psa_algorithm_t)0x01000002)</span></div><div class="line"><a name="l00642"></a><span class="lineno"> 642</span> <span class="preprocessor">#define PSA_ALG_MD5 ((psa_algorithm_t)0x01000003)</span></div><div class="line"><a name="l00643"></a><span class="lineno"> 643</span> <span class="preprocessor">#define PSA_ALG_RIPEMD160 ((psa_algorithm_t)0x01000004)</span></div><div class="line"><a name="l00644"></a><span class="lineno"> 644</span> <span class="preprocessor">#define PSA_ALG_SHA_1 ((psa_algorithm_t)0x01000005)</span></div><div class="line"><a name="l00645"></a><span class="lineno"> 645</span> </div><div class="line"><a name="l00646"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga25d6a3244d10a7148fe6b026d1979f7b"> 646</a></span> <span class="preprocessor">#define PSA_ALG_SHA_224 ((psa_algorithm_t)0x01000008)</span></div><div class="line"><a name="l00647"></a><span class="lineno"> 647</span> </div><div class="line"><a name="l00648"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga619471f978e13cdd0a1e37145e4bf341"> 648</a></span> <span class="preprocessor">#define PSA_ALG_SHA_256 ((psa_algorithm_t)0x01000009)</span></div><div class="line"><a name="l00649"></a><span class="lineno"> 649</span> </div><div class="line"><a name="l00650"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga58af64dd9a86a287e8da9ed7739eead4"> 650</a></span> <span class="preprocessor">#define PSA_ALG_SHA_384 ((psa_algorithm_t)0x0100000a)</span></div><div class="line"><a name="l00651"></a><span class="lineno"> 651</span> </div><div class="line"><a name="l00652"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gafba3ae409f46d3dd7f37a0910660c3e9"> 652</a></span> <span class="preprocessor">#define PSA_ALG_SHA_512 ((psa_algorithm_t)0x0100000b)</span></div><div class="line"><a name="l00653"></a><span class="lineno"> 653</span> </div><div class="line"><a name="l00654"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga3fe2d7c3c80e3186ca78d16a35d5d931"> 654</a></span> <span class="preprocessor">#define PSA_ALG_SHA_512_224 ((psa_algorithm_t)0x0100000c)</span></div><div class="line"><a name="l00655"></a><span class="lineno"> 655</span> </div><div class="line"><a name="l00656"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga5910b3964c14e9613e8643a45b09c2d4"> 656</a></span> <span class="preprocessor">#define PSA_ALG_SHA_512_256 ((psa_algorithm_t)0x0100000d)</span></div><div class="line"><a name="l00657"></a><span class="lineno"> 657</span> </div><div class="line"><a name="l00658"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga16f5fe34ccce68c2fada1224c054a999"> 658</a></span> <span class="preprocessor">#define PSA_ALG_SHA3_224 ((psa_algorithm_t)0x01000010)</span></div><div class="line"><a name="l00659"></a><span class="lineno"> 659</span> </div><div class="line"><a name="l00660"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaace70d9515489bbe3c5e7ac1b7d9155b"> 660</a></span> <span class="preprocessor">#define PSA_ALG_SHA3_256 ((psa_algorithm_t)0x01000011)</span></div><div class="line"><a name="l00661"></a><span class="lineno"> 661</span> </div><div class="line"><a name="l00662"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gab0f079257ea75e2acfe2fc3b38c78cd8"> 662</a></span> <span class="preprocessor">#define PSA_ALG_SHA3_384 ((psa_algorithm_t)0x01000012)</span></div><div class="line"><a name="l00663"></a><span class="lineno"> 663</span> </div><div class="line"><a name="l00664"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga37e5dbe936dddb155e76f2997de27188"> 664</a></span> <span class="preprocessor">#define PSA_ALG_SHA3_512 ((psa_algorithm_t)0x01000013)</span></div><div class="line"><a name="l00665"></a><span class="lineno"> 665</span> </div><div class="line"><a name="l00699"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaa1288ea8bd397a8a3f5e19e94110f2e4"> 699</a></span> <span class="preprocessor">#define PSA_ALG_ANY_HASH ((psa_algorithm_t)0x010000ff)</span></div><div class="line"><a name="l00700"></a><span class="lineno"> 700</span> </div><div class="line"><a name="l00701"></a><span class="lineno"> 701</span> <span class="preprocessor">#define PSA_ALG_MAC_SUBCATEGORY_MASK ((psa_algorithm_t)0x00c00000)</span></div><div class="line"><a name="l00702"></a><span class="lineno"> 702</span> <span class="preprocessor">#define PSA_ALG_HMAC_BASE ((psa_algorithm_t)0x02800000)</span></div><div class="line"><a name="l00703"></a><span class="lineno"> 703</span> </div><div class="line"><a name="l00714"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga70f397425684b3efcde1e0e34c28261f"> 714</a></span> <span class="preprocessor">#define PSA_ALG_HMAC(hash_alg) \</span></div><div class="line"><a name="l00715"></a><span class="lineno"> 715</span> <span class="preprocessor"> (PSA_ALG_HMAC_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l00716"></a><span class="lineno"> 716</span> </div><div class="line"><a name="l00717"></a><span class="lineno"> 717</span> <span class="preprocessor">#define PSA_ALG_HMAC_GET_HASH(hmac_alg) \</span></div><div class="line"><a name="l00718"></a><span class="lineno"> 718</span> <span class="preprocessor"> (PSA_ALG_CATEGORY_HASH | ((hmac_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l00719"></a><span class="lineno"> 719</span> </div><div class="line"><a name="l00730"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga4a050c3c3cbc6eb96418f18847601c8a"> 730</a></span> <span class="preprocessor">#define PSA_ALG_IS_HMAC(alg) \</span></div><div class="line"><a name="l00731"></a><span class="lineno"> 731</span> <span class="preprocessor"> (((alg) & (PSA_ALG_CATEGORY_MASK | PSA_ALG_MAC_SUBCATEGORY_MASK)) == \</span></div><div class="line"><a name="l00732"></a><span class="lineno"> 732</span> <span class="preprocessor"> PSA_ALG_HMAC_BASE)</span></div><div class="line"><a name="l00733"></a><span class="lineno"> 733</span> </div><div class="line"><a name="l00734"></a><span class="lineno"> 734</span> <span class="comment">/* In the encoding of a MAC algorithm, the bits corresponding to</span></div><div class="line"><a name="l00735"></a><span class="lineno"> 735</span> <span class="comment"> * PSA_ALG_MAC_TRUNCATION_MASK encode the length to which the MAC is</span></div><div class="line"><a name="l00736"></a><span class="lineno"> 736</span> <span class="comment"> * truncated. As an exception, the value 0 means the untruncated algorithm,</span></div><div class="line"><a name="l00737"></a><span class="lineno"> 737</span> <span class="comment"> * whatever its length is. The length is encoded in 6 bits, so it can</span></div><div class="line"><a name="l00738"></a><span class="lineno"> 738</span> <span class="comment"> * reach up to 63; the largest MAC is 64 bytes so its trivial truncation</span></div><div class="line"><a name="l00739"></a><span class="lineno"> 739</span> <span class="comment"> * to full length is correctly encoded as 0 and any non-trivial truncation</span></div><div class="line"><a name="l00740"></a><span class="lineno"> 740</span> <span class="comment"> * is correctly encoded as a value between 1 and 63. */</span></div><div class="line"><a name="l00741"></a><span class="lineno"> 741</span> <span class="preprocessor">#define PSA_ALG_MAC_TRUNCATION_MASK ((psa_algorithm_t)0x00003f00)</span></div><div class="line"><a name="l00742"></a><span class="lineno"> 742</span> <span class="preprocessor">#define PSA_MAC_TRUNCATION_OFFSET 8</span></div><div class="line"><a name="l00743"></a><span class="lineno"> 743</span> </div><div class="line"><a name="l00777"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaf36137110baf7bb13c5028fd62c64276"> 777</a></span> <span class="preprocessor">#define PSA_ALG_TRUNCATED_MAC(alg, mac_length) \</span></div><div class="line"><a name="l00778"></a><span class="lineno"> 778</span> <span class="preprocessor"> (((alg) & ~PSA_ALG_MAC_TRUNCATION_MASK) | \</span></div><div class="line"><a name="l00779"></a><span class="lineno"> 779</span> <span class="preprocessor"> ((mac_length) << PSA_MAC_TRUNCATION_OFFSET & PSA_ALG_MAC_TRUNCATION_MASK))</span></div><div class="line"><a name="l00780"></a><span class="lineno"> 780</span> </div><div class="line"><a name="l00793"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaa05a8d99634f3350597ac9284fb70cb1"> 793</a></span> <span class="preprocessor">#define PSA_ALG_FULL_LENGTH_MAC(alg) \</span></div><div class="line"><a name="l00794"></a><span class="lineno"> 794</span> <span class="preprocessor"> ((alg) & ~PSA_ALG_MAC_TRUNCATION_MASK)</span></div><div class="line"><a name="l00795"></a><span class="lineno"> 795</span> </div><div class="line"><a name="l00807"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gab03726c4476174e019a08e2a04018ce8"> 807</a></span> <span class="preprocessor">#define PSA_MAC_TRUNCATED_LENGTH(alg) \</span></div><div class="line"><a name="l00808"></a><span class="lineno"> 808</span> <span class="preprocessor"> (((alg) & PSA_ALG_MAC_TRUNCATION_MASK) >> PSA_MAC_TRUNCATION_OFFSET)</span></div><div class="line"><a name="l00809"></a><span class="lineno"> 809</span> </div><div class="line"><a name="l00810"></a><span class="lineno"> 810</span> <span class="preprocessor">#define PSA_ALG_CIPHER_MAC_BASE ((psa_algorithm_t)0x02c00000)</span></div><div class="line"><a name="l00811"></a><span class="lineno"> 811</span> <span class="preprocessor">#define PSA_ALG_CBC_MAC ((psa_algorithm_t)0x02c00001)</span></div><div class="line"><a name="l00812"></a><span class="lineno"> 812</span> <span class="preprocessor">#define PSA_ALG_CMAC ((psa_algorithm_t)0x02c00002)</span></div><div class="line"><a name="l00813"></a><span class="lineno"> 813</span> <span class="preprocessor">#define PSA_ALG_GMAC ((psa_algorithm_t)0x02c00003)</span></div><div class="line"><a name="l00814"></a><span class="lineno"> 814</span> </div><div class="line"><a name="l00823"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gae49d1eb601125d65a5c5b252aa45479e"> 823</a></span> <span class="preprocessor">#define PSA_ALG_IS_BLOCK_CIPHER_MAC(alg) \</span></div><div class="line"><a name="l00824"></a><span class="lineno"> 824</span> <span class="preprocessor"> (((alg) & (PSA_ALG_CATEGORY_MASK | PSA_ALG_MAC_SUBCATEGORY_MASK)) == \</span></div><div class="line"><a name="l00825"></a><span class="lineno"> 825</span> <span class="preprocessor"> PSA_ALG_CIPHER_MAC_BASE)</span></div><div class="line"><a name="l00826"></a><span class="lineno"> 826</span> </div><div class="line"><a name="l00827"></a><span class="lineno"> 827</span> <span class="preprocessor">#define PSA_ALG_CIPHER_STREAM_FLAG ((psa_algorithm_t)0x00800000)</span></div><div class="line"><a name="l00828"></a><span class="lineno"> 828</span> <span class="preprocessor">#define PSA_ALG_CIPHER_FROM_BLOCK_FLAG ((psa_algorithm_t)0x00400000)</span></div><div class="line"><a name="l00829"></a><span class="lineno"> 829</span> </div><div class="line"><a name="l00842"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gacfec68e0c6175e02e1b2ebc97df383c0"> 842</a></span> <span class="preprocessor">#define PSA_ALG_IS_STREAM_CIPHER(alg) \</span></div><div class="line"><a name="l00843"></a><span class="lineno"> 843</span> <span class="preprocessor"> (((alg) & (PSA_ALG_CATEGORY_MASK | PSA_ALG_CIPHER_STREAM_FLAG)) == \</span></div><div class="line"><a name="l00844"></a><span class="lineno"> 844</span> <span class="preprocessor"> (PSA_ALG_CATEGORY_CIPHER | PSA_ALG_CIPHER_STREAM_FLAG))</span></div><div class="line"><a name="l00845"></a><span class="lineno"> 845</span> </div><div class="line"><a name="l00848"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gab6a5284decb0e5e1b5b8740a41ef3c5e"> 848</a></span> <span class="preprocessor">#define PSA_ALG_ARC4 ((psa_algorithm_t)0x04800001)</span></div><div class="line"><a name="l00849"></a><span class="lineno"> 849</span> </div><div class="line"><a name="l00857"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gad318309706a769cffdc64e4c7e06b2e9"> 857</a></span> <span class="preprocessor">#define PSA_ALG_CTR ((psa_algorithm_t)0x04c00001)</span></div><div class="line"><a name="l00858"></a><span class="lineno"> 858</span> </div><div class="line"><a name="l00859"></a><span class="lineno"> 859</span> <span class="preprocessor">#define PSA_ALG_CFB ((psa_algorithm_t)0x04c00002)</span></div><div class="line"><a name="l00860"></a><span class="lineno"> 860</span> </div><div class="line"><a name="l00861"></a><span class="lineno"> 861</span> <span class="preprocessor">#define PSA_ALG_OFB ((psa_algorithm_t)0x04c00003)</span></div><div class="line"><a name="l00862"></a><span class="lineno"> 862</span> </div><div class="line"><a name="l00869"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaa722c0e426a797fd6d99623f59748125"> 869</a></span> <span class="preprocessor">#define PSA_ALG_XTS ((psa_algorithm_t)0x044000ff)</span></div><div class="line"><a name="l00870"></a><span class="lineno"> 870</span> </div><div class="line"><a name="l00878"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gacb332d72716958880ee7f97d8365ae66"> 878</a></span> <span class="preprocessor">#define PSA_ALG_CBC_NO_PADDING ((psa_algorithm_t)0x04600100)</span></div><div class="line"><a name="l00879"></a><span class="lineno"> 879</span> </div><div class="line"><a name="l00886"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaef50d2e9716eb6d476046608e4e0c78c"> 886</a></span> <span class="preprocessor">#define PSA_ALG_CBC_PKCS7 ((psa_algorithm_t)0x04600101)</span></div><div class="line"><a name="l00887"></a><span class="lineno"> 887</span> </div><div class="line"><a name="l00890"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gac2c0e7d21f1b2df5e76bcb4a8f84273c"> 890</a></span> <span class="preprocessor">#define PSA_ALG_CCM ((psa_algorithm_t)0x06001001)</span></div><div class="line"><a name="l00891"></a><span class="lineno"> 891</span> </div><div class="line"><a name="l00894"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga0d7d02b15aaae490d38277d99f1c637c"> 894</a></span> <span class="preprocessor">#define PSA_ALG_GCM ((psa_algorithm_t)0x06001002)</span></div><div class="line"><a name="l00895"></a><span class="lineno"> 895</span> </div><div class="line"><a name="l00896"></a><span class="lineno"> 896</span> <span class="comment">/* In the encoding of a AEAD algorithm, the bits corresponding to</span></div><div class="line"><a name="l00897"></a><span class="lineno"> 897</span> <span class="comment"> * PSA_ALG_AEAD_TAG_LENGTH_MASK encode the length of the AEAD tag.</span></div><div class="line"><a name="l00898"></a><span class="lineno"> 898</span> <span class="comment"> * The constants for default lengths follow this encoding.</span></div><div class="line"><a name="l00899"></a><span class="lineno"> 899</span> <span class="comment"> */</span></div><div class="line"><a name="l00900"></a><span class="lineno"> 900</span> <span class="preprocessor">#define PSA_ALG_AEAD_TAG_LENGTH_MASK ((psa_algorithm_t)0x00003f00)</span></div><div class="line"><a name="l00901"></a><span class="lineno"> 901</span> <span class="preprocessor">#define PSA_AEAD_TAG_LENGTH_OFFSET 8</span></div><div class="line"><a name="l00902"></a><span class="lineno"> 902</span> </div><div class="line"><a name="l00921"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaa63c520b62ab001d54d28801742fc9db"> 921</a></span> <span class="preprocessor">#define PSA_ALG_AEAD_WITH_TAG_LENGTH(alg, tag_length) \</span></div><div class="line"><a name="l00922"></a><span class="lineno"> 922</span> <span class="preprocessor"> (((alg) & ~PSA_ALG_AEAD_TAG_LENGTH_MASK) | \</span></div><div class="line"><a name="l00923"></a><span class="lineno"> 923</span> <span class="preprocessor"> ((tag_length) << PSA_AEAD_TAG_LENGTH_OFFSET & \</span></div><div class="line"><a name="l00924"></a><span class="lineno"> 924</span> <span class="preprocessor"> PSA_ALG_AEAD_TAG_LENGTH_MASK))</span></div><div class="line"><a name="l00925"></a><span class="lineno"> 925</span> </div><div class="line"><a name="l00934"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaddea507e062250cda8a29407a9480d2b"> 934</a></span> <span class="preprocessor">#define PSA_ALG_AEAD_WITH_DEFAULT_TAG_LENGTH(alg) \</span></div><div class="line"><a name="l00935"></a><span class="lineno"> 935</span> <span class="preprocessor"> ( \</span></div><div class="line"><a name="l00936"></a><span class="lineno"> 936</span> <span class="preprocessor"> PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE(alg, PSA_ALG_CCM) \</span></div><div class="line"><a name="l00937"></a><span class="lineno"> 937</span> <span class="preprocessor"> PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE(alg, PSA_ALG_GCM) \</span></div><div class="line"><a name="l00938"></a><span class="lineno"> 938</span> <span class="preprocessor"> 0)</span></div><div class="line"><a name="l00939"></a><span class="lineno"> 939</span> <span class="preprocessor">#define PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE(alg, ref) \</span></div><div class="line"><a name="l00940"></a><span class="lineno"> 940</span> <span class="preprocessor"> PSA_ALG_AEAD_WITH_TAG_LENGTH(alg, 0) == \</span></div><div class="line"><a name="l00941"></a><span class="lineno"> 941</span> <span class="preprocessor"> PSA_ALG_AEAD_WITH_TAG_LENGTH(ref, 0) ? \</span></div><div class="line"><a name="l00942"></a><span class="lineno"> 942</span> <span class="preprocessor"> ref :</span></div><div class="line"><a name="l00943"></a><span class="lineno"> 943</span> </div><div class="line"><a name="l00944"></a><span class="lineno"> 944</span> <span class="preprocessor">#define PSA_ALG_RSA_PKCS1V15_SIGN_BASE ((psa_algorithm_t)0x10020000)</span></div><div class="line"><a name="l00945"></a><span class="lineno"> 945</span> </div><div class="line"><a name="l00960"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga702ff75385a6ae7d4247033f479439af"> 960</a></span> <span class="preprocessor">#define PSA_ALG_RSA_PKCS1V15_SIGN(hash_alg) \</span></div><div class="line"><a name="l00961"></a><span class="lineno"> 961</span> <span class="preprocessor"> (PSA_ALG_RSA_PKCS1V15_SIGN_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l00962"></a><span class="lineno"> 962</span> </div><div class="line"><a name="l00968"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga4215e2a78dcf834e9a625927faa2a817"> 968</a></span> <span class="preprocessor">#define PSA_ALG_RSA_PKCS1V15_SIGN_RAW PSA_ALG_RSA_PKCS1V15_SIGN_BASE</span></div><div class="line"><a name="l00969"></a><span class="lineno"> 969</span> <span class="preprocessor">#define PSA_ALG_IS_RSA_PKCS1V15_SIGN(alg) \</span></div><div class="line"><a name="l00970"></a><span class="lineno"> 970</span> <span class="preprocessor"> (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_RSA_PKCS1V15_SIGN_BASE)</span></div><div class="line"><a name="l00971"></a><span class="lineno"> 971</span> </div><div class="line"><a name="l00972"></a><span class="lineno"> 972</span> <span class="preprocessor">#define PSA_ALG_RSA_PSS_BASE ((psa_algorithm_t)0x10030000)</span></div><div class="line"><a name="l00973"></a><span class="lineno"> 973</span> </div><div class="line"><a name="l00991"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga62152bf4cb4bf6aace5e1be8f143564d"> 991</a></span> <span class="preprocessor">#define PSA_ALG_RSA_PSS(hash_alg) \</span></div><div class="line"><a name="l00992"></a><span class="lineno"> 992</span> <span class="preprocessor"> (PSA_ALG_RSA_PSS_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l00993"></a><span class="lineno"> 993</span> <span class="preprocessor">#define PSA_ALG_IS_RSA_PSS(alg) \</span></div><div class="line"><a name="l00994"></a><span class="lineno"> 994</span> <span class="preprocessor"> (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_RSA_PSS_BASE)</span></div><div class="line"><a name="l00995"></a><span class="lineno"> 995</span> </div><div class="line"><a name="l00996"></a><span class="lineno"> 996</span> <span class="preprocessor">#define PSA_ALG_DSA_BASE ((psa_algorithm_t)0x10040000)</span></div><div class="line"><a name="l00997"></a><span class="lineno"> 997</span> </div><div class="line"><a name="l01011"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga9a68efdddff5ae95f104a1416b12742e"> 1011</a></span> <span class="preprocessor">#define PSA_ALG_DSA(hash_alg) \</span></div><div class="line"><a name="l01012"></a><span class="lineno"> 1012</span> <span class="preprocessor"> (PSA_ALG_DSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l01013"></a><span class="lineno"> 1013</span> <span class="preprocessor">#define PSA_ALG_DETERMINISTIC_DSA_BASE ((psa_algorithm_t)0x10050000)</span></div><div class="line"><a name="l01014"></a><span class="lineno"> 1014</span> <span class="preprocessor">#define PSA_ALG_DSA_DETERMINISTIC_FLAG ((psa_algorithm_t)0x00010000)</span></div><div class="line"><a name="l01015"></a><span class="lineno"> 1015</span> </div><div class="line"><a name="l01029"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gab8eb98fb6d2e094e47f3b44dfe128f94"> 1029</a></span> <span class="preprocessor">#define PSA_ALG_DETERMINISTIC_DSA(hash_alg) \</span></div><div class="line"><a name="l01030"></a><span class="lineno"> 1030</span> <span class="preprocessor"> (PSA_ALG_DETERMINISTIC_DSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l01031"></a><span class="lineno"> 1031</span> <span class="preprocessor">#define PSA_ALG_IS_DSA(alg) \</span></div><div class="line"><a name="l01032"></a><span class="lineno"> 1032</span> <span class="preprocessor"> (((alg) & ~PSA_ALG_HASH_MASK & ~PSA_ALG_DSA_DETERMINISTIC_FLAG) == \</span></div><div class="line"><a name="l01033"></a><span class="lineno"> 1033</span> <span class="preprocessor"> PSA_ALG_DSA_BASE)</span></div><div class="line"><a name="l01034"></a><span class="lineno"> 1034</span> <span class="preprocessor">#define PSA_ALG_DSA_IS_DETERMINISTIC(alg) \</span></div><div class="line"><a name="l01035"></a><span class="lineno"> 1035</span> <span class="preprocessor"> (((alg) & PSA_ALG_DSA_DETERMINISTIC_FLAG) != 0)</span></div><div class="line"><a name="l01036"></a><span class="lineno"> 1036</span> <span class="preprocessor">#define PSA_ALG_IS_DETERMINISTIC_DSA(alg) \</span></div><div class="line"><a name="l01037"></a><span class="lineno"> 1037</span> <span class="preprocessor"> (PSA_ALG_IS_DSA(alg) && PSA_ALG_DSA_IS_DETERMINISTIC(alg))</span></div><div class="line"><a name="l01038"></a><span class="lineno"> 1038</span> <span class="preprocessor">#define PSA_ALG_IS_RANDOMIZED_DSA(alg) \</span></div><div class="line"><a name="l01039"></a><span class="lineno"> 1039</span> <span class="preprocessor"> (PSA_ALG_IS_DSA(alg) && !PSA_ALG_DSA_IS_DETERMINISTIC(alg))</span></div><div class="line"><a name="l01040"></a><span class="lineno"> 1040</span> </div><div class="line"><a name="l01041"></a><span class="lineno"> 1041</span> <span class="preprocessor">#define PSA_ALG_ECDSA_BASE ((psa_algorithm_t)0x10060000)</span></div><div class="line"><a name="l01042"></a><span class="lineno"> 1042</span> </div><div class="line"><a name="l01062"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga7e3ce9f514a227d5ba5d8318870452e3"> 1062</a></span> <span class="preprocessor">#define PSA_ALG_ECDSA(hash_alg) \</span></div><div class="line"><a name="l01063"></a><span class="lineno"> 1063</span> <span class="preprocessor"> (PSA_ALG_ECDSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l01064"></a><span class="lineno"> 1064</span> </div><div class="line"><a name="l01073"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga51d6b6044a62e33cae0cf64bfc3b22a4"> 1073</a></span> <span class="preprocessor">#define PSA_ALG_ECDSA_ANY PSA_ALG_ECDSA_BASE</span></div><div class="line"><a name="l01074"></a><span class="lineno"> 1074</span> <span class="preprocessor">#define PSA_ALG_DETERMINISTIC_ECDSA_BASE ((psa_algorithm_t)0x10070000)</span></div><div class="line"><a name="l01075"></a><span class="lineno"> 1075</span> </div><div class="line"><a name="l01097"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga11da566bcd341661c8de921e2ca5ed03"> 1097</a></span> <span class="preprocessor">#define PSA_ALG_DETERMINISTIC_ECDSA(hash_alg) \</span></div><div class="line"><a name="l01098"></a><span class="lineno"> 1098</span> <span class="preprocessor"> (PSA_ALG_DETERMINISTIC_ECDSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l01099"></a><span class="lineno"> 1099</span> <span class="preprocessor">#define PSA_ALG_IS_ECDSA(alg) \</span></div><div class="line"><a name="l01100"></a><span class="lineno"> 1100</span> <span class="preprocessor"> (((alg) & ~PSA_ALG_HASH_MASK & ~PSA_ALG_DSA_DETERMINISTIC_FLAG) == \</span></div><div class="line"><a name="l01101"></a><span class="lineno"> 1101</span> <span class="preprocessor"> PSA_ALG_ECDSA_BASE)</span></div><div class="line"><a name="l01102"></a><span class="lineno"> 1102</span> <span class="preprocessor">#define PSA_ALG_ECDSA_IS_DETERMINISTIC(alg) \</span></div><div class="line"><a name="l01103"></a><span class="lineno"> 1103</span> <span class="preprocessor"> (((alg) & PSA_ALG_DSA_DETERMINISTIC_FLAG) != 0)</span></div><div class="line"><a name="l01104"></a><span class="lineno"> 1104</span> <span class="preprocessor">#define PSA_ALG_IS_DETERMINISTIC_ECDSA(alg) \</span></div><div class="line"><a name="l01105"></a><span class="lineno"> 1105</span> <span class="preprocessor"> (PSA_ALG_IS_ECDSA(alg) && PSA_ALG_ECDSA_IS_DETERMINISTIC(alg))</span></div><div class="line"><a name="l01106"></a><span class="lineno"> 1106</span> <span class="preprocessor">#define PSA_ALG_IS_RANDOMIZED_ECDSA(alg) \</span></div><div class="line"><a name="l01107"></a><span class="lineno"> 1107</span> <span class="preprocessor"> (PSA_ALG_IS_ECDSA(alg) && !PSA_ALG_ECDSA_IS_DETERMINISTIC(alg))</span></div><div class="line"><a name="l01108"></a><span class="lineno"> 1108</span> </div><div class="line"><a name="l01122"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gad8a8ea0536975363b66410cdeafe38b6"> 1122</a></span> <span class="preprocessor">#define PSA_ALG_IS_HASH_AND_SIGN(alg) \</span></div><div class="line"><a name="l01123"></a><span class="lineno"> 1123</span> <span class="preprocessor"> (PSA_ALG_IS_RSA_PSS(alg) || PSA_ALG_IS_RSA_PKCS1V15_SIGN(alg) || \</span></div><div class="line"><a name="l01124"></a><span class="lineno"> 1124</span> <span class="preprocessor"> PSA_ALG_IS_DSA(alg) || PSA_ALG_IS_ECDSA(alg))</span></div><div class="line"><a name="l01125"></a><span class="lineno"> 1125</span> </div><div class="line"><a name="l01144"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga24cf6d7bcd2b9aeeeff86f07b6c674e3"> 1144</a></span> <span class="preprocessor">#define PSA_ALG_SIGN_GET_HASH(alg) \</span></div><div class="line"><a name="l01145"></a><span class="lineno"> 1145</span> <span class="preprocessor"> (PSA_ALG_IS_HASH_AND_SIGN(alg) ? \</span></div><div class="line"><a name="l01146"></a><span class="lineno"> 1146</span> <span class="preprocessor"> ((alg) & PSA_ALG_HASH_MASK) == 0 ? </span><span class="comment">/*"raw" algorithm*/</span><span class="preprocessor"> 0 : \</span></div><div class="line"><a name="l01147"></a><span class="lineno"> 1147</span> <span class="preprocessor"> ((alg) & PSA_ALG_HASH_MASK) | PSA_ALG_CATEGORY_HASH : \</span></div><div class="line"><a name="l01148"></a><span class="lineno"> 1148</span> <span class="preprocessor"> 0)</span></div><div class="line"><a name="l01149"></a><span class="lineno"> 1149</span> </div><div class="line"><a name="l01152"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga4c540d3abe43fb9abcb94f2bc51acef9"> 1152</a></span> <span class="preprocessor">#define PSA_ALG_RSA_PKCS1V15_CRYPT ((psa_algorithm_t)0x12020000)</span></div><div class="line"><a name="l01153"></a><span class="lineno"> 1153</span> </div><div class="line"><a name="l01154"></a><span class="lineno"> 1154</span> <span class="preprocessor">#define PSA_ALG_RSA_OAEP_BASE ((psa_algorithm_t)0x12030000)</span></div><div class="line"><a name="l01155"></a><span class="lineno"> 1155</span> </div><div class="line"><a name="l01169"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaa1235dc3fdd9839c6c1b1a9857344c76"> 1169</a></span> <span class="preprocessor">#define PSA_ALG_RSA_OAEP(hash_alg) \</span></div><div class="line"><a name="l01170"></a><span class="lineno"> 1170</span> <span class="preprocessor"> (PSA_ALG_RSA_OAEP_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l01171"></a><span class="lineno"> 1171</span> <span class="preprocessor">#define PSA_ALG_IS_RSA_OAEP(alg) \</span></div><div class="line"><a name="l01172"></a><span class="lineno"> 1172</span> <span class="preprocessor"> (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_RSA_OAEP_BASE)</span></div><div class="line"><a name="l01173"></a><span class="lineno"> 1173</span> <span class="preprocessor">#define PSA_ALG_RSA_OAEP_GET_HASH(alg) \</span></div><div class="line"><a name="l01174"></a><span class="lineno"> 1174</span> <span class="preprocessor"> (PSA_ALG_IS_RSA_OAEP(alg) ? \</span></div><div class="line"><a name="l01175"></a><span class="lineno"> 1175</span> <span class="preprocessor"> ((alg) & PSA_ALG_HASH_MASK) | PSA_ALG_CATEGORY_HASH : \</span></div><div class="line"><a name="l01176"></a><span class="lineno"> 1176</span> <span class="preprocessor"> 0)</span></div><div class="line"><a name="l01177"></a><span class="lineno"> 1177</span> </div><div class="line"><a name="l01178"></a><span class="lineno"> 1178</span> <span class="preprocessor">#define PSA_ALG_HKDF_BASE ((psa_algorithm_t)0x20000100)</span></div><div class="line"><a name="l01179"></a><span class="lineno"> 1179</span> </div><div class="line"><a name="l01199"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga32a888fb360e6e25cab8a343772c4a82"> 1199</a></span> <span class="preprocessor">#define PSA_ALG_HKDF(hash_alg) \</span></div><div class="line"><a name="l01200"></a><span class="lineno"> 1200</span> <span class="preprocessor"> (PSA_ALG_HKDF_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l01201"></a><span class="lineno"> 1201</span> </div><div class="line"><a name="l01212"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga1979d0a76fcee6164cf2e65960f38db2"> 1212</a></span> <span class="preprocessor">#define PSA_ALG_IS_HKDF(alg) \</span></div><div class="line"><a name="l01213"></a><span class="lineno"> 1213</span> <span class="preprocessor"> (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_HKDF_BASE)</span></div><div class="line"><a name="l01214"></a><span class="lineno"> 1214</span> <span class="preprocessor">#define PSA_ALG_HKDF_GET_HASH(hkdf_alg) \</span></div><div class="line"><a name="l01215"></a><span class="lineno"> 1215</span> <span class="preprocessor"> (PSA_ALG_CATEGORY_HASH | ((hkdf_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l01216"></a><span class="lineno"> 1216</span> </div><div class="line"><a name="l01217"></a><span class="lineno"> 1217</span> <span class="preprocessor">#define PSA_ALG_TLS12_PRF_BASE ((psa_algorithm_t)0x20000200)</span></div><div class="line"><a name="l01218"></a><span class="lineno"> 1218</span> </div><div class="line"><a name="l01240"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga6d5623c2ccda1d4a84e34351af8382d5"> 1240</a></span> <span class="preprocessor">#define PSA_ALG_TLS12_PRF(hash_alg) \</span></div><div class="line"><a name="l01241"></a><span class="lineno"> 1241</span> <span class="preprocessor"> (PSA_ALG_TLS12_PRF_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l01242"></a><span class="lineno"> 1242</span> </div><div class="line"><a name="l01251"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaa3c18890c50222e5219f40ade8927e66"> 1251</a></span> <span class="preprocessor">#define PSA_ALG_IS_TLS12_PRF(alg) \</span></div><div class="line"><a name="l01252"></a><span class="lineno"> 1252</span> <span class="preprocessor"> (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_TLS12_PRF_BASE)</span></div><div class="line"><a name="l01253"></a><span class="lineno"> 1253</span> <span class="preprocessor">#define PSA_ALG_TLS12_PRF_GET_HASH(hkdf_alg) \</span></div><div class="line"><a name="l01254"></a><span class="lineno"> 1254</span> <span class="preprocessor"> (PSA_ALG_CATEGORY_HASH | ((hkdf_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l01255"></a><span class="lineno"> 1255</span> </div><div class="line"><a name="l01256"></a><span class="lineno"> 1256</span> <span class="preprocessor">#define PSA_ALG_TLS12_PSK_TO_MS_BASE ((psa_algorithm_t)0x20000300)</span></div><div class="line"><a name="l01257"></a><span class="lineno"> 1257</span> </div><div class="line"><a name="l01280"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga039ec797f15d1635d9b2e09a611f8a68"> 1280</a></span> <span class="preprocessor">#define PSA_ALG_TLS12_PSK_TO_MS(hash_alg) \</span></div><div class="line"><a name="l01281"></a><span class="lineno"> 1281</span> <span class="preprocessor"> (PSA_ALG_TLS12_PSK_TO_MS_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l01282"></a><span class="lineno"> 1282</span> </div><div class="line"><a name="l01291"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gab25ecc074a93fd11069bedfbba5a287b"> 1291</a></span> <span class="preprocessor">#define PSA_ALG_IS_TLS12_PSK_TO_MS(alg) \</span></div><div class="line"><a name="l01292"></a><span class="lineno"> 1292</span> <span class="preprocessor"> (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_TLS12_PSK_TO_MS_BASE)</span></div><div class="line"><a name="l01293"></a><span class="lineno"> 1293</span> <span class="preprocessor">#define PSA_ALG_TLS12_PSK_TO_MS_GET_HASH(hkdf_alg) \</span></div><div class="line"><a name="l01294"></a><span class="lineno"> 1294</span> <span class="preprocessor"> (PSA_ALG_CATEGORY_HASH | ((hkdf_alg) & PSA_ALG_HASH_MASK))</span></div><div class="line"><a name="l01295"></a><span class="lineno"> 1295</span> </div><div class="line"><a name="l01296"></a><span class="lineno"> 1296</span> <span class="preprocessor">#define PSA_ALG_KEY_DERIVATION_MASK ((psa_algorithm_t)0x080fffff)</span></div><div class="line"><a name="l01297"></a><span class="lineno"> 1297</span> <span class="preprocessor">#define PSA_ALG_KEY_AGREEMENT_MASK ((psa_algorithm_t)0x10f00000)</span></div><div class="line"><a name="l01298"></a><span class="lineno"> 1298</span> </div><div class="line"><a name="l01313"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga78bb81cffb87a635c247725eeb2a2682"> 1313</a></span> <span class="preprocessor">#define PSA_ALG_KEY_AGREEMENT(ka_alg, kdf_alg) \</span></div><div class="line"><a name="l01314"></a><span class="lineno"> 1314</span> <span class="preprocessor"> ((ka_alg) | (kdf_alg))</span></div><div class="line"><a name="l01315"></a><span class="lineno"> 1315</span> </div><div class="line"><a name="l01316"></a><span class="lineno"> 1316</span> <span class="preprocessor">#define PSA_ALG_KEY_AGREEMENT_GET_KDF(alg) \</span></div><div class="line"><a name="l01317"></a><span class="lineno"> 1317</span> <span class="preprocessor"> (((alg) & PSA_ALG_KEY_DERIVATION_MASK) | PSA_ALG_CATEGORY_KEY_DERIVATION)</span></div><div class="line"><a name="l01318"></a><span class="lineno"> 1318</span> </div><div class="line"><a name="l01319"></a><span class="lineno"> 1319</span> <span class="preprocessor">#define PSA_ALG_KEY_AGREEMENT_GET_BASE(alg) \</span></div><div class="line"><a name="l01320"></a><span class="lineno"> 1320</span> <span class="preprocessor"> (((alg) & PSA_ALG_KEY_AGREEMENT_MASK) | PSA_ALG_CATEGORY_KEY_AGREEMENT)</span></div><div class="line"><a name="l01321"></a><span class="lineno"> 1321</span> </div><div class="line"><a name="l01336"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaa40ab362ce141ce541d69b2eb1f41438"> 1336</a></span> <span class="preprocessor">#define PSA_ALG_IS_RAW_KEY_AGREEMENT(alg) \</span></div><div class="line"><a name="l01337"></a><span class="lineno"> 1337</span> <span class="preprocessor"> (PSA_ALG_IS_KEY_AGREEMENT(alg) && \</span></div><div class="line"><a name="l01338"></a><span class="lineno"> 1338</span> <span class="preprocessor"> PSA_ALG_KEY_AGREEMENT_GET_KDF(alg) == PSA_ALG_CATEGORY_KEY_DERIVATION)</span></div><div class="line"><a name="l01339"></a><span class="lineno"> 1339</span> </div><div class="line"><a name="l01340"></a><span class="lineno"> 1340</span> <span class="preprocessor">#define PSA_ALG_IS_KEY_DERIVATION_OR_AGREEMENT(alg) \</span></div><div class="line"><a name="l01341"></a><span class="lineno"> 1341</span> <span class="preprocessor"> ((PSA_ALG_IS_KEY_DERIVATION(alg) || PSA_ALG_IS_KEY_AGREEMENT(alg)))</span></div><div class="line"><a name="l01342"></a><span class="lineno"> 1342</span> </div><div class="line"><a name="l01351"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga0ebbb6f93a05b6511e6f108ffd2d1eb4"> 1351</a></span> <span class="preprocessor">#define PSA_ALG_FFDH ((psa_algorithm_t)0x30100000)</span></div><div class="line"><a name="l01352"></a><span class="lineno"> 1352</span> </div><div class="line"><a name="l01364"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gaa3cf76164cd9375af4fb8a291078a19e"> 1364</a></span> <span class="preprocessor">#define PSA_ALG_IS_FFDH(alg) \</span></div><div class="line"><a name="l01365"></a><span class="lineno"> 1365</span> <span class="preprocessor"> (PSA_ALG_KEY_AGREEMENT_GET_BASE(alg) == PSA_ALG_FFDH)</span></div><div class="line"><a name="l01366"></a><span class="lineno"> 1366</span> </div><div class="line"><a name="l01392"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gab2dbcf71b63785e7dd7b54a100edee43"> 1392</a></span> <span class="preprocessor">#define PSA_ALG_ECDH ((psa_algorithm_t)0x30200000)</span></div><div class="line"><a name="l01393"></a><span class="lineno"> 1393</span> </div><div class="line"><a name="l01407"></a><span class="lineno"><a class="line" href="group__crypto__types.html#ga9d9b6533d2a6bea7bac7ae01facb820d"> 1407</a></span> <span class="preprocessor">#define PSA_ALG_IS_ECDH(alg) \</span></div><div class="line"><a name="l01408"></a><span class="lineno"> 1408</span> <span class="preprocessor"> (PSA_ALG_KEY_AGREEMENT_GET_BASE(alg) == PSA_ALG_ECDH)</span></div><div class="line"><a name="l01409"></a><span class="lineno"> 1409</span> </div><div class="line"><a name="l01423"></a><span class="lineno"><a class="line" href="group__crypto__types.html#gacf83d7430e82b97cecb8b26ca6fa1426"> 1423</a></span> <span class="preprocessor">#define PSA_ALG_IS_WILDCARD(alg) \</span></div><div class="line"><a name="l01424"></a><span class="lineno"> 1424</span> <span class="preprocessor"> (PSA_ALG_IS_HASH_AND_SIGN(alg) ? \</span></div><div class="line"><a name="l01425"></a><span class="lineno"> 1425</span> <span class="preprocessor"> PSA_ALG_SIGN_GET_HASH(alg) == PSA_ALG_ANY_HASH : \</span></div><div class="line"><a name="l01426"></a><span class="lineno"> 1426</span> <span class="preprocessor"> (alg) == PSA_ALG_ANY_HASH)</span></div><div class="line"><a name="l01427"></a><span class="lineno"> 1427</span> </div><div class="line"><a name="l01437"></a><span class="lineno"><a class="line" href="group__key__lifetimes.html#ga8b438870ba69489b685730d346455108"> 1437</a></span> <span class="preprocessor">#define PSA_KEY_LIFETIME_VOLATILE ((psa_key_lifetime_t)0x00000000)</span></div><div class="line"><a name="l01438"></a><span class="lineno"> 1438</span> </div><div class="line"><a name="l01451"></a><span class="lineno"><a class="line" href="group__key__lifetimes.html#ga3713a01c5fcd5f7eae46ff22ceaf6d02"> 1451</a></span> <span class="preprocessor">#define PSA_KEY_LIFETIME_PERSISTENT ((psa_key_lifetime_t)0x00000001)</span></div><div class="line"><a name="l01452"></a><span class="lineno"> 1452</span> </div><div class="line"><a name="l01470"></a><span class="lineno"><a class="line" href="group__policy.html#ga7dddccdd1303176e87a4d20c87b589ed"> 1470</a></span> <span class="preprocessor">#define PSA_KEY_USAGE_EXPORT ((psa_key_usage_t)0x00000001)</span></div><div class="line"><a name="l01471"></a><span class="lineno"> 1471</span> </div><div class="line"><a name="l01481"></a><span class="lineno"><a class="line" href="group__policy.html#ga75153b296d045d529d97203a6a995dad"> 1481</a></span> <span class="preprocessor">#define PSA_KEY_USAGE_ENCRYPT ((psa_key_usage_t)0x00000100)</span></div><div class="line"><a name="l01482"></a><span class="lineno"> 1482</span> </div><div class="line"><a name="l01492"></a><span class="lineno"><a class="line" href="group__policy.html#gac3f2d2e5983db1edde9f142ca9bf8e6a"> 1492</a></span> <span class="preprocessor">#define PSA_KEY_USAGE_DECRYPT ((psa_key_usage_t)0x00000200)</span></div><div class="line"><a name="l01493"></a><span class="lineno"> 1493</span> </div><div class="line"><a name="l01502"></a><span class="lineno"><a class="line" href="group__policy.html#ga99b9f456cf59efc4b5579465407aef5a"> 1502</a></span> <span class="preprocessor">#define PSA_KEY_USAGE_SIGN ((psa_key_usage_t)0x00000400)</span></div><div class="line"><a name="l01503"></a><span class="lineno"> 1503</span> </div><div class="line"><a name="l01512"></a><span class="lineno"><a class="line" href="group__policy.html#ga39b54ffd5958b69634607924fa53cea6"> 1512</a></span> <span class="preprocessor">#define PSA_KEY_USAGE_VERIFY ((psa_key_usage_t)0x00000800)</span></div><div class="line"><a name="l01513"></a><span class="lineno"> 1513</span> </div><div class="line"><a name="l01516"></a><span class="lineno"><a class="line" href="group__policy.html#gaf19022acc5ef23cf12477f632b48a0b2"> 1516</a></span> <span class="preprocessor">#define PSA_KEY_USAGE_DERIVE ((psa_key_usage_t)0x00001000)</span></div><div class="line"><a name="l01517"></a><span class="lineno"> 1517</span> </div><div class="line"><a name="l01528"></a><span class="lineno"><a class="line" href="group__derivation.html#ga90a1995a41e26ed5ca30d2d4641d1168"> 1528</a></span> <span class="preprocessor">#define PSA_KDF_STEP_SECRET ((psa_key_derivation_step_t)0x0101)</span></div><div class="line"><a name="l01529"></a><span class="lineno"> 1529</span> </div><div class="line"><a name="l01534"></a><span class="lineno"><a class="line" href="group__derivation.html#ga9f4da10191bcb690b88756ed8470b03c"> 1534</a></span> <span class="preprocessor">#define PSA_KDF_STEP_LABEL ((psa_key_derivation_step_t)0x0201)</span></div><div class="line"><a name="l01535"></a><span class="lineno"> 1535</span> </div><div class="line"><a name="l01540"></a><span class="lineno"><a class="line" href="group__derivation.html#ga384777dac55791d8f3a1af72c847b327"> 1540</a></span> <span class="preprocessor">#define PSA_KDF_STEP_SALT ((psa_key_derivation_step_t)0x0202)</span></div><div class="line"><a name="l01541"></a><span class="lineno"> 1541</span> </div><div class="line"><a name="l01546"></a><span class="lineno"><a class="line" href="group__derivation.html#ga836afe760bbda3dafc6c29631560b1a0"> 1546</a></span> <span class="preprocessor">#define PSA_KDF_STEP_INFO ((psa_key_derivation_step_t)0x0203)</span></div><div class="line"><a name="l01547"></a><span class="lineno"> 1547</span> </div><div class="line"><a name="l01550"></a><span class="lineno"> 1550</span> <span class="preprocessor">#endif </span><span class="comment">/* PSA_CRYPTO_VALUES_H */</span><span class="preprocessor"></span></div></div><!-- fragment --></div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/dir_7dae9cfde651cd3cb034485ce5e391b9.html b/docs/html/dir_7dae9cfde651cd3cb034485ce5e391b9.html
deleted file mode 100644
index cef9bc1..0000000
--- a/docs/html/dir_7dae9cfde651cd3cb034485ce5e391b9.html
+++ /dev/null
@@ -1,117 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: psa Directory Reference</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li class="current"><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
- <div id="navrow2" class="tabs2">
- <ul class="tablist">
- <li class="current"><a href="files.html"><span>File List</span></a></li>
- <li><a href="globals.html"><span>File Members</span></a></li>
- </ul>
- </div>
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div id="nav-path" class="navpath">
- <ul>
-<li class="navelem"><a class="el" href="dir_7dae9cfde651cd3cb034485ce5e391b9.html">psa</a></li> </ul>
-</div>
-</div><!-- top -->
-<div class="header">
- <div class="headertitle">
-<div class="title">psa Directory Reference</div> </div>
-</div><!--header-->
-<div class="contents">
-<table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="files"></a>
-Files</h2></td></tr>
-<tr class="memitem:crypto_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><a class="el" href="crypto_8h.html">crypto.h</a> <a href="crypto_8h_source.html">[code]</a></td></tr>
-<tr class="memdesc:crypto_8h"><td class="mdescLeft"> </td><td class="mdescRight">Platform Security Architecture cryptography module. <br /></td></tr>
-<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:crypto__sizes_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><a class="el" href="crypto__sizes_8h.html">crypto_sizes.h</a> <a href="crypto__sizes_8h_source.html">[code]</a></td></tr>
-<tr class="memdesc:crypto__sizes_8h"><td class="mdescLeft"> </td><td class="mdescRight">PSA cryptography module: Mbed TLS buffer size macros. <br /></td></tr>
-<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:crypto__types_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><a class="el" href="crypto__types_8h.html">crypto_types.h</a> <a href="crypto__types_8h_source.html">[code]</a></td></tr>
-<tr class="memdesc:crypto__types_8h"><td class="mdescLeft"> </td><td class="mdescRight">PSA cryptography module: type aliases. <br /></td></tr>
-<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:crypto__values_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><a class="el" href="crypto__values_8h.html">crypto_values.h</a> <a href="crypto__values_8h_source.html">[code]</a></td></tr>
-<tr class="memdesc:crypto__values_8h"><td class="mdescLeft"> </td><td class="mdescRight">PSA cryptography module: macros to build and analyze integer values. <br /></td></tr>
-<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
-</table>
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/doc.png b/docs/html/doc.png
deleted file mode 100644
index 17edabf..0000000
--- a/docs/html/doc.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/doxygen.css b/docs/html/doxygen.css
deleted file mode 100644
index 1425ec5..0000000
--- a/docs/html/doxygen.css
+++ /dev/null
@@ -1,1475 +0,0 @@
-/* The standard CSS for doxygen 1.8.11 */
-
-body, table, div, p, dl {
- font: 400 14px/22px Roboto,sans-serif;
-}
-
-/* @group Heading Levels */
-
-h1.groupheader {
- font-size: 150%;
-}
-
-.title {
- font: 400 14px/28px Roboto,sans-serif;
- font-size: 150%;
- font-weight: bold;
- margin: 10px 2px;
-}
-
-h2.groupheader {
- border-bottom: 1px solid #879ECB;
- color: #354C7B;
- font-size: 150%;
- font-weight: normal;
- margin-top: 1.75em;
- padding-top: 8px;
- padding-bottom: 4px;
- width: 100%;
-}
-
-h3.groupheader {
- font-size: 100%;
-}
-
-h1, h2, h3, h4, h5, h6 {
- -webkit-transition: text-shadow 0.5s linear;
- -moz-transition: text-shadow 0.5s linear;
- -ms-transition: text-shadow 0.5s linear;
- -o-transition: text-shadow 0.5s linear;
- transition: text-shadow 0.5s linear;
- margin-right: 15px;
-}
-
-h1.glow, h2.glow, h3.glow, h4.glow, h5.glow, h6.glow {
- text-shadow: 0 0 15px cyan;
-}
-
-dt {
- font-weight: bold;
-}
-
-div.multicol {
- -moz-column-gap: 1em;
- -webkit-column-gap: 1em;
- -moz-column-count: 3;
- -webkit-column-count: 3;
-}
-
-p.startli, p.startdd {
- margin-top: 2px;
-}
-
-p.starttd {
- margin-top: 0px;
-}
-
-p.endli {
- margin-bottom: 0px;
-}
-
-p.enddd {
- margin-bottom: 4px;
-}
-
-p.endtd {
- margin-bottom: 2px;
-}
-
-/* @end */
-
-caption {
- font-weight: bold;
-}
-
-span.legend {
- font-size: 70%;
- text-align: center;
-}
-
-h3.version {
- font-size: 90%;
- text-align: center;
-}
-
-div.qindex, div.navtab{
- background-color: #EBEFF6;
- border: 1px solid #A3B4D7;
- text-align: center;
-}
-
-div.qindex, div.navpath {
- width: 100%;
- line-height: 140%;
-}
-
-div.navtab {
- margin-right: 15px;
-}
-
-/* @group Link Styling */
-
-a {
- color: #3D578C;
- font-weight: normal;
- text-decoration: none;
-}
-
-.contents a:visited {
- color: #4665A2;
-}
-
-a:hover {
- text-decoration: underline;
-}
-
-a.qindex {
- font-weight: bold;
-}
-
-a.qindexHL {
- font-weight: bold;
- background-color: #9CAFD4;
- color: #ffffff;
- border: 1px double #869DCA;
-}
-
-.contents a.qindexHL:visited {
- color: #ffffff;
-}
-
-a.el {
- font-weight: bold;
-}
-
-a.elRef {
-}
-
-a.code, a.code:visited, a.line, a.line:visited {
- color: #4665A2;
-}
-
-a.codeRef, a.codeRef:visited, a.lineRef, a.lineRef:visited {
- color: #4665A2;
-}
-
-/* @end */
-
-dl.el {
- margin-left: -1cm;
-}
-
-pre.fragment {
- border: 1px solid #C4CFE5;
- background-color: #FBFCFD;
- padding: 4px 6px;
- margin: 4px 8px 4px 2px;
- overflow: auto;
- word-wrap: break-word;
- font-size: 9pt;
- line-height: 125%;
- font-family: monospace, fixed;
- font-size: 105%;
-}
-
-div.fragment {
- padding: 4px 6px;
- margin: 4px 8px 4px 2px;
- background-color: #FBFCFD;
- border: 1px solid #C4CFE5;
-}
-
-div.line {
- font-family: monospace, fixed;
- font-size: 13px;
- min-height: 13px;
- line-height: 1.0;
- text-wrap: unrestricted;
- white-space: -moz-pre-wrap; /* Moz */
- white-space: -pre-wrap; /* Opera 4-6 */
- white-space: -o-pre-wrap; /* Opera 7 */
- white-space: pre-wrap; /* CSS3 */
- word-wrap: break-word; /* IE 5.5+ */
- text-indent: -53px;
- padding-left: 53px;
- padding-bottom: 0px;
- margin: 0px;
- -webkit-transition-property: background-color, box-shadow;
- -webkit-transition-duration: 0.5s;
- -moz-transition-property: background-color, box-shadow;
- -moz-transition-duration: 0.5s;
- -ms-transition-property: background-color, box-shadow;
- -ms-transition-duration: 0.5s;
- -o-transition-property: background-color, box-shadow;
- -o-transition-duration: 0.5s;
- transition-property: background-color, box-shadow;
- transition-duration: 0.5s;
-}
-
-div.line:after {
- content:"\000A";
- white-space: pre;
-}
-
-div.line.glow {
- background-color: cyan;
- box-shadow: 0 0 10px cyan;
-}
-
-
-span.lineno {
- padding-right: 4px;
- text-align: right;
- border-right: 2px solid #0F0;
- background-color: #E8E8E8;
- white-space: pre;
-}
-span.lineno a {
- background-color: #D8D8D8;
-}
-
-span.lineno a:hover {
- background-color: #C8C8C8;
-}
-
-div.ah, span.ah {
- background-color: black;
- font-weight: bold;
- color: #ffffff;
- margin-bottom: 3px;
- margin-top: 3px;
- padding: 0.2em;
- border: solid thin #333;
- border-radius: 0.5em;
- -webkit-border-radius: .5em;
- -moz-border-radius: .5em;
- box-shadow: 2px 2px 3px #999;
- -webkit-box-shadow: 2px 2px 3px #999;
- -moz-box-shadow: rgba(0, 0, 0, 0.15) 2px 2px 2px;
- background-image: -webkit-gradient(linear, left top, left bottom, from(#eee), to(#000),color-stop(0.3, #444));
- background-image: -moz-linear-gradient(center top, #eee 0%, #444 40%, #000 110%);
-}
-
-div.classindex ul {
- list-style: none;
- padding-left: 0;
-}
-
-div.classindex span.ai {
- display: inline-block;
-}
-
-div.groupHeader {
- margin-left: 16px;
- margin-top: 12px;
- font-weight: bold;
-}
-
-div.groupText {
- margin-left: 16px;
- font-style: italic;
-}
-
-body {
- background-color: white;
- color: black;
- margin: 0;
-}
-
-div.contents {
- margin-top: 10px;
- margin-left: 12px;
- margin-right: 8px;
-}
-
-td.indexkey {
- background-color: #EBEFF6;
- font-weight: bold;
- border: 1px solid #C4CFE5;
- margin: 2px 0px 2px 0;
- padding: 2px 10px;
- white-space: nowrap;
- vertical-align: top;
-}
-
-td.indexvalue {
- background-color: #EBEFF6;
- border: 1px solid #C4CFE5;
- padding: 2px 10px;
- margin: 2px 0px;
-}
-
-tr.memlist {
- background-color: #EEF1F7;
-}
-
-p.formulaDsp {
- text-align: center;
-}
-
-img.formulaDsp {
-
-}
-
-img.formulaInl {
- vertical-align: middle;
-}
-
-div.center {
- text-align: center;
- margin-top: 0px;
- margin-bottom: 0px;
- padding: 0px;
-}
-
-div.center img {
- border: 0px;
-}
-
-address.footer {
- text-align: right;
- padding-right: 12px;
-}
-
-img.footer {
- border: 0px;
- vertical-align: middle;
-}
-
-/* @group Code Colorization */
-
-span.keyword {
- color: #008000
-}
-
-span.keywordtype {
- color: #604020
-}
-
-span.keywordflow {
- color: #e08000
-}
-
-span.comment {
- color: #800000
-}
-
-span.preprocessor {
- color: #806020
-}
-
-span.stringliteral {
- color: #002080
-}
-
-span.charliteral {
- color: #008080
-}
-
-span.vhdldigit {
- color: #ff00ff
-}
-
-span.vhdlchar {
- color: #000000
-}
-
-span.vhdlkeyword {
- color: #700070
-}
-
-span.vhdllogic {
- color: #ff0000
-}
-
-blockquote {
- background-color: #F7F8FB;
- border-left: 2px solid #9CAFD4;
- margin: 0 24px 0 4px;
- padding: 0 12px 0 16px;
-}
-
-/* @end */
-
-/*
-.search {
- color: #003399;
- font-weight: bold;
-}
-
-form.search {
- margin-bottom: 0px;
- margin-top: 0px;
-}
-
-input.search {
- font-size: 75%;
- color: #000080;
- font-weight: normal;
- background-color: #e8eef2;
-}
-*/
-
-td.tiny {
- font-size: 75%;
-}
-
-.dirtab {
- padding: 4px;
- border-collapse: collapse;
- border: 1px solid #A3B4D7;
-}
-
-th.dirtab {
- background: #EBEFF6;
- font-weight: bold;
-}
-
-hr {
- height: 0px;
- border: none;
- border-top: 1px solid #4A6AAA;
-}
-
-hr.footer {
- height: 1px;
-}
-
-/* @group Member Descriptions */
-
-table.memberdecls {
- border-spacing: 0px;
- padding: 0px;
-}
-
-.memberdecls td, .fieldtable tr {
- -webkit-transition-property: background-color, box-shadow;
- -webkit-transition-duration: 0.5s;
- -moz-transition-property: background-color, box-shadow;
- -moz-transition-duration: 0.5s;
- -ms-transition-property: background-color, box-shadow;
- -ms-transition-duration: 0.5s;
- -o-transition-property: background-color, box-shadow;
- -o-transition-duration: 0.5s;
- transition-property: background-color, box-shadow;
- transition-duration: 0.5s;
-}
-
-.memberdecls td.glow, .fieldtable tr.glow {
- background-color: cyan;
- box-shadow: 0 0 15px cyan;
-}
-
-.mdescLeft, .mdescRight,
-.memItemLeft, .memItemRight,
-.memTemplItemLeft, .memTemplItemRight, .memTemplParams {
- background-color: #F9FAFC;
- border: none;
- margin: 4px;
- padding: 1px 0 0 8px;
-}
-
-.mdescLeft, .mdescRight {
- padding: 0px 8px 4px 8px;
- color: #555;
-}
-
-.memSeparator {
- border-bottom: 1px solid #DEE4F0;
- line-height: 1px;
- margin: 0px;
- padding: 0px;
-}
-
-.memItemLeft, .memTemplItemLeft {
- white-space: nowrap;
-}
-
-.memItemRight {
- width: 100%;
-}
-
-.memTemplParams {
- color: #4665A2;
- white-space: nowrap;
- font-size: 80%;
-}
-
-/* @end */
-
-/* @group Member Details */
-
-/* Styles for detailed member documentation */
-
-.memtemplate {
- font-size: 80%;
- color: #4665A2;
- font-weight: normal;
- margin-left: 9px;
-}
-
-.memnav {
- background-color: #EBEFF6;
- border: 1px solid #A3B4D7;
- text-align: center;
- margin: 2px;
- margin-right: 15px;
- padding: 2px;
-}
-
-.mempage {
- width: 100%;
-}
-
-.memitem {
- padding: 0;
- margin-bottom: 10px;
- margin-right: 5px;
- -webkit-transition: box-shadow 0.5s linear;
- -moz-transition: box-shadow 0.5s linear;
- -ms-transition: box-shadow 0.5s linear;
- -o-transition: box-shadow 0.5s linear;
- transition: box-shadow 0.5s linear;
- display: table !important;
- width: 100%;
-}
-
-.memitem.glow {
- box-shadow: 0 0 15px cyan;
-}
-
-.memname {
- font-weight: bold;
- margin-left: 6px;
-}
-
-.memname td {
- vertical-align: bottom;
-}
-
-.memproto, dl.reflist dt {
- border-top: 1px solid #A8B8D9;
- border-left: 1px solid #A8B8D9;
- border-right: 1px solid #A8B8D9;
- padding: 6px 0px 6px 0px;
- color: #253555;
- font-weight: bold;
- text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9);
- background-image:url('nav_f.png');
- background-repeat:repeat-x;
- background-color: #E2E8F2;
- /* opera specific markup */
- box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
- border-top-right-radius: 4px;
- border-top-left-radius: 4px;
- /* firefox specific markup */
- -moz-box-shadow: rgba(0, 0, 0, 0.15) 5px 5px 5px;
- -moz-border-radius-topright: 4px;
- -moz-border-radius-topleft: 4px;
- /* webkit specific markup */
- -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
- -webkit-border-top-right-radius: 4px;
- -webkit-border-top-left-radius: 4px;
-
-}
-
-.memdoc, dl.reflist dd {
- border-bottom: 1px solid #A8B8D9;
- border-left: 1px solid #A8B8D9;
- border-right: 1px solid #A8B8D9;
- padding: 6px 10px 2px 10px;
- background-color: #FBFCFD;
- border-top-width: 0;
- background-image:url('nav_g.png');
- background-repeat:repeat-x;
- background-color: #FFFFFF;
- /* opera specific markup */
- border-bottom-left-radius: 4px;
- border-bottom-right-radius: 4px;
- box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
- /* firefox specific markup */
- -moz-border-radius-bottomleft: 4px;
- -moz-border-radius-bottomright: 4px;
- -moz-box-shadow: rgba(0, 0, 0, 0.15) 5px 5px 5px;
- /* webkit specific markup */
- -webkit-border-bottom-left-radius: 4px;
- -webkit-border-bottom-right-radius: 4px;
- -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
-}
-
-dl.reflist dt {
- padding: 5px;
-}
-
-dl.reflist dd {
- margin: 0px 0px 10px 0px;
- padding: 5px;
-}
-
-.paramkey {
- text-align: right;
-}
-
-.paramtype {
- white-space: nowrap;
-}
-
-.paramname {
- color: #602020;
- white-space: nowrap;
-}
-.paramname em {
- font-style: normal;
-}
-.paramname code {
- line-height: 14px;
-}
-
-.params, .retval, .exception, .tparams {
- margin-left: 0px;
- padding-left: 0px;
-}
-
-.params .paramname, .retval .paramname {
- font-weight: bold;
- vertical-align: top;
-}
-
-.params .paramtype {
- font-style: italic;
- vertical-align: top;
-}
-
-.params .paramdir {
- font-family: "courier new",courier,monospace;
- vertical-align: top;
-}
-
-table.mlabels {
- border-spacing: 0px;
-}
-
-td.mlabels-left {
- width: 100%;
- padding: 0px;
-}
-
-td.mlabels-right {
- vertical-align: bottom;
- padding: 0px;
- white-space: nowrap;
-}
-
-span.mlabels {
- margin-left: 8px;
-}
-
-span.mlabel {
- background-color: #728DC1;
- border-top:1px solid #5373B4;
- border-left:1px solid #5373B4;
- border-right:1px solid #C4CFE5;
- border-bottom:1px solid #C4CFE5;
- text-shadow: none;
- color: white;
- margin-right: 4px;
- padding: 2px 3px;
- border-radius: 3px;
- font-size: 7pt;
- white-space: nowrap;
- vertical-align: middle;
-}
-
-
-
-/* @end */
-
-/* these are for tree view inside a (index) page */
-
-div.directory {
- margin: 10px 0px;
- border-top: 1px solid #9CAFD4;
- border-bottom: 1px solid #9CAFD4;
- width: 100%;
-}
-
-.directory table {
- border-collapse:collapse;
-}
-
-.directory td {
- margin: 0px;
- padding: 0px;
- vertical-align: top;
-}
-
-.directory td.entry {
- white-space: nowrap;
- padding-right: 6px;
- padding-top: 3px;
-}
-
-.directory td.entry a {
- outline:none;
-}
-
-.directory td.entry a img {
- border: none;
-}
-
-.directory td.desc {
- width: 100%;
- padding-left: 6px;
- padding-right: 6px;
- padding-top: 3px;
- border-left: 1px solid rgba(0,0,0,0.05);
-}
-
-.directory tr.even {
- padding-left: 6px;
- background-color: #F7F8FB;
-}
-
-.directory img {
- vertical-align: -30%;
-}
-
-.directory .levels {
- white-space: nowrap;
- width: 100%;
- text-align: right;
- font-size: 9pt;
-}
-
-.directory .levels span {
- cursor: pointer;
- padding-left: 2px;
- padding-right: 2px;
- color: #3D578C;
-}
-
-.arrow {
- color: #9CAFD4;
- -webkit-user-select: none;
- -khtml-user-select: none;
- -moz-user-select: none;
- -ms-user-select: none;
- user-select: none;
- cursor: pointer;
- font-size: 80%;
- display: inline-block;
- width: 16px;
- height: 22px;
-}
-
-.icon {
- font-family: Arial, Helvetica;
- font-weight: bold;
- font-size: 12px;
- height: 14px;
- width: 16px;
- display: inline-block;
- background-color: #728DC1;
- color: white;
- text-align: center;
- border-radius: 4px;
- margin-left: 2px;
- margin-right: 2px;
-}
-
-.icona {
- width: 24px;
- height: 22px;
- display: inline-block;
-}
-
-.iconfopen {
- width: 24px;
- height: 18px;
- margin-bottom: 4px;
- background-image:url('folderopen.png');
- background-position: 0px -4px;
- background-repeat: repeat-y;
- vertical-align:top;
- display: inline-block;
-}
-
-.iconfclosed {
- width: 24px;
- height: 18px;
- margin-bottom: 4px;
- background-image:url('folderclosed.png');
- background-position: 0px -4px;
- background-repeat: repeat-y;
- vertical-align:top;
- display: inline-block;
-}
-
-.icondoc {
- width: 24px;
- height: 18px;
- margin-bottom: 4px;
- background-image:url('doc.png');
- background-position: 0px -4px;
- background-repeat: repeat-y;
- vertical-align:top;
- display: inline-block;
-}
-
-table.directory {
- font: 400 14px Roboto,sans-serif;
-}
-
-/* @end */
-
-div.dynheader {
- margin-top: 8px;
- -webkit-touch-callout: none;
- -webkit-user-select: none;
- -khtml-user-select: none;
- -moz-user-select: none;
- -ms-user-select: none;
- user-select: none;
-}
-
-address {
- font-style: normal;
- color: #2A3D61;
-}
-
-table.doxtable caption {
- caption-side: top;
-}
-
-table.doxtable {
- border-collapse:collapse;
- margin-top: 4px;
- margin-bottom: 4px;
-}
-
-table.doxtable td, table.doxtable th {
- border: 1px solid #2D4068;
- padding: 3px 7px 2px;
-}
-
-table.doxtable th {
- background-color: #374F7F;
- color: #FFFFFF;
- font-size: 110%;
- padding-bottom: 4px;
- padding-top: 5px;
-}
-
-table.fieldtable {
- /*width: 100%;*/
- margin-bottom: 10px;
- border: 1px solid #A8B8D9;
- border-spacing: 0px;
- -moz-border-radius: 4px;
- -webkit-border-radius: 4px;
- border-radius: 4px;
- -moz-box-shadow: rgba(0, 0, 0, 0.15) 2px 2px 2px;
- -webkit-box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.15);
- box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.15);
-}
-
-.fieldtable td, .fieldtable th {
- padding: 3px 7px 2px;
-}
-
-.fieldtable td.fieldtype, .fieldtable td.fieldname {
- white-space: nowrap;
- border-right: 1px solid #A8B8D9;
- border-bottom: 1px solid #A8B8D9;
- vertical-align: top;
-}
-
-.fieldtable td.fieldname {
- padding-top: 3px;
-}
-
-.fieldtable td.fielddoc {
- border-bottom: 1px solid #A8B8D9;
- /*width: 100%;*/
-}
-
-.fieldtable td.fielddoc p:first-child {
- margin-top: 0px;
-}
-
-.fieldtable td.fielddoc p:last-child {
- margin-bottom: 2px;
-}
-
-.fieldtable tr:last-child td {
- border-bottom: none;
-}
-
-.fieldtable th {
- background-image:url('nav_f.png');
- background-repeat:repeat-x;
- background-color: #E2E8F2;
- font-size: 90%;
- color: #253555;
- padding-bottom: 4px;
- padding-top: 5px;
- text-align:left;
- -moz-border-radius-topleft: 4px;
- -moz-border-radius-topright: 4px;
- -webkit-border-top-left-radius: 4px;
- -webkit-border-top-right-radius: 4px;
- border-top-left-radius: 4px;
- border-top-right-radius: 4px;
- border-bottom: 1px solid #A8B8D9;
-}
-
-
-.tabsearch {
- top: 0px;
- left: 10px;
- height: 36px;
- background-image: url('tab_b.png');
- z-index: 101;
- overflow: hidden;
- font-size: 13px;
-}
-
-.navpath ul
-{
- font-size: 11px;
- background-image:url('tab_b.png');
- background-repeat:repeat-x;
- background-position: 0 -5px;
- height:30px;
- line-height:30px;
- color:#8AA0CC;
- border:solid 1px #C2CDE4;
- overflow:hidden;
- margin:0px;
- padding:0px;
-}
-
-.navpath li
-{
- list-style-type:none;
- float:left;
- padding-left:10px;
- padding-right:15px;
- background-image:url('bc_s.png');
- background-repeat:no-repeat;
- background-position:right;
- color:#364D7C;
-}
-
-.navpath li.navelem a
-{
- height:32px;
- display:block;
- text-decoration: none;
- outline: none;
- color: #283A5D;
- font-family: 'Lucida Grande',Geneva,Helvetica,Arial,sans-serif;
- text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9);
- text-decoration: none;
-}
-
-.navpath li.navelem a:hover
-{
- color:#6884BD;
-}
-
-.navpath li.footer
-{
- list-style-type:none;
- float:right;
- padding-left:10px;
- padding-right:15px;
- background-image:none;
- background-repeat:no-repeat;
- background-position:right;
- color:#364D7C;
- font-size: 8pt;
-}
-
-
-div.summary
-{
- float: right;
- font-size: 8pt;
- padding-right: 5px;
- width: 50%;
- text-align: right;
-}
-
-div.summary a
-{
- white-space: nowrap;
-}
-
-table.classindex
-{
- margin: 10px;
- white-space: nowrap;
- margin-left: 3%;
- margin-right: 3%;
- width: 94%;
- border: 0;
- border-spacing: 0;
- padding: 0;
-}
-
-div.ingroups
-{
- font-size: 8pt;
- width: 50%;
- text-align: left;
-}
-
-div.ingroups a
-{
- white-space: nowrap;
-}
-
-div.header
-{
- background-image:url('nav_h.png');
- background-repeat:repeat-x;
- background-color: #F9FAFC;
- margin: 0px;
- border-bottom: 1px solid #C4CFE5;
-}
-
-div.headertitle
-{
- padding: 5px 5px 5px 10px;
-}
-
-dl
-{
- padding: 0 0 0 10px;
-}
-
-/* dl.note, dl.warning, dl.attention, dl.pre, dl.post, dl.invariant, dl.deprecated, dl.todo, dl.test, dl.bug */
-dl.section
-{
- margin-left: 0px;
- padding-left: 0px;
-}
-
-dl.note
-{
- margin-left:-7px;
- padding-left: 3px;
- border-left:4px solid;
- border-color: #D0C000;
-}
-
-dl.warning, dl.attention
-{
- margin-left:-7px;
- padding-left: 3px;
- border-left:4px solid;
- border-color: #FF0000;
-}
-
-dl.pre, dl.post, dl.invariant
-{
- margin-left:-7px;
- padding-left: 3px;
- border-left:4px solid;
- border-color: #00D000;
-}
-
-dl.deprecated
-{
- margin-left:-7px;
- padding-left: 3px;
- border-left:4px solid;
- border-color: #505050;
-}
-
-dl.todo
-{
- margin-left:-7px;
- padding-left: 3px;
- border-left:4px solid;
- border-color: #00C0E0;
-}
-
-dl.test
-{
- margin-left:-7px;
- padding-left: 3px;
- border-left:4px solid;
- border-color: #3030E0;
-}
-
-dl.bug
-{
- margin-left:-7px;
- padding-left: 3px;
- border-left:4px solid;
- border-color: #C08050;
-}
-
-dl.section dd {
- margin-bottom: 6px;
-}
-
-
-#projectlogo
-{
- text-align: center;
- vertical-align: bottom;
- border-collapse: separate;
-}
-
-#projectlogo img
-{
- border: 0px none;
-}
-
-#projectalign
-{
- vertical-align: middle;
-}
-
-#projectname
-{
- font: 300% Tahoma, Arial,sans-serif;
- margin: 0px;
- padding: 2px 0px;
-}
-
-#projectbrief
-{
- font: 120% Tahoma, Arial,sans-serif;
- margin: 0px;
- padding: 0px;
-}
-
-#projectnumber
-{
- font: 50% Tahoma, Arial,sans-serif;
- margin: 0px;
- padding: 0px;
-}
-
-#titlearea
-{
- padding: 0px;
- margin: 0px;
- width: 100%;
- border-bottom: 1px solid #5373B4;
-}
-
-.image
-{
- text-align: center;
-}
-
-.dotgraph
-{
- text-align: center;
-}
-
-.mscgraph
-{
- text-align: center;
-}
-
-.diagraph
-{
- text-align: center;
-}
-
-.caption
-{
- font-weight: bold;
-}
-
-div.zoom
-{
- border: 1px solid #90A5CE;
-}
-
-dl.citelist {
- margin-bottom:50px;
-}
-
-dl.citelist dt {
- color:#334975;
- float:left;
- font-weight:bold;
- margin-right:10px;
- padding:5px;
-}
-
-dl.citelist dd {
- margin:2px 0;
- padding:5px 0;
-}
-
-div.toc {
- padding: 14px 25px;
- background-color: #F4F6FA;
- border: 1px solid #D8DFEE;
- border-radius: 7px 7px 7px 7px;
- float: right;
- height: auto;
- margin: 0 8px 10px 10px;
- width: 200px;
-}
-
-div.toc li {
- background: url("bdwn.png") no-repeat scroll 0 5px transparent;
- font: 10px/1.2 Verdana,DejaVu Sans,Geneva,sans-serif;
- margin-top: 5px;
- padding-left: 10px;
- padding-top: 2px;
-}
-
-div.toc h3 {
- font: bold 12px/1.2 Arial,FreeSans,sans-serif;
- color: #4665A2;
- border-bottom: 0 none;
- margin: 0;
-}
-
-div.toc ul {
- list-style: none outside none;
- border: medium none;
- padding: 0px;
-}
-
-div.toc li.level1 {
- margin-left: 0px;
-}
-
-div.toc li.level2 {
- margin-left: 15px;
-}
-
-div.toc li.level3 {
- margin-left: 30px;
-}
-
-div.toc li.level4 {
- margin-left: 45px;
-}
-
-.inherit_header {
- font-weight: bold;
- color: gray;
- cursor: pointer;
- -webkit-touch-callout: none;
- -webkit-user-select: none;
- -khtml-user-select: none;
- -moz-user-select: none;
- -ms-user-select: none;
- user-select: none;
-}
-
-.inherit_header td {
- padding: 6px 0px 2px 5px;
-}
-
-.inherit {
- display: none;
-}
-
-tr.heading h2 {
- margin-top: 12px;
- margin-bottom: 4px;
-}
-
-/* tooltip related style info */
-
-.ttc {
- position: absolute;
- display: none;
-}
-
-#powerTip {
- cursor: default;
- white-space: nowrap;
- background-color: white;
- border: 1px solid gray;
- border-radius: 4px 4px 4px 4px;
- box-shadow: 1px 1px 7px gray;
- display: none;
- font-size: smaller;
- max-width: 80%;
- opacity: 0.9;
- padding: 1ex 1em 1em;
- position: absolute;
- z-index: 2147483647;
-}
-
-#powerTip div.ttdoc {
- color: grey;
- font-style: italic;
-}
-
-#powerTip div.ttname a {
- font-weight: bold;
-}
-
-#powerTip div.ttname {
- font-weight: bold;
-}
-
-#powerTip div.ttdeci {
- color: #006318;
-}
-
-#powerTip div {
- margin: 0px;
- padding: 0px;
- font: 12px/16px Roboto,sans-serif;
-}
-
-#powerTip:before, #powerTip:after {
- content: "";
- position: absolute;
- margin: 0px;
-}
-
-#powerTip.n:after, #powerTip.n:before,
-#powerTip.s:after, #powerTip.s:before,
-#powerTip.w:after, #powerTip.w:before,
-#powerTip.e:after, #powerTip.e:before,
-#powerTip.ne:after, #powerTip.ne:before,
-#powerTip.se:after, #powerTip.se:before,
-#powerTip.nw:after, #powerTip.nw:before,
-#powerTip.sw:after, #powerTip.sw:before {
- border: solid transparent;
- content: " ";
- height: 0;
- width: 0;
- position: absolute;
-}
-
-#powerTip.n:after, #powerTip.s:after,
-#powerTip.w:after, #powerTip.e:after,
-#powerTip.nw:after, #powerTip.ne:after,
-#powerTip.sw:after, #powerTip.se:after {
- border-color: rgba(255, 255, 255, 0);
-}
-
-#powerTip.n:before, #powerTip.s:before,
-#powerTip.w:before, #powerTip.e:before,
-#powerTip.nw:before, #powerTip.ne:before,
-#powerTip.sw:before, #powerTip.se:before {
- border-color: rgba(128, 128, 128, 0);
-}
-
-#powerTip.n:after, #powerTip.n:before,
-#powerTip.ne:after, #powerTip.ne:before,
-#powerTip.nw:after, #powerTip.nw:before {
- top: 100%;
-}
-
-#powerTip.n:after, #powerTip.ne:after, #powerTip.nw:after {
- border-top-color: #ffffff;
- border-width: 10px;
- margin: 0px -10px;
-}
-#powerTip.n:before {
- border-top-color: #808080;
- border-width: 11px;
- margin: 0px -11px;
-}
-#powerTip.n:after, #powerTip.n:before {
- left: 50%;
-}
-
-#powerTip.nw:after, #powerTip.nw:before {
- right: 14px;
-}
-
-#powerTip.ne:after, #powerTip.ne:before {
- left: 14px;
-}
-
-#powerTip.s:after, #powerTip.s:before,
-#powerTip.se:after, #powerTip.se:before,
-#powerTip.sw:after, #powerTip.sw:before {
- bottom: 100%;
-}
-
-#powerTip.s:after, #powerTip.se:after, #powerTip.sw:after {
- border-bottom-color: #ffffff;
- border-width: 10px;
- margin: 0px -10px;
-}
-
-#powerTip.s:before, #powerTip.se:before, #powerTip.sw:before {
- border-bottom-color: #808080;
- border-width: 11px;
- margin: 0px -11px;
-}
-
-#powerTip.s:after, #powerTip.s:before {
- left: 50%;
-}
-
-#powerTip.sw:after, #powerTip.sw:before {
- right: 14px;
-}
-
-#powerTip.se:after, #powerTip.se:before {
- left: 14px;
-}
-
-#powerTip.e:after, #powerTip.e:before {
- left: 100%;
-}
-#powerTip.e:after {
- border-left-color: #ffffff;
- border-width: 10px;
- top: 50%;
- margin-top: -10px;
-}
-#powerTip.e:before {
- border-left-color: #808080;
- border-width: 11px;
- top: 50%;
- margin-top: -11px;
-}
-
-#powerTip.w:after, #powerTip.w:before {
- right: 100%;
-}
-#powerTip.w:after {
- border-right-color: #ffffff;
- border-width: 10px;
- top: 50%;
- margin-top: -10px;
-}
-#powerTip.w:before {
- border-right-color: #808080;
- border-width: 11px;
- top: 50%;
- margin-top: -11px;
-}
-
-@media print
-{
- #top { display: none; }
- #side-nav { display: none; }
- #nav-path { display: none; }
- body { overflow:visible; }
- h1, h2, h3, h4, h5, h6 { page-break-after: avoid; }
- .summary { display: none; }
- .memitem { page-break-inside: avoid; }
- #doc-content
- {
- margin-left:0 !important;
- height:auto !important;
- width:auto !important;
- overflow:inherit;
- display:inline;
- }
-}
-
diff --git a/docs/html/doxygen.png b/docs/html/doxygen.png
deleted file mode 100644
index 3ff17d8..0000000
--- a/docs/html/doxygen.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/dynsections.js b/docs/html/dynsections.js
deleted file mode 100644
index 85e1836..0000000
--- a/docs/html/dynsections.js
+++ /dev/null
@@ -1,97 +0,0 @@
-function toggleVisibility(linkObj)
-{
- var base = $(linkObj).attr('id');
- var summary = $('#'+base+'-summary');
- var content = $('#'+base+'-content');
- var trigger = $('#'+base+'-trigger');
- var src=$(trigger).attr('src');
- if (content.is(':visible')===true) {
- content.hide();
- summary.show();
- $(linkObj).addClass('closed').removeClass('opened');
- $(trigger).attr('src',src.substring(0,src.length-8)+'closed.png');
- } else {
- content.show();
- summary.hide();
- $(linkObj).removeClass('closed').addClass('opened');
- $(trigger).attr('src',src.substring(0,src.length-10)+'open.png');
- }
- return false;
-}
-
-function updateStripes()
-{
- $('table.directory tr').
- removeClass('even').filter(':visible:even').addClass('even');
-}
-
-function toggleLevel(level)
-{
- $('table.directory tr').each(function() {
- var l = this.id.split('_').length-1;
- var i = $('#img'+this.id.substring(3));
- var a = $('#arr'+this.id.substring(3));
- if (l<level+1) {
- i.removeClass('iconfopen iconfclosed').addClass('iconfopen');
- a.html('▼');
- $(this).show();
- } else if (l==level+1) {
- i.removeClass('iconfclosed iconfopen').addClass('iconfclosed');
- a.html('►');
- $(this).show();
- } else {
- $(this).hide();
- }
- });
- updateStripes();
-}
-
-function toggleFolder(id)
-{
- // the clicked row
- var currentRow = $('#row_'+id);
-
- // all rows after the clicked row
- var rows = currentRow.nextAll("tr");
-
- var re = new RegExp('^row_'+id+'\\d+_$', "i"); //only one sub
-
- // only match elements AFTER this one (can't hide elements before)
- var childRows = rows.filter(function() { return this.id.match(re); });
-
- // first row is visible we are HIDING
- if (childRows.filter(':first').is(':visible')===true) {
- // replace down arrow by right arrow for current row
- var currentRowSpans = currentRow.find("span");
- currentRowSpans.filter(".iconfopen").removeClass("iconfopen").addClass("iconfclosed");
- currentRowSpans.filter(".arrow").html('►');
- rows.filter("[id^=row_"+id+"]").hide(); // hide all children
- } else { // we are SHOWING
- // replace right arrow by down arrow for current row
- var currentRowSpans = currentRow.find("span");
- currentRowSpans.filter(".iconfclosed").removeClass("iconfclosed").addClass("iconfopen");
- currentRowSpans.filter(".arrow").html('▼');
- // replace down arrows by right arrows for child rows
- var childRowsSpans = childRows.find("span");
- childRowsSpans.filter(".iconfopen").removeClass("iconfopen").addClass("iconfclosed");
- childRowsSpans.filter(".arrow").html('►');
- childRows.show(); //show all children
- }
- updateStripes();
-}
-
-
-function toggleInherit(id)
-{
- var rows = $('tr.inherit.'+id);
- var img = $('tr.inherit_header.'+id+' img');
- var src = $(img).attr('src');
- if (rows.filter(':first').is(':visible')===true) {
- rows.css('display','none');
- $(img).attr('src',src.substring(0,src.length-8)+'closed.png');
- } else {
- rows.css('display','table-row'); // using show() causes jump in firefox
- $(img).attr('src',src.substring(0,src.length-10)+'open.png');
- }
-}
-
diff --git a/docs/html/files.html b/docs/html/files.html
deleted file mode 100644
index 56787ed..0000000
--- a/docs/html/files.html
+++ /dev/null
@@ -1,106 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: File List</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li class="current"><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
- <div id="navrow2" class="tabs2">
- <ul class="tablist">
- <li class="current"><a href="files.html"><span>File List</span></a></li>
- <li><a href="globals.html"><span>File Members</span></a></li>
- </ul>
- </div>
-</div><!-- top -->
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div class="header">
- <div class="headertitle">
-<div class="title">File List</div> </div>
-</div><!--header-->
-<div class="contents">
-<div class="textblock">Here is a list of all documented files with brief descriptions:</div><div class="directory">
-<div class="levels">[detail level <span onclick="javascript:toggleLevel(1);">1</span><span onclick="javascript:toggleLevel(2);">2</span>]</div><table class="directory">
-<tr id="row_0_" class="even"><td class="entry"><span style="width:0px;display:inline-block;"> </span><span id="arr_0_" class="arrow" onclick="toggleFolder('0_')">▼</span><span id="img_0_" class="iconfopen" onclick="toggleFolder('0_')"> </span><a class="el" href="dir_7dae9cfde651cd3cb034485ce5e391b9.html" target="_self">psa</a></td><td class="desc"></td></tr>
-<tr id="row_0_0_"><td class="entry"><span style="width:32px;display:inline-block;"> </span><a href="crypto_8h_source.html"><span class="icondoc"></span></a><a class="el" href="crypto_8h.html" target="_self">crypto.h</a></td><td class="desc">Platform Security Architecture cryptography module </td></tr>
-<tr id="row_0_1_" class="even"><td class="entry"><span style="width:32px;display:inline-block;"> </span><a href="crypto__sizes_8h_source.html"><span class="icondoc"></span></a><a class="el" href="crypto__sizes_8h.html" target="_self">crypto_sizes.h</a></td><td class="desc">PSA cryptography module: Mbed TLS buffer size macros </td></tr>
-<tr id="row_0_2_"><td class="entry"><span style="width:32px;display:inline-block;"> </span><a href="crypto__types_8h_source.html"><span class="icondoc"></span></a><a class="el" href="crypto__types_8h.html" target="_self">crypto_types.h</a></td><td class="desc">PSA cryptography module: type aliases </td></tr>
-<tr id="row_0_3_" class="even"><td class="entry"><span style="width:32px;display:inline-block;"> </span><a href="crypto__values_8h_source.html"><span class="icondoc"></span></a><a class="el" href="crypto__values_8h.html" target="_self">crypto_values.h</a></td><td class="desc">PSA cryptography module: macros to build and analyze integer values </td></tr>
-</table>
-</div><!-- directory -->
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/folderclosed.png b/docs/html/folderclosed.png
deleted file mode 100644
index bb8ab35..0000000
--- a/docs/html/folderclosed.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/folderopen.png b/docs/html/folderopen.png
deleted file mode 100644
index d6c7f67..0000000
--- a/docs/html/folderopen.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/from_doxygen.html b/docs/html/from_doxygen.html
new file mode 100644
index 0000000..15487a0
--- /dev/null
+++ b/docs/html/from_doxygen.html
@@ -0,0 +1,7097 @@
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+ <title>Implementation-specific definitions — psa_crypto_api 1.0 beta3 documentation</title>
+ <link rel="stylesheet" href="_static/alabaster.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+ <script type="text/javascript" id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
+ <script type="text/javascript" src="_static/jquery.js"></script>
+ <script type="text/javascript" src="_static/underscore.js"></script>
+ <script type="text/javascript" src="_static/doctools.js"></script>
+ <script type="text/javascript" src="_static/language_data.js"></script>
+ <link rel="index" title="Index" href="genindex.html" />
+ <link rel="search" title="Search" href="search.html" />
+ <link rel="prev" title="Introduction" href="general.html" />
+
+ <link rel="stylesheet" href="_static/custom.css" type="text/css" />
+
+
+ <meta name="viewport" content="width=device-width, initial-scale=0.9, maximum-scale=0.9" />
+
+ </head><body>
+
+
+ <div class="document">
+ <div class="documentwrapper">
+ <div class="bodywrapper">
+
+
+ <div class="body" role="main">
+
+ <div class="section" id="implementation-specific-definitions">
+<h1>Implementation-specific definitions</h1>
+<div class="section" id="psa_key_handle_t">
+<span id="c.psa_key_handle_t"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_key_handle_t</span></code> (type)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="k">typedef</span> <span class="n">_unsigned_integral_type_</span> <span class="n">psa_key_handle_t</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>Key handle.</p>
+<p>This type represents open handles to keys. It must be an unsigned integral type. The choice of type is implementation-dependent.</p>
+<p>0 is not a valid key handle. How other handle values are assigned is implementation-dependent.</p>
+</div>
+</div>
+<div class="section" id="library-initialization">
+<h1>Library initialization</h1>
+<div class="section" id="psa_crypto_init">
+<span id="c.psa_crypto_init"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_crypto_init</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_crypto_init</span><span class="p">(</span><span class="kt">void</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_ENTROPY" title="PSA_ERROR_INSUFFICIENT_ENTROPY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_ENTROPY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Library initialization.</p>
+<p>Applications must call this function before calling any other function in this module.</p>
+<p>Applications may call this function more than once. Once a call succeeds, subsequent calls are guaranteed to succeed.</p>
+<p>If the application calls other functions before calling <a class="reference internal" href="#c.psa_crypto_init" title="psa_crypto_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_crypto_init()</span></code></a>, the behavior is undefined. Implementations are encouraged to either perform the operation as if the library had been initialized or to return <a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a> or some other applicable error. In particular, implementations should not return a success status if the lack of initialization may have security implications, for example due to improper seeding of the random number generator.</p>
+</div>
+</div>
+<div class="section" id="key-attributes">
+<h1>Key attributes</h1>
+<div class="section" id="psa_key_attributes_t">
+<span id="c.psa_key_attributes_t"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_key_attributes_t</span></code> (type)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="k">typedef</span> <span class="k">struct</span> <span class="n">psa_key_attributes_s</span> <span class="n">psa_key_attributes_t</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>The type of a structure containing key attributes.</p>
+<p>This is an opaque structure that can represent the metadata of a key object. Metadata that can be stored in attributes includes:</p>
+<ul class="simple">
+<li>The location of the key in storage, indicated by its key identifier and its lifetime.</li>
+<li>The key’s policy, comprising usage flags and a specification of the permitted algorithm(s).</li>
+<li>Information about the key itself: the key type and its size.</li>
+<li>Implementations may define additional attributes.</li>
+</ul>
+<p>The actual key material is not considered an attribute of a key. Key attributes do not contain information that is generally considered highly confidential.</p>
+<p>An attribute structure can be a simple data structure where each function <code class="docutils literal notranslate"><span class="pre">psa_set_key_xxx</span></code> sets a field and the corresponding function <code class="docutils literal notranslate"><span class="pre">psa_get_key_xxx</span></code> retrieves the value of the corresponding field. However, implementations may report values that are equivalent to the original one, but have a different encoding. For example, an implementation may use a more compact representation for types where many bit-patterns are invalid or not supported, and store all values that it does not support as a special marker value. In such an implementation, after setting an invalid value, the corresponding get function returns an invalid value which may not be the one that was originally stored.</p>
+<p>An attribute structure may contain references to auxiliary resources, for example pointers to allocated memory or indirect references to pre-calculated values. In order to free such resources, the application must call <a class="reference internal" href="#c.psa_reset_key_attributes" title="psa_reset_key_attributes"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_reset_key_attributes()</span></code></a>. As an exception, calling <a class="reference internal" href="#c.psa_reset_key_attributes" title="psa_reset_key_attributes"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_reset_key_attributes()</span></code></a> on an attribute structure is optional if the structure has only been modified by the following functions since it was initialized or last reset with <a class="reference internal" href="#c.psa_reset_key_attributes" title="psa_reset_key_attributes"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_reset_key_attributes()</span></code></a>:</p>
+<ul class="simple">
+<li><a class="reference internal" href="#c.psa_set_key_id" title="psa_set_key_id"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_set_key_id()</span></code></a></li>
+<li><a class="reference internal" href="#c.psa_set_key_lifetime" title="psa_set_key_lifetime"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_set_key_lifetime()</span></code></a></li>
+<li><a class="reference internal" href="#c.psa_set_key_type" title="psa_set_key_type"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_set_key_type()</span></code></a></li>
+<li><a class="reference internal" href="#c.psa_set_key_bits" title="psa_set_key_bits"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_set_key_bits()</span></code></a></li>
+<li><a class="reference internal" href="#c.psa_set_key_usage_flags" title="psa_set_key_usage_flags"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_set_key_usage_flags()</span></code></a></li>
+<li><a class="reference internal" href="#c.psa_set_key_algorithm" title="psa_set_key_algorithm"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_set_key_algorithm()</span></code></a></li>
+</ul>
+<p>Before calling any function on a key attribute structure, the application must initialize it by any of the following means:</p>
+<ul>
+<li><p class="first">Set the structure to all-bits-zero, for example:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_key_attributes_t</span> <span class="n">attributes</span><span class="p">;</span>
+<span class="n">memset</span><span class="p">(</span><span class="o">&</span><span class="n">attributes</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="k">sizeof</span><span class="p">(</span><span class="n">attributes</span><span class="p">));</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first">Initialize the structure to logical zero values, for example:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_key_attributes_t</span> <span class="n">attributes</span> <span class="o">=</span> <span class="p">{</span><span class="mi">0</span><span class="p">};</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first">Initialize the structure to the initializer <a class="reference internal" href="#c.PSA_KEY_ATTRIBUTES_INIT" title="PSA_KEY_ATTRIBUTES_INIT"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_ATTRIBUTES_INIT</span></code></a>, for example:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_key_attributes_t</span> <span class="n">attributes</span> <span class="o">=</span> <span class="n">PSA_KEY_ATTRIBUTES_INIT</span><span class="p">;</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first">Assign the result of the function <a class="reference internal" href="#c.psa_key_attributes_init" title="psa_key_attributes_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_attributes_init()</span></code></a> to the structure, for example:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_key_attributes_t</span> <span class="n">attributes</span><span class="p">;</span>
+<span class="n">attributes</span> <span class="o">=</span> <span class="n">psa_key_attributes_init</span><span class="p">();</span>
+</pre></div>
+</div>
+</li>
+</ul>
+<p>A freshly initialized attribute structure contains the following values:</p>
+<ul class="simple">
+<li>lifetime: <a class="reference internal" href="#c.PSA_KEY_LIFETIME_VOLATILE" title="PSA_KEY_LIFETIME_VOLATILE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_LIFETIME_VOLATILE</span></code></a>.</li>
+<li>key identifier: unspecified.</li>
+<li>type: <code class="docutils literal notranslate"><span class="pre">0</span></code>.</li>
+<li>key size: <code class="docutils literal notranslate"><span class="pre">0</span></code>.</li>
+<li>usage flags: <code class="docutils literal notranslate"><span class="pre">0</span></code>.</li>
+<li>algorithm: <code class="docutils literal notranslate"><span class="pre">0</span></code>.</li>
+</ul>
+<p>A typical sequence to create a key is as follows:</p>
+<ol class="arabic simple">
+<li>Create and initialize an attribute structure.</li>
+<li>If the key is persistent, call <a class="reference internal" href="#c.psa_set_key_id" title="psa_set_key_id"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_set_key_id()</span></code></a>. Also call <a class="reference internal" href="#c.psa_set_key_lifetime" title="psa_set_key_lifetime"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_set_key_lifetime()</span></code></a> to place the key in a non-default location.</li>
+<li>Set the key policy with <a class="reference internal" href="#c.psa_set_key_usage_flags" title="psa_set_key_usage_flags"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_set_key_usage_flags()</span></code></a> and <a class="reference internal" href="#c.psa_set_key_algorithm" title="psa_set_key_algorithm"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_set_key_algorithm()</span></code></a>.</li>
+<li>Set the key type with <a class="reference internal" href="#c.psa_set_key_type" title="psa_set_key_type"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_set_key_type()</span></code></a>. Skip this step if copying an existing key with <a class="reference internal" href="#c.psa_copy_key" title="psa_copy_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_copy_key()</span></code></a>.</li>
+<li>When generating a random key with <a class="reference internal" href="#c.psa_generate_key" title="psa_generate_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_generate_key()</span></code></a> or deriving a key with <a class="reference internal" href="#c.psa_key_derivation_output_key" title="psa_key_derivation_output_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_derivation_output_key()</span></code></a>, set the desired key size with <a class="reference internal" href="#c.psa_set_key_bits" title="psa_set_key_bits"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_set_key_bits()</span></code></a>.</li>
+<li>Call a key creation function: <a class="reference internal" href="#c.psa_import_key" title="psa_import_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_import_key()</span></code></a>, <a class="reference internal" href="#c.psa_generate_key" title="psa_generate_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_generate_key()</span></code></a>, <a class="reference internal" href="#c.psa_key_derivation_output_key" title="psa_key_derivation_output_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_derivation_output_key()</span></code></a> or <a class="reference internal" href="#c.psa_copy_key" title="psa_copy_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_copy_key()</span></code></a>. This function reads the attribute structure, creates a key with these attributes, and outputs a handle to the newly created key.</li>
+<li>The attribute structure is now no longer necessary. You may call <a class="reference internal" href="#c.psa_reset_key_attributes" title="psa_reset_key_attributes"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_reset_key_attributes()</span></code></a>, although this is optional with the workflow presented here because the attributes currently defined in this specification do not require any additional resources beyond the structure itself.</li>
+</ol>
+<p>A typical sequence to query a key’s attributes is as follows:</p>
+<ol class="arabic simple">
+<li>Call <a class="reference internal" href="#c.psa_get_key_attributes" title="psa_get_key_attributes"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_get_key_attributes()</span></code></a>.</li>
+<li>Call <code class="docutils literal notranslate"><span class="pre">psa_get_key_xxx</span></code> functions to retrieve the attribute(s) that you are interested in.</li>
+<li>Call <a class="reference internal" href="#c.psa_reset_key_attributes" title="psa_reset_key_attributes"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_reset_key_attributes()</span></code></a> to free any resources that may be used by the attribute structure.</li>
+</ol>
+<p>Once a key has been created, it is impossible to change its attributes.</p>
+</div>
+<div class="section" id="PSA_KEY_ATTRIBUTES_INIT">
+<span id="c.PSA_KEY_ATTRIBUTES_INIT"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_ATTRIBUTES_INIT</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_ATTRIBUTES_INIT {0}</span>
+</pre></div>
+</div>
+<p>This macro returns a suitable initializer for a key attribute structure of type <a class="reference internal" href="#c.psa_key_attributes_t" title="psa_key_attributes_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_key_attributes_t</span></code></a>.</p>
+</div>
+<div class="section" id="psa_key_attributes_init">
+<span id="c.psa_key_attributes_init"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_key_attributes_init</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_key_attributes_t</span> <span class="nf">psa_key_attributes_init</span><span class="p">(</span><span class="kt">void</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_key_attributes_t" title="psa_key_attributes_t"><code class="docutils literal notranslate"><span class="pre">psa_key_attributes_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Return an initial value for a key attributes structure.</p>
+</div>
+<div class="section" id="psa_set_key_id">
+<span id="c.psa_set_key_id"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_set_key_id</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="kt">void</span> <span class="nf">psa_set_key_id</span><span class="p">(</span><span class="n">psa_key_attributes_t</span> <span class="o">*</span> <span class="n">attributes</span><span class="p">,</span>
+ <span class="n">psa_key_id_t</span> <span class="n">id</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">attributes</span></code></dt>
+<dd>The attribute structure to write to.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">id</span></code></dt>
+<dd>The persistent identifier for the key.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><code class="docutils literal notranslate"><span class="pre">void</span></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Declare a key as persistent and set its key identifier.</p>
+<p>If the attribute structure currently declares the key as volatile (which is the default content of an attribute structure), this function sets the lifetime attribute to <a class="reference internal" href="#c.PSA_KEY_LIFETIME_PERSISTENT" title="PSA_KEY_LIFETIME_PERSISTENT"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_LIFETIME_PERSISTENT</span></code></a>.</p>
+<p>This function does not access storage, it merely stores the given value in the structure. The persistent key will be written to storage when the attribute structure is passed to a key creation function such as <a class="reference internal" href="#c.psa_import_key" title="psa_import_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_import_key()</span></code></a>, <a class="reference internal" href="#c.psa_generate_key" title="psa_generate_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_generate_key()</span></code></a>, <a class="reference internal" href="#c.psa_key_derivation_output_key" title="psa_key_derivation_output_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_derivation_output_key()</span></code></a> or <a class="reference internal" href="#c.psa_copy_key" title="psa_copy_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_copy_key()</span></code></a>.</p>
+<p>This function may be declared as <code class="docutils literal notranslate"><span class="pre">static</span></code> (i.e. without external linkage). This function may be provided as a function-like macro, but in this case it must evaluate each of its arguments exactly once.</p>
+</div>
+<div class="section" id="psa_set_key_lifetime">
+<span id="c.psa_set_key_lifetime"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_set_key_lifetime</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="kt">void</span> <span class="nf">psa_set_key_lifetime</span><span class="p">(</span><span class="n">psa_key_attributes_t</span> <span class="o">*</span> <span class="n">attributes</span><span class="p">,</span>
+ <span class="n">psa_key_lifetime_t</span> <span class="n">lifetime</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">attributes</span></code></dt>
+<dd>The attribute structure to write to.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">lifetime</span></code></dt>
+<dd>The lifetime for the key. If this is <a class="reference internal" href="#c.PSA_KEY_LIFETIME_VOLATILE" title="PSA_KEY_LIFETIME_VOLATILE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_LIFETIME_VOLATILE</span></code></a>, the key will be volatile, and the key identifier attribute is reset to 0.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><code class="docutils literal notranslate"><span class="pre">void</span></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Set the location of a persistent key.</p>
+<p>To make a key persistent, you must give it a persistent key identifier with <a class="reference internal" href="#c.psa_set_key_id" title="psa_set_key_id"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_set_key_id()</span></code></a>. By default, a key that has a persistent identifier is stored in the default storage area identifier by <a class="reference internal" href="#c.PSA_KEY_LIFETIME_PERSISTENT" title="PSA_KEY_LIFETIME_PERSISTENT"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_LIFETIME_PERSISTENT</span></code></a>. Call this function to choose a storage area, or to explicitly declare the key as volatile.</p>
+<p>This function does not access storage, it merely stores the given value in the structure. The persistent key will be written to storage when the attribute structure is passed to a key creation function such as <a class="reference internal" href="#c.psa_import_key" title="psa_import_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_import_key()</span></code></a>, <a class="reference internal" href="#c.psa_generate_key" title="psa_generate_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_generate_key()</span></code></a>, <a class="reference internal" href="#c.psa_key_derivation_output_key" title="psa_key_derivation_output_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_derivation_output_key()</span></code></a> or <a class="reference internal" href="#c.psa_copy_key" title="psa_copy_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_copy_key()</span></code></a>.</p>
+<p>This function may be declared as <code class="docutils literal notranslate"><span class="pre">static</span></code> (i.e. without external linkage). This function may be provided as a function-like macro, but in this case it must evaluate each of its arguments exactly once.</p>
+</div>
+<div class="section" id="psa_get_key_id">
+<span id="c.psa_get_key_id"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_get_key_id</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_key_id_t</span> <span class="nf">psa_get_key_id</span><span class="p">(</span><span class="k">const</span> <span class="n">psa_key_attributes_t</span> <span class="o">*</span> <span class="n">attributes</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">attributes</span></code></dt>
+<dd>The key attribute structure to query.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_key_id_t" title="psa_key_id_t"><code class="docutils literal notranslate"><span class="pre">psa_key_id_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<p>The persistent identifier stored in the attribute structure. This value is unspecified if the attribute structure declares the key as volatile.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Retrieve the key identifier from key attributes.</p>
+<p>This function may be declared as <code class="docutils literal notranslate"><span class="pre">static</span></code> (i.e. without external linkage). This function may be provided as a function-like macro, but in this case it must evaluate its argument exactly once.</p>
+</div>
+<div class="section" id="psa_get_key_lifetime">
+<span id="c.psa_get_key_lifetime"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_get_key_lifetime</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_key_lifetime_t</span> <span class="nf">psa_get_key_lifetime</span><span class="p">(</span><span class="k">const</span> <span class="n">psa_key_attributes_t</span> <span class="o">*</span> <span class="n">attributes</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">attributes</span></code></dt>
+<dd>The key attribute structure to query.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_key_lifetime_t" title="psa_key_lifetime_t"><code class="docutils literal notranslate"><span class="pre">psa_key_lifetime_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<p>The lifetime value stored in the attribute structure.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Retrieve the lifetime from key attributes.</p>
+<p>This function may be declared as <code class="docutils literal notranslate"><span class="pre">static</span></code> (i.e. without external linkage). This function may be provided as a function-like macro, but in this case it must evaluate its argument exactly once.</p>
+</div>
+<div class="section" id="psa_set_key_usage_flags">
+<span id="c.psa_set_key_usage_flags"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_set_key_usage_flags</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="kt">void</span> <span class="nf">psa_set_key_usage_flags</span><span class="p">(</span><span class="n">psa_key_attributes_t</span> <span class="o">*</span> <span class="n">attributes</span><span class="p">,</span>
+ <span class="n">psa_key_usage_t</span> <span class="n">usage_flags</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">attributes</span></code></dt>
+<dd>The attribute structure to write to.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">usage_flags</span></code></dt>
+<dd>The usage flags to write.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><code class="docutils literal notranslate"><span class="pre">void</span></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Declare usage flags for a key.</p>
+<p>Usage flags are part of a key’s usage policy. They encode what kind of operations are permitted on the key. For more details, refer to the documentation of the type <a class="reference internal" href="#c.psa_key_usage_t" title="psa_key_usage_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_key_usage_t</span></code></a>.</p>
+<p>This function overwrites any usage flags previously set in <code class="docutils literal notranslate"><span class="pre">attributes</span></code>.</p>
+<p>This function may be declared as <code class="docutils literal notranslate"><span class="pre">static</span></code> (i.e. without external linkage). This function may be provided as a function-like macro, but in this case it must evaluate each of its arguments exactly once.</p>
+</div>
+<div class="section" id="psa_get_key_usage_flags">
+<span id="c.psa_get_key_usage_flags"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_get_key_usage_flags</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_key_usage_t</span> <span class="nf">psa_get_key_usage_flags</span><span class="p">(</span><span class="k">const</span> <span class="n">psa_key_attributes_t</span> <span class="o">*</span> <span class="n">attributes</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">attributes</span></code></dt>
+<dd>The key attribute structure to query.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_key_usage_t" title="psa_key_usage_t"><code class="docutils literal notranslate"><span class="pre">psa_key_usage_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<p>The usage flags stored in the attribute structure.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Retrieve the usage flags from key attributes.</p>
+<p>This function may be declared as <code class="docutils literal notranslate"><span class="pre">static</span></code> (i.e. without external linkage). This function may be provided as a function-like macro, but in this case it must evaluate its argument exactly once.</p>
+</div>
+<div class="section" id="psa_set_key_algorithm">
+<span id="c.psa_set_key_algorithm"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_set_key_algorithm</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="kt">void</span> <span class="nf">psa_set_key_algorithm</span><span class="p">(</span><span class="n">psa_key_attributes_t</span> <span class="o">*</span> <span class="n">attributes</span><span class="p">,</span>
+ <span class="n">psa_algorithm_t</span> <span class="n">alg</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">attributes</span></code></dt>
+<dd>The attribute structure to write to.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>The permitted algorithm policy to write.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><code class="docutils literal notranslate"><span class="pre">void</span></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Declare the permitted algorithm policy for a key.</p>
+<p>The permitted algorithm policy of a key encodes which algorithm or algorithms are permitted to be used with this key.</p>
+<p>This function overwrites any algorithm policy previously set in <code class="docutils literal notranslate"><span class="pre">attributes</span></code>.</p>
+<p>This function may be declared as <code class="docutils literal notranslate"><span class="pre">static</span></code> (i.e. without external linkage). This function may be provided as a function-like macro, but in this case it must evaluate each of its arguments exactly once.</p>
+</div>
+<div class="section" id="psa_get_key_algorithm">
+<span id="c.psa_get_key_algorithm"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_get_key_algorithm</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_algorithm_t</span> <span class="nf">psa_get_key_algorithm</span><span class="p">(</span><span class="k">const</span> <span class="n">psa_key_attributes_t</span> <span class="o">*</span> <span class="n">attributes</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">attributes</span></code></dt>
+<dd>The key attribute structure to query.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_algorithm_t" title="psa_algorithm_t"><code class="docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<p>The algorithm stored in the attribute structure.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Retrieve the algorithm policy from key attributes.</p>
+<p>This function may be declared as <code class="docutils literal notranslate"><span class="pre">static</span></code> (i.e. without external linkage). This function may be provided as a function-like macro, but in this case it must evaluate its argument exactly once.</p>
+</div>
+<div class="section" id="psa_set_key_type">
+<span id="c.psa_set_key_type"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_set_key_type</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="kt">void</span> <span class="nf">psa_set_key_type</span><span class="p">(</span><span class="n">psa_key_attributes_t</span> <span class="o">*</span> <span class="n">attributes</span><span class="p">,</span>
+ <span class="n">psa_key_type_t</span> <span class="n">type</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">attributes</span></code></dt>
+<dd>The attribute structure to write to.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">type</span></code></dt>
+<dd>The key type to write.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><code class="docutils literal notranslate"><span class="pre">void</span></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Declare the type of a key.</p>
+<p>This function overwrites any key type previously set in <code class="docutils literal notranslate"><span class="pre">attributes</span></code>.</p>
+<p>This function may be declared as <code class="docutils literal notranslate"><span class="pre">static</span></code> (i.e. without external linkage). This function may be provided as a function-like macro, but in this case it must evaluate each of its arguments exactly once.</p>
+</div>
+<div class="section" id="psa_set_key_bits">
+<span id="c.psa_set_key_bits"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_set_key_bits</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="kt">void</span> <span class="nf">psa_set_key_bits</span><span class="p">(</span><span class="n">psa_key_attributes_t</span> <span class="o">*</span> <span class="n">attributes</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">bits</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">attributes</span></code></dt>
+<dd>The attribute structure to write to.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">bits</span></code></dt>
+<dd>The key size in bits.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><code class="docutils literal notranslate"><span class="pre">void</span></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Declare the size of a key.</p>
+<p>This function overwrites any key size previously set in <code class="docutils literal notranslate"><span class="pre">attributes</span></code>.</p>
+<p>This function may be declared as <code class="docutils literal notranslate"><span class="pre">static</span></code> (i.e. without external linkage). This function may be provided as a function-like macro, but in this case it must evaluate each of its arguments exactly once.</p>
+</div>
+<div class="section" id="psa_get_key_type">
+<span id="c.psa_get_key_type"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_get_key_type</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_key_type_t</span> <span class="nf">psa_get_key_type</span><span class="p">(</span><span class="k">const</span> <span class="n">psa_key_attributes_t</span> <span class="o">*</span> <span class="n">attributes</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">attributes</span></code></dt>
+<dd>The key attribute structure to query.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_key_type_t" title="psa_key_type_t"><code class="docutils literal notranslate"><span class="pre">psa_key_type_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<p>The key type stored in the attribute structure.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Retrieve the key type from key attributes.</p>
+<p>This function may be declared as <code class="docutils literal notranslate"><span class="pre">static</span></code> (i.e. without external linkage). This function may be provided as a function-like macro, but in this case it must evaluate its argument exactly once.</p>
+</div>
+<div class="section" id="psa_get_key_bits">
+<span id="c.psa_get_key_bits"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_get_key_bits</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="kt">size_t</span> <span class="nf">psa_get_key_bits</span><span class="p">(</span><span class="k">const</span> <span class="n">psa_key_attributes_t</span> <span class="o">*</span> <span class="n">attributes</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">attributes</span></code></dt>
+<dd>The key attribute structure to query.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><code class="docutils literal notranslate"><span class="pre">size_t</span></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<p>The key size stored in the attribute structure, in bits.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Retrieve the key size from key attributes.</p>
+<p>This function may be declared as <code class="docutils literal notranslate"><span class="pre">static</span></code> (i.e. without external linkage). This function may be provided as a function-like macro, but in this case it must evaluate its argument exactly once.</p>
+</div>
+<div class="section" id="psa_get_key_attributes">
+<span id="c.psa_get_key_attributes"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_get_key_attributes</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_get_key_attributes</span><span class="p">(</span><span class="n">psa_key_handle_t</span> <span class="n">handle</span><span class="p">,</span>
+ <span class="n">psa_key_attributes_t</span> <span class="o">*</span> <span class="n">attributes</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">handle</span></code></dt>
+<dd>Handle to the key to query.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">attributes</span></code></dt>
+<dd>On success, the attributes of the key. On failure, equivalent to a freshly-initialized structure.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_HANDLE" title="PSA_ERROR_INVALID_HANDLE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_HANDLE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Retrieve the attributes of a key.</p>
+<p>This function first resets the attribute structure as with <a class="reference internal" href="#c.psa_reset_key_attributes" title="psa_reset_key_attributes"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_reset_key_attributes()</span></code></a>. It then copies the attributes of the given key into the given attribute structure.</p>
+<div class="admonition note">
+<p class="first admonition-title">Note</p>
+<p class="last">This function may allocate memory or other resources. Once you have called this function on an attribute structure, you must call <a class="reference internal" href="#c.psa_reset_key_attributes" title="psa_reset_key_attributes"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_reset_key_attributes()</span></code></a> to free these resources.</p>
+</div>
+</div>
+<div class="section" id="psa_reset_key_attributes">
+<span id="c.psa_reset_key_attributes"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_reset_key_attributes</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="kt">void</span> <span class="nf">psa_reset_key_attributes</span><span class="p">(</span><span class="n">psa_key_attributes_t</span> <span class="o">*</span> <span class="n">attributes</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">attributes</span></code></dt>
+<dd>The attribute structure to reset.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><code class="docutils literal notranslate"><span class="pre">void</span></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Reset a key attribute structure to a freshly initialized state.</p>
+<p>You must initialize the attribute structure as described in the documentation of the type <a class="reference internal" href="#c.psa_key_attributes_t" title="psa_key_attributes_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_key_attributes_t</span></code></a> before calling this function. Once the structure has been initialized, you may call this function at any time.</p>
+<p>This function frees any auxiliary resources that the structure may contain.</p>
+</div>
+</div>
+<div class="section" id="key-management">
+<h1>Key management</h1>
+<div class="section" id="psa_open_key">
+<span id="c.psa_open_key"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_open_key</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_open_key</span><span class="p">(</span><span class="n">psa_key_id_t</span> <span class="n">id</span><span class="p">,</span>
+ <span class="n">psa_key_handle_t</span> <span class="o">*</span> <span class="n">handle</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">id</span></code></dt>
+<dd>The persistent identifier of the key.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">handle</span></code></dt>
+<dd>On success, a handle to the key.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success. The application can now use the value of <code class="docutils literal notranslate"><span class="pre">*handle</span></code> to access the key.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_DOES_NOT_EXIST" title="PSA_ERROR_DOES_NOT_EXIST"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_DOES_NOT_EXIST</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">id</span></code> is invalid.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_PERMITTED" title="PSA_ERROR_NOT_PERMITTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_PERMITTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The specified key exists, but the application does not have the permission to access it. Note that this specification does not define any way to create such a key, but it may be possible through implementation-specific means.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_STORAGE_FAILURE" title="PSA_ERROR_STORAGE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_STORAGE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Open a handle to an existing persistent key.</p>
+<p>Open a handle to a persistent key. A key is persistent if it was created with a lifetime other than <a class="reference internal" href="#c.PSA_KEY_LIFETIME_VOLATILE" title="PSA_KEY_LIFETIME_VOLATILE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_LIFETIME_VOLATILE</span></code></a>. A persistent key always has a nonzero key identifier, set with <a class="reference internal" href="#c.psa_set_key_id" title="psa_set_key_id"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_set_key_id()</span></code></a> when creating the key. Implementations may provide additional pre-provisioned keys with identifiers in the range <a class="reference internal" href="#c.PSA_KEY_ID_VENDOR_MIN" title="PSA_KEY_ID_VENDOR_MIN"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_ID_VENDOR_MIN</span></code></a>–<a class="reference internal" href="#c.PSA_KEY_ID_VENDOR_MAX" title="PSA_KEY_ID_VENDOR_MAX"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_ID_VENDOR_MAX</span></code></a>.</p>
+<p>The application must eventually close the handle with <a class="reference internal" href="#c.psa_close_key" title="psa_close_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_close_key()</span></code></a> to release associated resources. If the application dies without calling <a class="reference internal" href="#c.psa_close_key" title="psa_close_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_close_key()</span></code></a>, the implementation should perform the equivalent of a call to <a class="reference internal" href="#c.psa_close_key" title="psa_close_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_close_key()</span></code></a>.</p>
+<p>Implementations may provide additional keys that can be opened with <a class="reference internal" href="#c.psa_open_key" title="psa_open_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_open_key()</span></code></a>. Such keys have a key identifier in the vendor range, as documented in the description of <a class="reference internal" href="#c.psa_key_id_t" title="psa_key_id_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_key_id_t</span></code></a>.</p>
+</div>
+<div class="section" id="psa_close_key">
+<span id="c.psa_close_key"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_close_key</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_close_key</span><span class="p">(</span><span class="n">psa_key_handle_t</span> <span class="n">handle</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">handle</span></code></dt>
+<dd>The key handle to close.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_HANDLE" title="PSA_ERROR_INVALID_HANDLE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_HANDLE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Close a key handle.</p>
+<p>If the handle designates a volatile key, destroy the key material and free all associated resources, just like <a class="reference internal" href="#c.psa_destroy_key" title="psa_destroy_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_destroy_key()</span></code></a>.</p>
+<p>If the handle designates a persistent key, free all resources associated with the key in volatile memory. The key in persistent storage is not affected and can be opened again later with <a class="reference internal" href="#c.psa_open_key" title="psa_open_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_open_key()</span></code></a>.</p>
+<p>If the key is currently in use in a multipart operation, the multipart operation is aborted.</p>
+</div>
+</div>
+<div class="section" id="key-import-and-export">
+<h1>Key import and export</h1>
+<div class="section" id="psa_import_key">
+<span id="c.psa_import_key"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_import_key</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_import_key</span><span class="p">(</span><span class="k">const</span> <span class="n">psa_key_attributes_t</span> <span class="o">*</span> <span class="n">attributes</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">data</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">data_length</span><span class="p">,</span>
+ <span class="n">psa_key_handle_t</span> <span class="o">*</span> <span class="n">handle</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">attributes</span></code></dt>
+<dd>The attributes for the new key. The key size is always determined from the <code class="docutils literal notranslate"><span class="pre">data</span></code> buffer. If the key size in <code class="docutils literal notranslate"><span class="pre">attributes</span></code> is nonzero, it must be equal to the size from <code class="docutils literal notranslate"><span class="pre">data</span></code>.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">data</span></code></dt>
+<dd>Buffer containing the key data. The content of this buffer is interpreted according to the type declared in <code class="docutils literal notranslate"><span class="pre">attributes</span></code>. All implementations must support at least the format described in the documentation of <a class="reference internal" href="#c.psa_export_key" title="psa_export_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_export_key()</span></code></a> or <a class="reference internal" href="#c.psa_export_public_key" title="psa_export_public_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_export_public_key()</span></code></a> for the chosen type. Implementations may allow other formats, but should be conservative: implementations should err on the side of rejecting content if it may be erroneous (e.g. wrong type or truncated data).</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">data_length</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">data</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">handle</span></code></dt>
+<dd>On success, a handle to the newly created key. <code class="docutils literal notranslate"><span class="pre">0</span></code> on failure.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success. If the key is persistent, the key material and the key’s metadata have been saved to persistent storage.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_ALREADY_EXISTS" title="PSA_ERROR_ALREADY_EXISTS"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_ALREADY_EXISTS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>This is an attempt to create a persistent key, and there is already a persistent key with the given identifier.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_SUPPORTED" title="PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The key type or key size is not supported, either by the implementation in general or in this particular persistent location.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The key attributes, as a whole, are invalid.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The key data is not correctly formatted.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The size in <code class="docutils literal notranslate"><span class="pre">attributes</span></code> is nonzero and does not match the size of the key data.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_STORAGE" title="PSA_ERROR_INSUFFICIENT_STORAGE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_STORAGE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_STORAGE_FAILURE" title="PSA_ERROR_STORAGE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_STORAGE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The library has not been previously initialized by <a class="reference internal" href="#c.psa_crypto_init" title="psa_crypto_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_crypto_init()</span></code></a>. It is implementation-dependent whether a failure to initialize results in this error code.</dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Import a key in binary format.</p>
+<p>This function supports any output from <a class="reference internal" href="#c.psa_export_key" title="psa_export_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_export_key()</span></code></a>. Refer to the documentation of <a class="reference internal" href="#c.psa_export_public_key" title="psa_export_public_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_export_public_key()</span></code></a> for the format of public keys and to the documentation of <a class="reference internal" href="#c.psa_export_key" title="psa_export_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_export_key()</span></code></a> for the format for other key types.</p>
+<p>This specification supports a single format for each key type. Implementations may support other formats as long as the standard format is supported. Implementations that support other formats should ensure that the formats are clearly unambiguous so as to minimize the risk that an invalid input is accidentally interpreted according to a different format.</p>
+</div>
+<div class="section" id="psa_destroy_key">
+<span id="c.psa_destroy_key"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_destroy_key</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_destroy_key</span><span class="p">(</span><span class="n">psa_key_handle_t</span> <span class="n">handle</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">handle</span></code></dt>
+<dd>Handle to the key to erase.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The key material has been erased.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_PERMITTED" title="PSA_ERROR_NOT_PERMITTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_PERMITTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The key cannot be erased because it is read-only, either due to a policy or due to physical restrictions.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_HANDLE" title="PSA_ERROR_INVALID_HANDLE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_HANDLE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>There was an failure in communication with the cryptoprocessor. The key material may still be present in the cryptoprocessor.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_STORAGE_FAILURE" title="PSA_ERROR_STORAGE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_STORAGE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The storage is corrupted. Implementations shall make a best effort to erase key material even in this stage, however applications should be aware that it may be impossible to guarantee that the key material is not recoverable in such cases.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>An unexpected condition which is not a storage corruption or a communication failure occurred. The cryptoprocessor may have been compromised.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The library has not been previously initialized by <a class="reference internal" href="#c.psa_crypto_init" title="psa_crypto_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_crypto_init()</span></code></a>. It is implementation-dependent whether a failure to initialize results in this error code.</dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Destroy a key.</p>
+<p>This function destroys a key from both volatile memory and, if applicable, non-volatile storage. Implementations shall make a best effort to ensure that that the key material cannot be recovered.</p>
+<p>This function also erases any metadata such as policies and frees all resources associated with the key.</p>
+</div>
+<div class="section" id="psa_export_key">
+<span id="c.psa_export_key"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_export_key</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_export_key</span><span class="p">(</span><span class="n">psa_key_handle_t</span> <span class="n">handle</span><span class="p">,</span>
+ <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">data</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">data_size</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="o">*</span> <span class="n">data_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">handle</span></code></dt>
+<dd>Handle to the key to export.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">data</span></code></dt>
+<dd>Buffer where the key data is to be written.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">data_size</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">data</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">data_length</span></code></dt>
+<dd>On success, the number of bytes that make up the key data.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_HANDLE" title="PSA_ERROR_INVALID_HANDLE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_HANDLE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_DOES_NOT_EXIST" title="PSA_ERROR_DOES_NOT_EXIST"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_DOES_NOT_EXIST</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_PERMITTED" title="PSA_ERROR_NOT_PERMITTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_PERMITTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The key does not have the <a class="reference internal" href="#c.PSA_KEY_USAGE_EXPORT" title="PSA_KEY_USAGE_EXPORT"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_EXPORT</span></code></a> flag.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_SUPPORTED" title="PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BUFFER_TOO_SMALL" title="PSA_ERROR_BUFFER_TOO_SMALL"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BUFFER_TOO_SMALL</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The size of the <code class="docutils literal notranslate"><span class="pre">data</span></code> buffer is too small. You can determine a sufficient buffer size by calling <a class="reference internal" href="#c.PSA_KEY_EXPORT_MAX_SIZE" title="PSA_KEY_EXPORT_MAX_SIZE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_EXPORT_MAX_SIZE</span></code></a>(<code class="docutils literal notranslate"><span class="pre">type</span></code>, <code class="docutils literal notranslate"><span class="pre">bits</span></code>) where <code class="docutils literal notranslate"><span class="pre">type</span></code> is the key type and <code class="docutils literal notranslate"><span class="pre">bits</span></code> is the key size in bits.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The library has not been previously initialized by <a class="reference internal" href="#c.psa_crypto_init" title="psa_crypto_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_crypto_init()</span></code></a>. It is implementation-dependent whether a failure to initialize results in this error code.</dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Export a key in binary format.</p>
+<p>The output of this function can be passed to <a class="reference internal" href="#c.psa_import_key" title="psa_import_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_import_key()</span></code></a> to create an equivalent object.</p>
+<p>If the implementation of <a class="reference internal" href="#c.psa_import_key" title="psa_import_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_import_key()</span></code></a> supports other formats beyond the format specified here, the output from <a class="reference internal" href="#c.psa_export_key" title="psa_export_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_export_key()</span></code></a> must use the representation specified here, not the original representation.</p>
+<p>For standard key types, the output format is as follows:</p>
+<ul>
+<li><p class="first">For symmetric keys (including MAC keys), the format is the raw bytes of the key.</p>
+</li>
+<li><p class="first">For DES, the key data consists of 8 bytes. The parity bits must be correct.</p>
+</li>
+<li><p class="first">For Triple-DES, the format is the concatenation of the two or three DES keys.</p>
+</li>
+<li><p class="first">For RSA key pairs (<a class="reference internal" href="#c.PSA_KEY_TYPE_RSA_KEY_PAIR" title="PSA_KEY_TYPE_RSA_KEY_PAIR"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_RSA_KEY_PAIR</span></code></a>), the format is the non-encrypted DER encoding of the representation defined by PKCS#1 (RFC 8017) as <code class="docutils literal notranslate"><span class="pre">RSAPrivateKey</span></code>, version 0.</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">RSAPrivateKey</span> <span class="o">::=</span> <span class="n">SEQUENCE</span> <span class="p">{</span>
+ <span class="n">version</span> <span class="n">INTEGER</span><span class="p">,</span> <span class="o">--</span> <span class="n">must</span> <span class="n">be</span> <span class="mi">0</span>
+ <span class="n">modulus</span> <span class="n">INTEGER</span><span class="p">,</span> <span class="o">--</span> <span class="n">n</span>
+ <span class="n">publicExponent</span> <span class="n">INTEGER</span><span class="p">,</span> <span class="o">--</span> <span class="n">e</span>
+ <span class="n">privateExponent</span> <span class="n">INTEGER</span><span class="p">,</span> <span class="o">--</span> <span class="n">d</span>
+ <span class="n">prime1</span> <span class="n">INTEGER</span><span class="p">,</span> <span class="o">--</span> <span class="n">p</span>
+ <span class="n">prime2</span> <span class="n">INTEGER</span><span class="p">,</span> <span class="o">--</span> <span class="n">q</span>
+ <span class="n">exponent1</span> <span class="n">INTEGER</span><span class="p">,</span> <span class="o">--</span> <span class="n">d</span> <span class="n">mod</span> <span class="p">(</span><span class="n">p</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
+ <span class="n">exponent2</span> <span class="n">INTEGER</span><span class="p">,</span> <span class="o">--</span> <span class="n">d</span> <span class="n">mod</span> <span class="p">(</span><span class="n">q</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
+ <span class="n">coefficient</span> <span class="n">INTEGER</span><span class="p">,</span> <span class="o">--</span> <span class="p">(</span><span class="n">inverse</span> <span class="n">of</span> <span class="n">q</span><span class="p">)</span> <span class="n">mod</span> <span class="n">p</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first">For elliptic curve key pairs (key types for which <a class="reference internal" href="#c.PSA_KEY_TYPE_IS_ECC_KEY_PAIR" title="PSA_KEY_TYPE_IS_ECC_KEY_PAIR"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_ECC_KEY_PAIR</span></code></a> is true), the format is a representation of the private value as a <code class="docutils literal notranslate"><span class="pre">ceiling(m/8)</span></code>-byte string where <code class="docutils literal notranslate"><span class="pre">m</span></code> is the bit size associated with the curve, i.e. the bit size of the order of the curve’s coordinate field. This byte string is in little-endian order for Montgomery curves (curve types <code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_CURVEXXX</span></code>), and in big-endian order for Weierstrass curves (curve types <code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECTXXX</span></code>, <code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECPXXX</span></code> and <code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_BRAINPOOL_PXXX</span></code>). This is the content of the <code class="docutils literal notranslate"><span class="pre">privateKey</span></code> field of the <code class="docutils literal notranslate"><span class="pre">ECPrivateKey</span></code> format defined by RFC 5915.</p>
+</li>
+<li><p class="first">For Diffie-Hellman key exchange key pairs (key types for which <a class="reference internal" href="#c.PSA_KEY_TYPE_IS_DH_KEY_PAIR" title="PSA_KEY_TYPE_IS_DH_KEY_PAIR"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_DH_KEY_PAIR</span></code></a> is true), the format is the representation of the private key <code class="docutils literal notranslate"><span class="pre">x</span></code> as a big-endian byte string. The length of the byte string is the private key size in bytes (leading zeroes are not stripped).</p>
+</li>
+<li><p class="first">For public keys (key types for which <a class="reference internal" href="#c.PSA_KEY_TYPE_IS_PUBLIC_KEY" title="PSA_KEY_TYPE_IS_PUBLIC_KEY"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_PUBLIC_KEY</span></code></a> is true), the format is the same as for <a class="reference internal" href="#c.psa_export_public_key" title="psa_export_public_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_export_public_key()</span></code></a>.</p>
+</li>
+</ul>
+<p>The policy on the key must have the usage flag <a class="reference internal" href="#c.PSA_KEY_USAGE_EXPORT" title="PSA_KEY_USAGE_EXPORT"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_EXPORT</span></code></a> set.</p>
+</div>
+<div class="section" id="psa_export_public_key">
+<span id="c.psa_export_public_key"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_export_public_key</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_export_public_key</span><span class="p">(</span><span class="n">psa_key_handle_t</span> <span class="n">handle</span><span class="p">,</span>
+ <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">data</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">data_size</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="o">*</span> <span class="n">data_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">handle</span></code></dt>
+<dd>Handle to the key to export.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">data</span></code></dt>
+<dd>Buffer where the key data is to be written.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">data_size</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">data</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">data_length</span></code></dt>
+<dd>On success, the number of bytes that make up the key data.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_HANDLE" title="PSA_ERROR_INVALID_HANDLE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_HANDLE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_DOES_NOT_EXIST" title="PSA_ERROR_DOES_NOT_EXIST"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_DOES_NOT_EXIST</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The key is neither a public key nor a key pair.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_SUPPORTED" title="PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BUFFER_TOO_SMALL" title="PSA_ERROR_BUFFER_TOO_SMALL"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BUFFER_TOO_SMALL</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The size of the <code class="docutils literal notranslate"><span class="pre">data</span></code> buffer is too small. You can determine a sufficient buffer size by calling <a class="reference internal" href="#c.PSA_KEY_EXPORT_MAX_SIZE" title="PSA_KEY_EXPORT_MAX_SIZE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_EXPORT_MAX_SIZE</span></code></a>(<a class="reference internal" href="#c.PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR" title="PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR</span></code></a>(<code class="docutils literal notranslate"><span class="pre">type</span></code>), <code class="docutils literal notranslate"><span class="pre">bits</span></code>) where <code class="docutils literal notranslate"><span class="pre">type</span></code> is the key type and <code class="docutils literal notranslate"><span class="pre">bits</span></code> is the key size in bits.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The library has not been previously initialized by <a class="reference internal" href="#c.psa_crypto_init" title="psa_crypto_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_crypto_init()</span></code></a>. It is implementation-dependent whether a failure to initialize results in this error code.</dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Export a public key or the public part of a key pair in binary format.</p>
+<p>The output of this function can be passed to <a class="reference internal" href="#c.psa_import_key" title="psa_import_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_import_key()</span></code></a> to create an object that is equivalent to the public key.</p>
+<p>This specification supports a single format for each key type. Implementations may support other formats as long as the standard format is supported. Implementations that support other formats should ensure that the formats are clearly unambiguous so as to minimize the risk that an invalid input is accidentally interpreted according to a different format.</p>
+<p>For standard key types, the output format is as follows:</p>
+<ul>
+<li><p class="first">For RSA public keys (<a class="reference internal" href="#c.PSA_KEY_TYPE_RSA_PUBLIC_KEY" title="PSA_KEY_TYPE_RSA_PUBLIC_KEY"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_RSA_PUBLIC_KEY</span></code></a>), the DER encoding of the representation defined by RFC 3279 §2.3.1 as <code class="docutils literal notranslate"><span class="pre">RSAPublicKey</span></code>.</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">RSAPublicKey</span> <span class="o">::=</span> <span class="n">SEQUENCE</span> <span class="p">{</span>
+ <span class="n">modulus</span> <span class="n">INTEGER</span><span class="p">,</span> <span class="o">--</span> <span class="n">n</span>
+ <span class="n">publicExponent</span> <span class="n">INTEGER</span> <span class="p">}</span> <span class="o">--</span> <span class="n">e</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first">For elliptic curve public keys (key types for which <a class="reference internal" href="#c.PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY" title="PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY</span></code></a> is true), the format is the uncompressed representation defined by SEC1 §2.3.3 as the content of an ECPoint. Let <code class="docutils literal notranslate"><span class="pre">m</span></code> be the bit size associated with the curve, i.e. the bit size of <code class="docutils literal notranslate"><span class="pre">q</span></code> for a curve over <code class="docutils literal notranslate"><span class="pre">F_q</span></code>. The representation consists of:</p>
+<ul class="simple">
+<li>The byte 0x04;</li>
+<li><code class="docutils literal notranslate"><span class="pre">x_P</span></code> as a <code class="docutils literal notranslate"><span class="pre">ceiling(m/8)</span></code>-byte string, big-endian;</li>
+<li><code class="docutils literal notranslate"><span class="pre">y_P</span></code> as a <code class="docutils literal notranslate"><span class="pre">ceiling(m/8)</span></code>-byte string, big-endian.</li>
+</ul>
+</li>
+<li><p class="first">For Diffie-Hellman key exchange public keys (key types for which <a class="reference internal" href="#c.PSA_KEY_TYPE_IS_DH_PUBLIC_KEY" title="PSA_KEY_TYPE_IS_DH_PUBLIC_KEY"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_DH_PUBLIC_KEY</span></code></a> is true), the format is the representation of the public key <code class="docutils literal notranslate"><span class="pre">y</span> <span class="pre">=</span> <span class="pre">g^x</span> <span class="pre">mod</span> <span class="pre">p</span></code> as a big-endian byte string. The length of the byte string is the length of the base prime <code class="docutils literal notranslate"><span class="pre">p</span></code> in bytes.</p>
+</li>
+</ul>
+<p>Exporting a public key object or the public part of a key pair is always permitted, regardless of the key’s usage flags.</p>
+</div>
+<div class="section" id="psa_copy_key">
+<span id="c.psa_copy_key"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_copy_key</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_copy_key</span><span class="p">(</span><span class="n">psa_key_handle_t</span> <span class="n">source_handle</span><span class="p">,</span>
+ <span class="k">const</span> <span class="n">psa_key_attributes_t</span> <span class="o">*</span> <span class="n">attributes</span><span class="p">,</span>
+ <span class="n">psa_key_handle_t</span> <span class="o">*</span> <span class="n">target_handle</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">source_handle</span></code></dt>
+<dd>The key to copy. It must be a valid key handle.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">attributes</span></code></dt>
+<dd><p class="first">The attributes for the new key. They are used as follows:</p>
+<ul class="last simple">
+<li>The key type and size may be 0. If either is nonzero, it must match the corresponding attribute of the source key.</li>
+<li>The key location (the lifetime and, for persistent keys, the key identifier) is used directly.</li>
+<li>The policy constraints (usage flags and algorithm policy) are combined from the source key and <code class="docutils literal notranslate"><span class="pre">attributes</span></code> so that both sets of restrictions apply, as described in the documentation of this function.</li>
+</ul>
+</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">target_handle</span></code></dt>
+<dd>On success, a handle to the newly created key. <code class="docutils literal notranslate"><span class="pre">0</span></code> on failure.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_HANDLE" title="PSA_ERROR_INVALID_HANDLE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_HANDLE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">source_handle</span></code> is invalid.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_ALREADY_EXISTS" title="PSA_ERROR_ALREADY_EXISTS"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_ALREADY_EXISTS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>This is an attempt to create a persistent key, and there is already a persistent key with the given identifier.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The lifetime or identifier in <code class="docutils literal notranslate"><span class="pre">attributes</span></code> are invalid.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The policy constraints on the source and specified in <code class="docutils literal notranslate"><span class="pre">attributes</span></code> are incompatible.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">attributes</span></code> specifies a key type or key size which does not match the attributes of the source key.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_PERMITTED" title="PSA_ERROR_NOT_PERMITTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_PERMITTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The source key does not have the <a class="reference internal" href="#c.PSA_KEY_USAGE_COPY" title="PSA_KEY_USAGE_COPY"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_COPY</span></code></a> usage flag.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_PERMITTED" title="PSA_ERROR_NOT_PERMITTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_PERMITTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The source key is not exportable and its lifetime does not allow copying it to the target’s lifetime.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_STORAGE" title="PSA_ERROR_INSUFFICIENT_STORAGE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_STORAGE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Make a copy of a key.</p>
+<p>Copy key material from one location to another.</p>
+<p>This function is primarily useful to copy a key from one location to another, since it populates a key using the material from another key which may have a different lifetime.</p>
+<p>This function may be used to share a key with a different party, subject to implementation-defined restrictions on key sharing.</p>
+<p>The policy on the source key must have the usage flag <a class="reference internal" href="#c.PSA_KEY_USAGE_COPY" title="PSA_KEY_USAGE_COPY"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_COPY</span></code></a> set. This flag is sufficient to permit the copy if the key has the lifetime <a class="reference internal" href="#c.PSA_KEY_LIFETIME_VOLATILE" title="PSA_KEY_LIFETIME_VOLATILE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_LIFETIME_VOLATILE</span></code></a> or <a class="reference internal" href="#c.PSA_KEY_LIFETIME_PERSISTENT" title="PSA_KEY_LIFETIME_PERSISTENT"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_LIFETIME_PERSISTENT</span></code></a>. Some secure elements do not provide a way to copy a key without making it extractable from the secure element. If a key is located in such a secure element, then the key must have both usage flags <a class="reference internal" href="#c.PSA_KEY_USAGE_COPY" title="PSA_KEY_USAGE_COPY"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_COPY</span></code></a> and <a class="reference internal" href="#c.PSA_KEY_USAGE_EXPORT" title="PSA_KEY_USAGE_EXPORT"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_EXPORT</span></code></a> in order to make a copy of the key outside the secure element.</p>
+<p>The resulting key may only be used in a way that conforms to both the policy of the original key and the policy specified in the <code class="docutils literal notranslate"><span class="pre">attributes</span></code> parameter:</p>
+<ul class="simple">
+<li>The usage flags on the resulting key are the bitwise-and of the usage flags on the source policy and the usage flags in <code class="docutils literal notranslate"><span class="pre">attributes</span></code>.</li>
+<li>If both allow the same algorithm or wildcard-based algorithm policy, the resulting key has the same algorithm policy.</li>
+<li>If either of the policies allows an algorithm and the other policy allows a wildcard-based algorithm policy that includes this algorithm, the resulting key allows the same algorithm.</li>
+<li>If the policies do not allow any algorithm in common, this function fails with the status <a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a>.</li>
+</ul>
+<p>The effect of this function on implementation-defined attributes is implementation-defined.</p>
+</div>
+</div>
+<div class="section" id="message-digests">
+<h1>Message digests</h1>
+<div class="section" id="psa_hash_operation_t">
+<span id="c.psa_hash_operation_t"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_hash_operation_t</span></code> (type)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="k">typedef</span> <span class="k">struct</span> <span class="n">psa_hash_operation_s</span> <span class="n">psa_hash_operation_t</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>The type of the state data structure for multipart hash operations.</p>
+<p>Before calling any function on a hash operation object, the application must initialize it by any of the following means:</p>
+<ul>
+<li><p class="first">Set the structure to all-bits-zero, for example:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_hash_operation_t</span> <span class="n">operation</span><span class="p">;</span>
+<span class="n">memset</span><span class="p">(</span><span class="o">&</span><span class="n">operation</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="k">sizeof</span><span class="p">(</span><span class="n">operation</span><span class="p">));</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first">Initialize the structure to logical zero values, for example:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_hash_operation_t</span> <span class="n">operation</span> <span class="o">=</span> <span class="p">{</span><span class="mi">0</span><span class="p">};</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first">Initialize the structure to the initializer <a class="reference internal" href="#c.PSA_HASH_OPERATION_INIT" title="PSA_HASH_OPERATION_INIT"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_HASH_OPERATION_INIT</span></code></a>, for example:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_hash_operation_t</span> <span class="n">operation</span> <span class="o">=</span> <span class="n">PSA_HASH_OPERATION_INIT</span><span class="p">;</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first">Assign the result of the function <a class="reference internal" href="#c.psa_hash_operation_init" title="psa_hash_operation_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_operation_init()</span></code></a> to the structure, for example:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_hash_operation_t</span> <span class="n">operation</span><span class="p">;</span>
+<span class="n">operation</span> <span class="o">=</span> <span class="n">psa_hash_operation_init</span><span class="p">();</span>
+</pre></div>
+</div>
+</li>
+</ul>
+<p>This is an implementation-defined <code class="docutils literal notranslate"><span class="pre">struct</span></code>. Applications should not make any assumptions about the content of this structure except as directed by the documentation of a specific implementation.</p>
+</div>
+<div class="section" id="PSA_HASH_OPERATION_INIT">
+<span id="c.PSA_HASH_OPERATION_INIT"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_HASH_OPERATION_INIT</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_HASH_OPERATION_INIT {0}</span>
+</pre></div>
+</div>
+<p>This macro returns a suitable initializer for a hash operation object of type <a class="reference internal" href="#c.psa_hash_operation_t" title="psa_hash_operation_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_hash_operation_t</span></code></a>.</p>
+</div>
+<div class="section" id="psa_hash_compute">
+<span id="c.psa_hash_compute"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_hash_compute</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_hash_compute</span><span class="p">(</span><span class="n">psa_algorithm_t</span> <span class="n">alg</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">input</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">input_length</span><span class="p">,</span>
+ <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">hash</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">hash_size</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="o">*</span> <span class="n">hash_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>The hash algorithm to compute (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_HASH" title="PSA_ALG_IS_HASH"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_HASH</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true).</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">input</span></code></dt>
+<dd>Buffer containing the message to hash.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">input_length</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">input</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">hash</span></code></dt>
+<dd>Buffer where the hash is to be written.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">hash_size</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">hash</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">hash_length</span></code></dt>
+<dd>On success, the number of bytes that make up the hash value. This is always <a class="reference internal" href="#c.PSA_HASH_SIZE" title="PSA_HASH_SIZE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_HASH_SIZE</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_SUPPORTED" title="PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">alg</span></code> is not supported or is not a hash algorithm.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Calculate the hash (digest) of a message.</p>
+<div class="admonition note">
+<p class="first admonition-title">Note</p>
+<p class="last">To verify the hash of a message against an expected value, use <a class="reference internal" href="#c.psa_hash_compare" title="psa_hash_compare"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_compare()</span></code></a> instead.</p>
+</div>
+</div>
+<div class="section" id="psa_hash_compare">
+<span id="c.psa_hash_compare"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_hash_compare</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_hash_compare</span><span class="p">(</span><span class="n">psa_algorithm_t</span> <span class="n">alg</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">input</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">input_length</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">hash</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">size_t</span> <span class="n">hash_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>The hash algorithm to compute (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_HASH" title="PSA_ALG_IS_HASH"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_HASH</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true).</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">input</span></code></dt>
+<dd>Buffer containing the message to hash.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">input_length</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">input</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">hash</span></code></dt>
+<dd>Buffer containing the expected hash value.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">hash_length</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">hash</span></code> buffer in bytes.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The expected hash is identical to the actual hash of the input.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_SIGNATURE" title="PSA_ERROR_INVALID_SIGNATURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_SIGNATURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The hash of the message was calculated successfully, but it differs from the expected hash.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_SUPPORTED" title="PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">alg</span></code> is not supported or is not a hash algorithm.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Calculate the hash (digest) of a message and compare it with a reference value.</p>
+</div>
+<div class="section" id="psa_hash_operation_init">
+<span id="c.psa_hash_operation_init"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_hash_operation_init</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_hash_operation_t</span> <span class="nf">psa_hash_operation_init</span><span class="p">(</span><span class="kt">void</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_hash_operation_t" title="psa_hash_operation_t"><code class="docutils literal notranslate"><span class="pre">psa_hash_operation_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Return an initial value for a hash operation object.</p>
+</div>
+<div class="section" id="psa_hash_setup">
+<span id="c.psa_hash_setup"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_hash_setup</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_hash_setup</span><span class="p">(</span><span class="n">psa_hash_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="n">psa_algorithm_t</span> <span class="n">alg</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>The operation object to set up. It must have been initialized as per the documentation for <a class="reference internal" href="#c.psa_hash_operation_t" title="psa_hash_operation_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_hash_operation_t</span></code></a> and not yet in use.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>The hash algorithm to compute (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_HASH" title="PSA_ALG_IS_HASH"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_HASH</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_SUPPORTED" title="PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">alg</span></code> is not supported or is not a hash algorithm.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The operation state is not valid (already set up and not subsequently completed).</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Set up a multipart hash operation.</p>
+<p>The sequence of operations to calculate a hash (message digest) is as follows:</p>
+<ol class="arabic simple">
+<li>Allocate an operation object which will be passed to all the functions listed here.</li>
+<li>Initialize the operation object with one of the methods described in the documentation for <a class="reference internal" href="#c.psa_hash_operation_t" title="psa_hash_operation_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_hash_operation_t</span></code></a>, e.g. PSA_HASH_OPERATION_INIT.</li>
+<li>Call <a class="reference internal" href="#c.psa_hash_setup" title="psa_hash_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_setup()</span></code></a> to specify the algorithm.</li>
+<li>Call <a class="reference internal" href="#c.psa_hash_update" title="psa_hash_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_update()</span></code></a> zero, one or more times, passing a fragment of the message each time. The hash that is calculated is the hash of the concatenation of these messages in order.</li>
+<li>To calculate the hash, call <a class="reference internal" href="#c.psa_hash_finish" title="psa_hash_finish"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_finish()</span></code></a>. To compare the hash with an expected value, call <a class="reference internal" href="#c.psa_hash_verify" title="psa_hash_verify"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_verify()</span></code></a>.</li>
+</ol>
+<p>The application may call <a class="reference internal" href="#c.psa_hash_abort" title="psa_hash_abort"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_abort()</span></code></a> at any time after the operation has been initialized.</p>
+<p>After a successful call to <a class="reference internal" href="#c.psa_hash_setup" title="psa_hash_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_setup()</span></code></a>, the application must eventually terminate the operation. The following events terminate an operation:</p>
+<ul class="simple">
+<li>A failed call to <a class="reference internal" href="#c.psa_hash_update" title="psa_hash_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_update()</span></code></a>.</li>
+<li>A call to <a class="reference internal" href="#c.psa_hash_finish" title="psa_hash_finish"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_finish()</span></code></a>, <a class="reference internal" href="#c.psa_hash_verify" title="psa_hash_verify"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_verify()</span></code></a> or <a class="reference internal" href="#c.psa_hash_abort" title="psa_hash_abort"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_abort()</span></code></a>.</li>
+</ul>
+</div>
+<div class="section" id="psa_hash_update">
+<span id="c.psa_hash_update"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_hash_update</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_hash_update</span><span class="p">(</span><span class="n">psa_hash_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">input</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">input_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>Active hash operation.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">input</span></code></dt>
+<dd>Buffer containing the message fragment to hash.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">input_length</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">input</span></code> buffer in bytes.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The operation state is not valid (not set up, or already completed).</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Add a message fragment to a multipart hash operation.</p>
+<p>The application must call <a class="reference internal" href="#c.psa_hash_setup" title="psa_hash_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_setup()</span></code></a> before calling this function.</p>
+<p>If this function returns an error status, the operation becomes inactive.</p>
+</div>
+<div class="section" id="psa_hash_finish">
+<span id="c.psa_hash_finish"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_hash_finish</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_hash_finish</span><span class="p">(</span><span class="n">psa_hash_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">hash</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">hash_size</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="o">*</span> <span class="n">hash_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>Active hash operation.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">hash</span></code></dt>
+<dd>Buffer where the hash is to be written.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">hash_size</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">hash</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">hash_length</span></code></dt>
+<dd>On success, the number of bytes that make up the hash value. This is always <a class="reference internal" href="#c.PSA_HASH_SIZE" title="PSA_HASH_SIZE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_HASH_SIZE</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) where <code class="docutils literal notranslate"><span class="pre">alg</span></code> is the hash algorithm that is calculated.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The operation state is not valid (not set up, or already completed).</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BUFFER_TOO_SMALL" title="PSA_ERROR_BUFFER_TOO_SMALL"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BUFFER_TOO_SMALL</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The size of the <code class="docutils literal notranslate"><span class="pre">hash</span></code> buffer is too small. You can determine a sufficient buffer size by calling <a class="reference internal" href="#c.PSA_HASH_SIZE" title="PSA_HASH_SIZE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_HASH_SIZE</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) where <code class="docutils literal notranslate"><span class="pre">alg</span></code> is the hash algorithm that is calculated.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Finish the calculation of the hash of a message.</p>
+<p>The application must call <a class="reference internal" href="#c.psa_hash_setup" title="psa_hash_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_setup()</span></code></a> before calling this function. This function calculates the hash of the message formed by concatenating the inputs passed to preceding calls to <a class="reference internal" href="#c.psa_hash_update" title="psa_hash_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_update()</span></code></a>.</p>
+<p>When this function returns, the operation becomes inactive.</p>
+<div class="admonition warning">
+<p class="first admonition-title">Warning</p>
+<p class="last">Applications should not call this function if they expect a specific value for the hash. Call <a class="reference internal" href="#c.psa_hash_verify" title="psa_hash_verify"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_verify()</span></code></a> instead. Beware that comparing integrity or authenticity data such as hash values with a function such as <code class="docutils literal notranslate"><span class="pre">memcmp</span></code> is risky because the time taken by the comparison may leak information about the hashed data which could allow an attacker to guess a valid hash and thereby bypass security controls.</p>
+</div>
+</div>
+<div class="section" id="psa_hash_verify">
+<span id="c.psa_hash_verify"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_hash_verify</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_hash_verify</span><span class="p">(</span><span class="n">psa_hash_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">hash</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">hash_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>Active hash operation.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">hash</span></code></dt>
+<dd>Buffer containing the expected hash value.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">hash_length</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">hash</span></code> buffer in bytes.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The expected hash is identical to the actual hash of the message.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_SIGNATURE" title="PSA_ERROR_INVALID_SIGNATURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_SIGNATURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The hash of the message was calculated successfully, but it differs from the expected hash.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The operation state is not valid (not set up, or already completed).</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Finish the calculation of the hash of a message and compare it with an expected value.</p>
+<p>The application must call <a class="reference internal" href="#c.psa_hash_setup" title="psa_hash_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_setup()</span></code></a> before calling this function. This function calculates the hash of the message formed by concatenating the inputs passed to preceding calls to <a class="reference internal" href="#c.psa_hash_update" title="psa_hash_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_update()</span></code></a>. It then compares the calculated hash with the expected hash passed as a parameter to this function.</p>
+<p>When this function returns, the operation becomes inactive.</p>
+<div class="admonition note">
+<p class="first admonition-title">Note</p>
+<p class="last">Implementations shall make the best effort to ensure that the comparison between the actual hash and the expected hash is performed in constant time.</p>
+</div>
+</div>
+<div class="section" id="psa_hash_abort">
+<span id="c.psa_hash_abort"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_hash_abort</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_hash_abort</span><span class="p">(</span><span class="n">psa_hash_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>Initialized hash operation.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">operation</span></code> is not an active hash operation.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Abort a hash operation.</p>
+<p>Aborting an operation frees all associated resources except for the <code class="docutils literal notranslate"><span class="pre">operation</span></code> structure itself. Once aborted, the operation object can be reused for another operation by calling <a class="reference internal" href="#c.psa_hash_setup" title="psa_hash_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_setup()</span></code></a> again.</p>
+<p>You may call this function any time after the operation object has been initialized by any of the following methods:</p>
+<ul class="simple">
+<li>A call to <a class="reference internal" href="#c.psa_hash_setup" title="psa_hash_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_setup()</span></code></a>, whether it succeeds or not.</li>
+<li>Initializing the <code class="docutils literal notranslate"><span class="pre">struct</span></code> to all-bits-zero.</li>
+<li>Initializing the <code class="docutils literal notranslate"><span class="pre">struct</span></code> to logical zeros, e.g. <code class="docutils literal notranslate"><span class="pre">psa_hash_operation_t</span> <span class="pre">operation</span> <span class="pre">=</span> <span class="pre">{0}</span></code>.</li>
+</ul>
+<p>In particular, calling <a class="reference internal" href="#c.psa_hash_abort" title="psa_hash_abort"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_abort()</span></code></a> after the operation has been terminated by a call to <a class="reference internal" href="#c.psa_hash_abort" title="psa_hash_abort"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_abort()</span></code></a>, <a class="reference internal" href="#c.psa_hash_finish" title="psa_hash_finish"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_finish()</span></code></a> or <a class="reference internal" href="#c.psa_hash_verify" title="psa_hash_verify"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_verify()</span></code></a> is safe and has no effect.</p>
+</div>
+<div class="section" id="psa_hash_clone">
+<span id="c.psa_hash_clone"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_hash_clone</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_hash_clone</span><span class="p">(</span><span class="k">const</span> <span class="n">psa_hash_operation_t</span> <span class="o">*</span> <span class="n">source_operation</span><span class="p">,</span>
+ <span class="n">psa_hash_operation_t</span> <span class="o">*</span> <span class="n">target_operation</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">source_operation</span></code></dt>
+<dd>The active hash operation to clone.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">target_operation</span></code></dt>
+<dd>The operation object to set up. It must be initialized but not active.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">source_operation</span></code> is not an active hash operation.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">target_operation</span></code> is active.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Clone a hash operation.</p>
+<p>This function copies the state of an ongoing hash operation to a new operation object. In other words, this function is equivalent to calling <a class="reference internal" href="#c.psa_hash_setup" title="psa_hash_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_setup()</span></code></a> on <code class="docutils literal notranslate"><span class="pre">target_operation</span></code> with the same algorithm that <code class="docutils literal notranslate"><span class="pre">source_operation</span></code> was set up for, then <a class="reference internal" href="#c.psa_hash_update" title="psa_hash_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_update()</span></code></a> on <code class="docutils literal notranslate"><span class="pre">target_operation</span></code> with the same input that that was passed to <code class="docutils literal notranslate"><span class="pre">source_operation</span></code>. After this function returns, the two objects are independent, i.e. subsequent calls involving one of the objects do not affect the other object.</p>
+</div>
+</div>
+<div class="section" id="message-authentication-codes">
+<h1>Message authentication codes</h1>
+<div class="section" id="psa_mac_operation_t">
+<span id="c.psa_mac_operation_t"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_mac_operation_t</span></code> (type)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="k">typedef</span> <span class="k">struct</span> <span class="n">psa_mac_operation_s</span> <span class="n">psa_mac_operation_t</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>The type of the state data structure for multipart MAC operations.</p>
+<p>Before calling any function on a MAC operation object, the application must initialize it by any of the following means:</p>
+<ul>
+<li><p class="first">Set the structure to all-bits-zero, for example:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_mac_operation_t</span> <span class="n">operation</span><span class="p">;</span>
+<span class="n">memset</span><span class="p">(</span><span class="o">&</span><span class="n">operation</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="k">sizeof</span><span class="p">(</span><span class="n">operation</span><span class="p">));</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first">Initialize the structure to logical zero values, for example:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_mac_operation_t</span> <span class="n">operation</span> <span class="o">=</span> <span class="p">{</span><span class="mi">0</span><span class="p">};</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first">Initialize the structure to the initializer <a class="reference internal" href="#c.PSA_MAC_OPERATION_INIT" title="PSA_MAC_OPERATION_INIT"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_MAC_OPERATION_INIT</span></code></a>, for example:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_mac_operation_t</span> <span class="n">operation</span> <span class="o">=</span> <span class="n">PSA_MAC_OPERATION_INIT</span><span class="p">;</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first">Assign the result of the function <a class="reference internal" href="#c.psa_mac_operation_init" title="psa_mac_operation_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_operation_init()</span></code></a> to the structure, for example:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_mac_operation_t</span> <span class="n">operation</span><span class="p">;</span>
+<span class="n">operation</span> <span class="o">=</span> <span class="n">psa_mac_operation_init</span><span class="p">();</span>
+</pre></div>
+</div>
+</li>
+</ul>
+<p>This is an implementation-defined <code class="docutils literal notranslate"><span class="pre">struct</span></code>. Applications should not make any assumptions about the content of this structure except as directed by the documentation of a specific implementation.</p>
+</div>
+<div class="section" id="PSA_MAC_OPERATION_INIT">
+<span id="c.PSA_MAC_OPERATION_INIT"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_MAC_OPERATION_INIT</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_MAC_OPERATION_INIT {0}</span>
+</pre></div>
+</div>
+<p>This macro returns a suitable initializer for a MAC operation object of type <a class="reference internal" href="#c.psa_mac_operation_t" title="psa_mac_operation_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_mac_operation_t</span></code></a>.</p>
+</div>
+<div class="section" id="psa_mac_compute">
+<span id="c.psa_mac_compute"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_mac_compute</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_mac_compute</span><span class="p">(</span><span class="n">psa_key_handle_t</span> <span class="n">handle</span><span class="p">,</span>
+ <span class="n">psa_algorithm_t</span> <span class="n">alg</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">input</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">input_length</span><span class="p">,</span>
+ <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">mac</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">mac_size</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="o">*</span> <span class="n">mac_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">handle</span></code></dt>
+<dd>Handle to the key to use for the operation.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>The MAC algorithm to compute (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_MAC" title="PSA_ALG_IS_MAC"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_MAC</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true).</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">input</span></code></dt>
+<dd>Buffer containing the input message.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">input_length</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">input</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">mac</span></code></dt>
+<dd>Buffer where the MAC value is to be written.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">mac_size</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">mac</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">mac_length</span></code></dt>
+<dd>On success, the number of bytes that make up the MAC value.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_HANDLE" title="PSA_ERROR_INVALID_HANDLE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_HANDLE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_PERMITTED" title="PSA_ERROR_NOT_PERMITTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_PERMITTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">handle</span></code> is not compatible with <code class="docutils literal notranslate"><span class="pre">alg</span></code>.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_SUPPORTED" title="PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">alg</span></code> is not supported or is not a MAC algorithm.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The library has not been previously initialized by <a class="reference internal" href="#c.psa_crypto_init" title="psa_crypto_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_crypto_init()</span></code></a>. It is implementation-dependent whether a failure to initialize results in this error code.</dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Calculate the MAC (message authentication code) of a message.</p>
+<div class="admonition note">
+<p class="first admonition-title">Note</p>
+<p class="last">To verify the MAC of a message against an expected value, use <a class="reference internal" href="#c.psa_mac_verify" title="psa_mac_verify"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_verify()</span></code></a> instead. Beware that comparing integrity or authenticity data such as MAC values with a function such as <code class="docutils literal notranslate"><span class="pre">memcmp</span></code> is risky because the time taken by the comparison may leak information about the MAC value which could allow an attacker to guess a valid MAC and thereby bypass security controls.</p>
+</div>
+</div>
+<div class="section" id="psa_mac_verify">
+<span id="c.psa_mac_verify"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_mac_verify</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_mac_verify</span><span class="p">(</span><span class="n">psa_key_handle_t</span> <span class="n">handle</span><span class="p">,</span>
+ <span class="n">psa_algorithm_t</span> <span class="n">alg</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">input</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">input_length</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">mac</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">size_t</span> <span class="n">mac_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">handle</span></code></dt>
+<dd>Handle to the key to use for the operation.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>The MAC algorithm to compute (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_MAC" title="PSA_ALG_IS_MAC"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_MAC</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true).</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">input</span></code></dt>
+<dd>Buffer containing the input message.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">input_length</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">input</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">mac</span></code></dt>
+<dd>Buffer containing the expected MAC value.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">mac_length</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">mac</span></code> buffer in bytes.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The expected MAC is identical to the actual MAC of the input.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_SIGNATURE" title="PSA_ERROR_INVALID_SIGNATURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_SIGNATURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The MAC of the message was calculated successfully, but it differs from the expected value.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_HANDLE" title="PSA_ERROR_INVALID_HANDLE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_HANDLE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_PERMITTED" title="PSA_ERROR_NOT_PERMITTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_PERMITTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">handle</span></code> is not compatible with <code class="docutils literal notranslate"><span class="pre">alg</span></code>.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_SUPPORTED" title="PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">alg</span></code> is not supported or is not a MAC algorithm.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Calculate the MAC of a message and compare it with a reference value.</p>
+</div>
+<div class="section" id="psa_mac_operation_init">
+<span id="c.psa_mac_operation_init"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_mac_operation_init</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_mac_operation_t</span> <span class="nf">psa_mac_operation_init</span><span class="p">(</span><span class="kt">void</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_mac_operation_t" title="psa_mac_operation_t"><code class="docutils literal notranslate"><span class="pre">psa_mac_operation_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Return an initial value for a MAC operation object.</p>
+</div>
+<div class="section" id="psa_mac_sign_setup">
+<span id="c.psa_mac_sign_setup"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_mac_sign_setup</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_mac_sign_setup</span><span class="p">(</span><span class="n">psa_mac_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="n">psa_key_handle_t</span> <span class="n">handle</span><span class="p">,</span>
+ <span class="n">psa_algorithm_t</span> <span class="n">alg</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>The operation object to set up. It must have been initialized as per the documentation for <a class="reference internal" href="#c.psa_mac_operation_t" title="psa_mac_operation_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_mac_operation_t</span></code></a> and not yet in use.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">handle</span></code></dt>
+<dd>Handle to the key to use for the operation. It must remain valid until the operation terminates.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>The MAC algorithm to compute (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_MAC" title="PSA_ALG_IS_MAC"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_MAC</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_HANDLE" title="PSA_ERROR_INVALID_HANDLE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_HANDLE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_DOES_NOT_EXIST" title="PSA_ERROR_DOES_NOT_EXIST"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_DOES_NOT_EXIST</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_PERMITTED" title="PSA_ERROR_NOT_PERMITTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_PERMITTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">handle</span></code> is not compatible with <code class="docutils literal notranslate"><span class="pre">alg</span></code>.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_SUPPORTED" title="PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">alg</span></code> is not supported or is not a MAC algorithm.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The operation state is not valid (already set up and not subsequently completed).</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The library has not been previously initialized by <a class="reference internal" href="#c.psa_crypto_init" title="psa_crypto_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_crypto_init()</span></code></a>. It is implementation-dependent whether a failure to initialize results in this error code.</dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Set up a multipart MAC calculation operation.</p>
+<p>This function sets up the calculation of the MAC (message authentication code) of a byte string. To verify the MAC of a message against an expected value, use <a class="reference internal" href="#c.psa_mac_verify_setup" title="psa_mac_verify_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_verify_setup()</span></code></a> instead.</p>
+<p>The sequence of operations to calculate a MAC is as follows:</p>
+<ol class="arabic simple">
+<li>Allocate an operation object which will be passed to all the functions listed here.</li>
+<li>Initialize the operation object with one of the methods described in the documentation for <a class="reference internal" href="#c.psa_mac_operation_t" title="psa_mac_operation_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_mac_operation_t</span></code></a>, e.g. PSA_MAC_OPERATION_INIT.</li>
+<li>Call <a class="reference internal" href="#c.psa_mac_sign_setup" title="psa_mac_sign_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_sign_setup()</span></code></a> to specify the algorithm and key.</li>
+<li>Call <a class="reference internal" href="#c.psa_mac_update" title="psa_mac_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_update()</span></code></a> zero, one or more times, passing a fragment of the message each time. The MAC that is calculated is the MAC of the concatenation of these messages in order.</li>
+<li>At the end of the message, call <a class="reference internal" href="#c.psa_mac_sign_finish" title="psa_mac_sign_finish"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_sign_finish()</span></code></a> to finish calculating the MAC value and retrieve it.</li>
+</ol>
+<p>The application may call <a class="reference internal" href="#c.psa_mac_abort" title="psa_mac_abort"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_abort()</span></code></a> at any time after the operation has been initialized.</p>
+<p>After a successful call to <a class="reference internal" href="#c.psa_mac_sign_setup" title="psa_mac_sign_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_sign_setup()</span></code></a>, the application must eventually terminate the operation through one of the following methods:</p>
+<ul class="simple">
+<li>A failed call to <a class="reference internal" href="#c.psa_mac_update" title="psa_mac_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_update()</span></code></a>.</li>
+<li>A call to <a class="reference internal" href="#c.psa_mac_sign_finish" title="psa_mac_sign_finish"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_sign_finish()</span></code></a> or <a class="reference internal" href="#c.psa_mac_abort" title="psa_mac_abort"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_abort()</span></code></a>.</li>
+</ul>
+</div>
+<div class="section" id="psa_mac_verify_setup">
+<span id="c.psa_mac_verify_setup"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_mac_verify_setup</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_mac_verify_setup</span><span class="p">(</span><span class="n">psa_mac_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="n">psa_key_handle_t</span> <span class="n">handle</span><span class="p">,</span>
+ <span class="n">psa_algorithm_t</span> <span class="n">alg</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>The operation object to set up. It must have been initialized as per the documentation for <a class="reference internal" href="#c.psa_mac_operation_t" title="psa_mac_operation_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_mac_operation_t</span></code></a> and not yet in use.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">handle</span></code></dt>
+<dd>Handle to the key to use for the operation. It must remain valid until the operation terminates.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>The MAC algorithm to compute (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_MAC" title="PSA_ALG_IS_MAC"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_MAC</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_HANDLE" title="PSA_ERROR_INVALID_HANDLE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_HANDLE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_DOES_NOT_EXIST" title="PSA_ERROR_DOES_NOT_EXIST"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_DOES_NOT_EXIST</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_PERMITTED" title="PSA_ERROR_NOT_PERMITTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_PERMITTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">key</span></code> is not compatible with <code class="docutils literal notranslate"><span class="pre">alg</span></code>.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_SUPPORTED" title="PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">alg</span></code> is not supported or is not a MAC algorithm.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The operation state is not valid (already set up and not subsequently completed).</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The library has not been previously initialized by <a class="reference internal" href="#c.psa_crypto_init" title="psa_crypto_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_crypto_init()</span></code></a>. It is implementation-dependent whether a failure to initialize results in this error code.</dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Set up a multipart MAC verification operation.</p>
+<p>This function sets up the verification of the MAC (message authentication code) of a byte string against an expected value.</p>
+<p>The sequence of operations to verify a MAC is as follows:</p>
+<ol class="arabic simple">
+<li>Allocate an operation object which will be passed to all the functions listed here.</li>
+<li>Initialize the operation object with one of the methods described in the documentation for <a class="reference internal" href="#c.psa_mac_operation_t" title="psa_mac_operation_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_mac_operation_t</span></code></a>, e.g. PSA_MAC_OPERATION_INIT.</li>
+<li>Call <a class="reference internal" href="#c.psa_mac_verify_setup" title="psa_mac_verify_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_verify_setup()</span></code></a> to specify the algorithm and key.</li>
+<li>Call <a class="reference internal" href="#c.psa_mac_update" title="psa_mac_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_update()</span></code></a> zero, one or more times, passing a fragment of the message each time. The MAC that is calculated is the MAC of the concatenation of these messages in order.</li>
+<li>At the end of the message, call <a class="reference internal" href="#c.psa_mac_verify_finish" title="psa_mac_verify_finish"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_verify_finish()</span></code></a> to finish calculating the actual MAC of the message and verify it against the expected value.</li>
+</ol>
+<p>The application may call <a class="reference internal" href="#c.psa_mac_abort" title="psa_mac_abort"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_abort()</span></code></a> at any time after the operation has been initialized.</p>
+<p>After a successful call to <a class="reference internal" href="#c.psa_mac_verify_setup" title="psa_mac_verify_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_verify_setup()</span></code></a>, the application must eventually terminate the operation through one of the following methods:</p>
+<ul class="simple">
+<li>A failed call to <a class="reference internal" href="#c.psa_mac_update" title="psa_mac_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_update()</span></code></a>.</li>
+<li>A call to <a class="reference internal" href="#c.psa_mac_verify_finish" title="psa_mac_verify_finish"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_verify_finish()</span></code></a> or <a class="reference internal" href="#c.psa_mac_abort" title="psa_mac_abort"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_abort()</span></code></a>.</li>
+</ul>
+</div>
+<div class="section" id="psa_mac_update">
+<span id="c.psa_mac_update"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_mac_update</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_mac_update</span><span class="p">(</span><span class="n">psa_mac_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">input</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">input_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>Active MAC operation.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">input</span></code></dt>
+<dd>Buffer containing the message fragment to add to the MAC calculation.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">input_length</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">input</span></code> buffer in bytes.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The operation state is not valid (not set up, or already completed).</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Add a message fragment to a multipart MAC operation.</p>
+<p>The application must call <a class="reference internal" href="#c.psa_mac_sign_setup" title="psa_mac_sign_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_sign_setup()</span></code></a> or <a class="reference internal" href="#c.psa_mac_verify_setup" title="psa_mac_verify_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_verify_setup()</span></code></a> before calling this function.</p>
+<p>If this function returns an error status, the operation becomes inactive.</p>
+</div>
+<div class="section" id="psa_mac_sign_finish">
+<span id="c.psa_mac_sign_finish"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_mac_sign_finish</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_mac_sign_finish</span><span class="p">(</span><span class="n">psa_mac_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">mac</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">mac_size</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="o">*</span> <span class="n">mac_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>Active MAC operation.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">mac</span></code></dt>
+<dd>Buffer where the MAC value is to be written.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">mac_size</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">mac</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">mac_length</span></code></dt>
+<dd>On success, the number of bytes that make up the MAC value. This is always <a class="reference internal" href="#c.PSA_MAC_FINAL_SIZE" title="PSA_MAC_FINAL_SIZE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_MAC_FINAL_SIZE</span></code></a>(<code class="docutils literal notranslate"><span class="pre">key_type</span></code>, <code class="docutils literal notranslate"><span class="pre">key_bits</span></code>, <code class="docutils literal notranslate"><span class="pre">alg</span></code>) where <code class="docutils literal notranslate"><span class="pre">key_type</span></code> and <code class="docutils literal notranslate"><span class="pre">key_bits</span></code> are the type and bit-size respectively of the key and <code class="docutils literal notranslate"><span class="pre">alg</span></code> is the MAC algorithm that is calculated.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The operation state is not valid (not set up, or already completed).</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BUFFER_TOO_SMALL" title="PSA_ERROR_BUFFER_TOO_SMALL"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BUFFER_TOO_SMALL</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The size of the <code class="docutils literal notranslate"><span class="pre">mac</span></code> buffer is too small. You can determine a sufficient buffer size by calling <a class="reference internal" href="#c.PSA_MAC_FINAL_SIZE" title="PSA_MAC_FINAL_SIZE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_MAC_FINAL_SIZE()</span></code></a>.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Finish the calculation of the MAC of a message.</p>
+<p>The application must call <a class="reference internal" href="#c.psa_mac_sign_setup" title="psa_mac_sign_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_sign_setup()</span></code></a> before calling this function. This function calculates the MAC of the message formed by concatenating the inputs passed to preceding calls to <a class="reference internal" href="#c.psa_mac_update" title="psa_mac_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_update()</span></code></a>.</p>
+<p>When this function returns, the operation becomes inactive.</p>
+<div class="admonition warning">
+<p class="first admonition-title">Warning</p>
+<p class="last">Applications should not call this function if they expect a specific value for the MAC. Call <a class="reference internal" href="#c.psa_mac_verify_finish" title="psa_mac_verify_finish"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_verify_finish()</span></code></a> instead. Beware that comparing integrity or authenticity data such as MAC values with a function such as <code class="docutils literal notranslate"><span class="pre">memcmp</span></code> is risky because the time taken by the comparison may leak information about the MAC value which could allow an attacker to guess a valid MAC and thereby bypass security controls.</p>
+</div>
+</div>
+<div class="section" id="psa_mac_verify_finish">
+<span id="c.psa_mac_verify_finish"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_mac_verify_finish</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_mac_verify_finish</span><span class="p">(</span><span class="n">psa_mac_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">mac</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">mac_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>Active MAC operation.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">mac</span></code></dt>
+<dd>Buffer containing the expected MAC value.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">mac_length</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">mac</span></code> buffer in bytes.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The expected MAC is identical to the actual MAC of the message.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_SIGNATURE" title="PSA_ERROR_INVALID_SIGNATURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_SIGNATURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The MAC of the message was calculated successfully, but it differs from the expected MAC.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The operation state is not valid (not set up, or already completed).</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Finish the calculation of the MAC of a message and compare it with an expected value.</p>
+<p>The application must call <a class="reference internal" href="#c.psa_mac_verify_setup" title="psa_mac_verify_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_verify_setup()</span></code></a> before calling this function. This function calculates the MAC of the message formed by concatenating the inputs passed to preceding calls to <a class="reference internal" href="#c.psa_mac_update" title="psa_mac_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_update()</span></code></a>. It then compares the calculated MAC with the expected MAC passed as a parameter to this function.</p>
+<p>When this function returns, the operation becomes inactive.</p>
+<div class="admonition note">
+<p class="first admonition-title">Note</p>
+<p class="last">Implementations shall make the best effort to ensure that the comparison between the actual MAC and the expected MAC is performed in constant time.</p>
+</div>
+</div>
+<div class="section" id="psa_mac_abort">
+<span id="c.psa_mac_abort"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_mac_abort</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_mac_abort</span><span class="p">(</span><span class="n">psa_mac_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>Initialized MAC operation.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">operation</span></code> is not an active MAC operation.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Abort a MAC operation.</p>
+<p>Aborting an operation frees all associated resources except for the <code class="docutils literal notranslate"><span class="pre">operation</span></code> structure itself. Once aborted, the operation object can be reused for another operation by calling <a class="reference internal" href="#c.psa_mac_sign_setup" title="psa_mac_sign_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_sign_setup()</span></code></a> or <a class="reference internal" href="#c.psa_mac_verify_setup" title="psa_mac_verify_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_verify_setup()</span></code></a> again.</p>
+<p>You may call this function any time after the operation object has been initialized by any of the following methods:</p>
+<ul class="simple">
+<li>A call to <a class="reference internal" href="#c.psa_mac_sign_setup" title="psa_mac_sign_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_sign_setup()</span></code></a> or <a class="reference internal" href="#c.psa_mac_verify_setup" title="psa_mac_verify_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_verify_setup()</span></code></a>, whether it succeeds or not.</li>
+<li>Initializing the <code class="docutils literal notranslate"><span class="pre">struct</span></code> to all-bits-zero.</li>
+<li>Initializing the <code class="docutils literal notranslate"><span class="pre">struct</span></code> to logical zeros, e.g. <code class="docutils literal notranslate"><span class="pre">psa_mac_operation_t</span> <span class="pre">operation</span> <span class="pre">=</span> <span class="pre">{0}</span></code>.</li>
+</ul>
+<p>In particular, calling <a class="reference internal" href="#c.psa_mac_abort" title="psa_mac_abort"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_abort()</span></code></a> after the operation has been terminated by a call to <a class="reference internal" href="#c.psa_mac_abort" title="psa_mac_abort"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_abort()</span></code></a>, <a class="reference internal" href="#c.psa_mac_sign_finish" title="psa_mac_sign_finish"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_sign_finish()</span></code></a> or <a class="reference internal" href="#c.psa_mac_verify_finish" title="psa_mac_verify_finish"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_verify_finish()</span></code></a> is safe and has no effect.</p>
+</div>
+</div>
+<div class="section" id="symmetric-ciphers">
+<h1>Symmetric ciphers</h1>
+<div class="section" id="psa_cipher_operation_t">
+<span id="c.psa_cipher_operation_t"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_cipher_operation_t</span></code> (type)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="k">typedef</span> <span class="k">struct</span> <span class="n">psa_cipher_operation_s</span> <span class="n">psa_cipher_operation_t</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>The type of the state data structure for multipart cipher operations.</p>
+<p>Before calling any function on a cipher operation object, the application must initialize it by any of the following means:</p>
+<ul>
+<li><p class="first">Set the structure to all-bits-zero, for example:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_cipher_operation_t</span> <span class="n">operation</span><span class="p">;</span>
+<span class="n">memset</span><span class="p">(</span><span class="o">&</span><span class="n">operation</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="k">sizeof</span><span class="p">(</span><span class="n">operation</span><span class="p">));</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first">Initialize the structure to logical zero values, for example:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_cipher_operation_t</span> <span class="n">operation</span> <span class="o">=</span> <span class="p">{</span><span class="mi">0</span><span class="p">};</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first">Initialize the structure to the initializer <a class="reference internal" href="#c.PSA_CIPHER_OPERATION_INIT" title="PSA_CIPHER_OPERATION_INIT"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_CIPHER_OPERATION_INIT</span></code></a>, for example:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_cipher_operation_t</span> <span class="n">operation</span> <span class="o">=</span> <span class="n">PSA_CIPHER_OPERATION_INIT</span><span class="p">;</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first">Assign the result of the function <a class="reference internal" href="#c.psa_cipher_operation_init" title="psa_cipher_operation_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_operation_init()</span></code></a> to the structure, for example:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_cipher_operation_t</span> <span class="n">operation</span><span class="p">;</span>
+<span class="n">operation</span> <span class="o">=</span> <span class="n">psa_cipher_operation_init</span><span class="p">();</span>
+</pre></div>
+</div>
+</li>
+</ul>
+<p>This is an implementation-defined <code class="docutils literal notranslate"><span class="pre">struct</span></code>. Applications should not make any assumptions about the content of this structure except as directed by the documentation of a specific implementation.</p>
+</div>
+<div class="section" id="PSA_CIPHER_OPERATION_INIT">
+<span id="c.PSA_CIPHER_OPERATION_INIT"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_CIPHER_OPERATION_INIT</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_CIPHER_OPERATION_INIT {0}</span>
+</pre></div>
+</div>
+<p>This macro returns a suitable initializer for a cipher operation object of type <a class="reference internal" href="#c.psa_cipher_operation_t" title="psa_cipher_operation_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_cipher_operation_t</span></code></a>.</p>
+</div>
+<div class="section" id="psa_cipher_encrypt">
+<span id="c.psa_cipher_encrypt"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_cipher_encrypt</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_cipher_encrypt</span><span class="p">(</span><span class="n">psa_key_handle_t</span> <span class="n">handle</span><span class="p">,</span>
+ <span class="n">psa_algorithm_t</span> <span class="n">alg</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">input</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">input_length</span><span class="p">,</span>
+ <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">output</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">output_size</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="o">*</span> <span class="n">output_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">handle</span></code></dt>
+<dd>Handle to the key to use for the operation. It must remain valid until the operation terminates.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>The cipher algorithm to compute (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_CIPHER" title="PSA_ALG_IS_CIPHER"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_CIPHER</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true).</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">input</span></code></dt>
+<dd>Buffer containing the message to encrypt.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">input_length</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">input</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">output</span></code></dt>
+<dd>Buffer where the output is to be written. The output contains the IV followed by the ciphertext proper.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">output_size</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">output</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">output_length</span></code></dt>
+<dd>On success, the number of bytes that make up the output.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_HANDLE" title="PSA_ERROR_INVALID_HANDLE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_HANDLE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_PERMITTED" title="PSA_ERROR_NOT_PERMITTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_PERMITTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">handle</span></code> is not compatible with <code class="docutils literal notranslate"><span class="pre">alg</span></code>.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_SUPPORTED" title="PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">alg</span></code> is not supported or is not a cipher algorithm.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BUFFER_TOO_SMALL" title="PSA_ERROR_BUFFER_TOO_SMALL"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BUFFER_TOO_SMALL</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Encrypt a message using a symmetric cipher.</p>
+<p>This function encrypts a message with a random IV (initialization vector).</p>
+</div>
+<div class="section" id="psa_cipher_decrypt">
+<span id="c.psa_cipher_decrypt"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_cipher_decrypt</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_cipher_decrypt</span><span class="p">(</span><span class="n">psa_key_handle_t</span> <span class="n">handle</span><span class="p">,</span>
+ <span class="n">psa_algorithm_t</span> <span class="n">alg</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">input</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">input_length</span><span class="p">,</span>
+ <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">output</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">output_size</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="o">*</span> <span class="n">output_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">handle</span></code></dt>
+<dd>Handle to the key to use for the operation. It must remain valid until the operation terminates.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>The cipher algorithm to compute (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_CIPHER" title="PSA_ALG_IS_CIPHER"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_CIPHER</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true).</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">input</span></code></dt>
+<dd>Buffer containing the message to decrypt. This consists of the IV followed by the ciphertext proper.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">input_length</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">input</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">output</span></code></dt>
+<dd>Buffer where the plaintext is to be written.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">output_size</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">output</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">output_length</span></code></dt>
+<dd>On success, the number of bytes that make up the output.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_HANDLE" title="PSA_ERROR_INVALID_HANDLE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_HANDLE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_PERMITTED" title="PSA_ERROR_NOT_PERMITTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_PERMITTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">handle</span></code> is not compatible with <code class="docutils literal notranslate"><span class="pre">alg</span></code>.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_SUPPORTED" title="PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">alg</span></code> is not supported or is not a cipher algorithm.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BUFFER_TOO_SMALL" title="PSA_ERROR_BUFFER_TOO_SMALL"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BUFFER_TOO_SMALL</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Decrypt a message using a symmetric cipher.</p>
+<p>This function decrypts a message encrypted with a symmetric cipher.</p>
+</div>
+<div class="section" id="psa_cipher_operation_init">
+<span id="c.psa_cipher_operation_init"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_cipher_operation_init</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_cipher_operation_t</span> <span class="nf">psa_cipher_operation_init</span><span class="p">(</span><span class="kt">void</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_cipher_operation_t" title="psa_cipher_operation_t"><code class="docutils literal notranslate"><span class="pre">psa_cipher_operation_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Return an initial value for a cipher operation object.</p>
+</div>
+<div class="section" id="psa_cipher_encrypt_setup">
+<span id="c.psa_cipher_encrypt_setup"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_cipher_encrypt_setup</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_cipher_encrypt_setup</span><span class="p">(</span><span class="n">psa_cipher_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="n">psa_key_handle_t</span> <span class="n">handle</span><span class="p">,</span>
+ <span class="n">psa_algorithm_t</span> <span class="n">alg</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>The operation object to set up. It must have been initialized as per the documentation for <a class="reference internal" href="#c.psa_cipher_operation_t" title="psa_cipher_operation_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_cipher_operation_t</span></code></a> and not yet in use.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">handle</span></code></dt>
+<dd>Handle to the key to use for the operation. It must remain valid until the operation terminates.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>The cipher algorithm to compute (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_CIPHER" title="PSA_ALG_IS_CIPHER"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_CIPHER</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_HANDLE" title="PSA_ERROR_INVALID_HANDLE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_HANDLE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_DOES_NOT_EXIST" title="PSA_ERROR_DOES_NOT_EXIST"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_DOES_NOT_EXIST</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_PERMITTED" title="PSA_ERROR_NOT_PERMITTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_PERMITTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">handle</span></code> is not compatible with <code class="docutils literal notranslate"><span class="pre">alg</span></code>.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_SUPPORTED" title="PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">alg</span></code> is not supported or is not a cipher algorithm.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The operation state is not valid (already set up and not subsequently completed).</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The library has not been previously initialized by <a class="reference internal" href="#c.psa_crypto_init" title="psa_crypto_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_crypto_init()</span></code></a>. It is implementation-dependent whether a failure to initialize results in this error code.</dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Set the key for a multipart symmetric encryption operation.</p>
+<p>The sequence of operations to encrypt a message with a symmetric cipher is as follows:</p>
+<ol class="arabic simple">
+<li>Allocate an operation object which will be passed to all the functions listed here.</li>
+<li>Initialize the operation object with one of the methods described in the documentation for <a class="reference internal" href="#c.psa_cipher_operation_t" title="psa_cipher_operation_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_cipher_operation_t</span></code></a>, e.g. PSA_CIPHER_OPERATION_INIT.</li>
+<li>Call <a class="reference internal" href="#c.psa_cipher_encrypt_setup" title="psa_cipher_encrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_encrypt_setup()</span></code></a> to specify the algorithm and key.</li>
+<li>Call either <a class="reference internal" href="#c.psa_cipher_generate_iv" title="psa_cipher_generate_iv"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_generate_iv()</span></code></a> or <a class="reference internal" href="#c.psa_cipher_set_iv" title="psa_cipher_set_iv"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_set_iv()</span></code></a> to generate or set the IV (initialization vector). You should use <a class="reference internal" href="#c.psa_cipher_generate_iv" title="psa_cipher_generate_iv"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_generate_iv()</span></code></a> unless the protocol you are implementing requires a specific IV value.</li>
+<li>Call <a class="reference internal" href="#c.psa_cipher_update" title="psa_cipher_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_update()</span></code></a> zero, one or more times, passing a fragment of the message each time.</li>
+<li>Call <a class="reference internal" href="#c.psa_cipher_finish" title="psa_cipher_finish"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_finish()</span></code></a>.</li>
+</ol>
+<p>The application may call <a class="reference internal" href="#c.psa_cipher_abort" title="psa_cipher_abort"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_abort()</span></code></a> at any time after the operation has been initialized.</p>
+<p>After a successful call to <a class="reference internal" href="#c.psa_cipher_encrypt_setup" title="psa_cipher_encrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_encrypt_setup()</span></code></a>, the application must eventually terminate the operation. The following events terminate an operation:</p>
+<ul class="simple">
+<li>A failed call to any of the <code class="docutils literal notranslate"><span class="pre">psa_cipher_xxx</span></code> functions.</li>
+<li>A call to <a class="reference internal" href="#c.psa_cipher_finish" title="psa_cipher_finish"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_finish()</span></code></a> or <a class="reference internal" href="#c.psa_cipher_abort" title="psa_cipher_abort"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_abort()</span></code></a>.</li>
+</ul>
+</div>
+<div class="section" id="psa_cipher_decrypt_setup">
+<span id="c.psa_cipher_decrypt_setup"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_cipher_decrypt_setup</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_cipher_decrypt_setup</span><span class="p">(</span><span class="n">psa_cipher_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="n">psa_key_handle_t</span> <span class="n">handle</span><span class="p">,</span>
+ <span class="n">psa_algorithm_t</span> <span class="n">alg</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>The operation object to set up. It must have been initialized as per the documentation for <a class="reference internal" href="#c.psa_cipher_operation_t" title="psa_cipher_operation_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_cipher_operation_t</span></code></a> and not yet in use.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">handle</span></code></dt>
+<dd>Handle to the key to use for the operation. It must remain valid until the operation terminates.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>The cipher algorithm to compute (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_CIPHER" title="PSA_ALG_IS_CIPHER"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_CIPHER</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_HANDLE" title="PSA_ERROR_INVALID_HANDLE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_HANDLE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_DOES_NOT_EXIST" title="PSA_ERROR_DOES_NOT_EXIST"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_DOES_NOT_EXIST</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_PERMITTED" title="PSA_ERROR_NOT_PERMITTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_PERMITTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">handle</span></code> is not compatible with <code class="docutils literal notranslate"><span class="pre">alg</span></code>.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_SUPPORTED" title="PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">alg</span></code> is not supported or is not a cipher algorithm.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The operation state is not valid (already set up and not subsequently completed).</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The library has not been previously initialized by <a class="reference internal" href="#c.psa_crypto_init" title="psa_crypto_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_crypto_init()</span></code></a>. It is implementation-dependent whether a failure to initialize results in this error code.</dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Set the key for a multipart symmetric decryption operation.</p>
+<p>The sequence of operations to decrypt a message with a symmetric cipher is as follows:</p>
+<ol class="arabic simple">
+<li>Allocate an operation object which will be passed to all the functions listed here.</li>
+<li>Initialize the operation object with one of the methods described in the documentation for <a class="reference internal" href="#c.psa_cipher_operation_t" title="psa_cipher_operation_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_cipher_operation_t</span></code></a>, e.g. PSA_CIPHER_OPERATION_INIT.</li>
+<li>Call <a class="reference internal" href="#c.psa_cipher_decrypt_setup" title="psa_cipher_decrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_decrypt_setup()</span></code></a> to specify the algorithm and key.</li>
+<li>Call <a class="reference internal" href="#c.psa_cipher_set_iv" title="psa_cipher_set_iv"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_set_iv()</span></code></a> with the IV (initialization vector) for the decryption. If the IV is prepended to the ciphertext, you can call <a class="reference internal" href="#c.psa_cipher_update" title="psa_cipher_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_update()</span></code></a> on a buffer containing the IV followed by the beginning of the message.</li>
+<li>Call <a class="reference internal" href="#c.psa_cipher_update" title="psa_cipher_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_update()</span></code></a> zero, one or more times, passing a fragment of the message each time.</li>
+<li>Call <a class="reference internal" href="#c.psa_cipher_finish" title="psa_cipher_finish"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_finish()</span></code></a>.</li>
+</ol>
+<p>The application may call <a class="reference internal" href="#c.psa_cipher_abort" title="psa_cipher_abort"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_abort()</span></code></a> at any time after the operation has been initialized.</p>
+<p>After a successful call to <a class="reference internal" href="#c.psa_cipher_decrypt_setup" title="psa_cipher_decrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_decrypt_setup()</span></code></a>, the application must eventually terminate the operation. The following events terminate an operation:</p>
+<ul class="simple">
+<li>A failed call to any of the <code class="docutils literal notranslate"><span class="pre">psa_cipher_xxx</span></code> functions.</li>
+<li>A call to <a class="reference internal" href="#c.psa_cipher_finish" title="psa_cipher_finish"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_finish()</span></code></a> or <a class="reference internal" href="#c.psa_cipher_abort" title="psa_cipher_abort"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_abort()</span></code></a>.</li>
+</ul>
+</div>
+<div class="section" id="psa_cipher_generate_iv">
+<span id="c.psa_cipher_generate_iv"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_cipher_generate_iv</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_cipher_generate_iv</span><span class="p">(</span><span class="n">psa_cipher_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="kt">unsigned</span> <span class="kt">char</span> <span class="o">*</span> <span class="n">iv</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">iv_size</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="o">*</span> <span class="n">iv_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>Active cipher operation.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">iv</span></code></dt>
+<dd>Buffer where the generated IV is to be written.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">iv_size</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">iv</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">iv_length</span></code></dt>
+<dd>On success, the number of bytes of the generated IV.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The operation state is not valid (not set up, or IV already set).</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BUFFER_TOO_SMALL" title="PSA_ERROR_BUFFER_TOO_SMALL"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BUFFER_TOO_SMALL</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The size of the <code class="docutils literal notranslate"><span class="pre">iv</span></code> buffer is too small.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Generate an IV for a symmetric encryption operation.</p>
+<p>This function generates a random IV (initialization vector), nonce or initial counter value for the encryption operation as appropriate for the chosen algorithm, key type and key size.</p>
+<p>The application must call <a class="reference internal" href="#c.psa_cipher_encrypt_setup" title="psa_cipher_encrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_encrypt_setup()</span></code></a> before calling this function.</p>
+<p>If this function returns an error status, the operation becomes inactive.</p>
+</div>
+<div class="section" id="psa_cipher_set_iv">
+<span id="c.psa_cipher_set_iv"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_cipher_set_iv</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_cipher_set_iv</span><span class="p">(</span><span class="n">psa_cipher_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">unsigned</span> <span class="kt">char</span> <span class="o">*</span> <span class="n">iv</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">iv_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>Active cipher operation.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">iv</span></code></dt>
+<dd>Buffer containing the IV to use.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">iv_length</span></code></dt>
+<dd>Size of the IV in bytes.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The operation state is not valid (not set up, or IV already set).</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The size of <code class="docutils literal notranslate"><span class="pre">iv</span></code> is not acceptable for the chosen algorithm, or the chosen algorithm does not use an IV.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Set the IV for a symmetric encryption or decryption operation.</p>
+<p>This function sets the IV (initialization vector), nonce or initial counter value for the encryption or decryption operation.</p>
+<p>The application must call <a class="reference internal" href="#c.psa_cipher_encrypt_setup" title="psa_cipher_encrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_encrypt_setup()</span></code></a> before calling this function.</p>
+<p>If this function returns an error status, the operation becomes inactive.</p>
+<div class="admonition note">
+<p class="first admonition-title">Note</p>
+<p class="last">When encrypting, applications should use <a class="reference internal" href="#c.psa_cipher_generate_iv" title="psa_cipher_generate_iv"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_generate_iv()</span></code></a> instead of this function, unless implementing a protocol that requires a non-random IV.</p>
+</div>
+</div>
+<div class="section" id="psa_cipher_update">
+<span id="c.psa_cipher_update"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_cipher_update</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_cipher_update</span><span class="p">(</span><span class="n">psa_cipher_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">input</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">input_length</span><span class="p">,</span>
+ <span class="kt">unsigned</span> <span class="kt">char</span> <span class="o">*</span> <span class="n">output</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">output_size</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="o">*</span> <span class="n">output_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>Active cipher operation.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">input</span></code></dt>
+<dd>Buffer containing the message fragment to encrypt or decrypt.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">input_length</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">input</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">output</span></code></dt>
+<dd>Buffer where the output is to be written.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">output_size</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">output</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">output_length</span></code></dt>
+<dd>On success, the number of bytes that make up the returned output.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The operation state is not valid (not set up, IV required but not set, or already completed).</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BUFFER_TOO_SMALL" title="PSA_ERROR_BUFFER_TOO_SMALL"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BUFFER_TOO_SMALL</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The size of the <code class="docutils literal notranslate"><span class="pre">output</span></code> buffer is too small.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Encrypt or decrypt a message fragment in an active cipher operation.</p>
+<p>Before calling this function, you must:</p>
+<ol class="arabic simple">
+<li>Call either <a class="reference internal" href="#c.psa_cipher_encrypt_setup" title="psa_cipher_encrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_encrypt_setup()</span></code></a> or <a class="reference internal" href="#c.psa_cipher_decrypt_setup" title="psa_cipher_decrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_decrypt_setup()</span></code></a>. The choice of setup function determines whether this function encrypts or decrypts its input.</li>
+<li>If the algorithm requires an IV, call <a class="reference internal" href="#c.psa_cipher_generate_iv" title="psa_cipher_generate_iv"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_generate_iv()</span></code></a> (recommended when encrypting) or <a class="reference internal" href="#c.psa_cipher_set_iv" title="psa_cipher_set_iv"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_set_iv()</span></code></a>.</li>
+</ol>
+<p>If this function returns an error status, the operation becomes inactive.</p>
+</div>
+<div class="section" id="psa_cipher_finish">
+<span id="c.psa_cipher_finish"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_cipher_finish</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_cipher_finish</span><span class="p">(</span><span class="n">psa_cipher_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">output</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">output_size</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="o">*</span> <span class="n">output_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>Active cipher operation.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">output</span></code></dt>
+<dd>Buffer where the output is to be written.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">output_size</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">output</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">output_length</span></code></dt>
+<dd>On success, the number of bytes that make up the returned output.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The operation state is not valid (not set up, IV required but not set, or already completed).</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BUFFER_TOO_SMALL" title="PSA_ERROR_BUFFER_TOO_SMALL"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BUFFER_TOO_SMALL</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The size of the <code class="docutils literal notranslate"><span class="pre">output</span></code> buffer is too small.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Finish encrypting or decrypting a message in a cipher operation.</p>
+<p>The application must call <a class="reference internal" href="#c.psa_cipher_encrypt_setup" title="psa_cipher_encrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_encrypt_setup()</span></code></a> or <a class="reference internal" href="#c.psa_cipher_decrypt_setup" title="psa_cipher_decrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_decrypt_setup()</span></code></a> before calling this function. The choice of setup function determines whether this function encrypts or decrypts its input.</p>
+<p>This function finishes the encryption or decryption of the message formed by concatenating the inputs passed to preceding calls to <a class="reference internal" href="#c.psa_cipher_update" title="psa_cipher_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_update()</span></code></a>.</p>
+<p>When this function returns, the operation becomes inactive.</p>
+</div>
+<div class="section" id="psa_cipher_abort">
+<span id="c.psa_cipher_abort"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_cipher_abort</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_cipher_abort</span><span class="p">(</span><span class="n">psa_cipher_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>Initialized cipher operation.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">operation</span></code> is not an active cipher operation.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Abort a cipher operation.</p>
+<p>Aborting an operation frees all associated resources except for the <code class="docutils literal notranslate"><span class="pre">operation</span></code> structure itself. Once aborted, the operation object can be reused for another operation by calling <a class="reference internal" href="#c.psa_cipher_encrypt_setup" title="psa_cipher_encrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_encrypt_setup()</span></code></a> or <a class="reference internal" href="#c.psa_cipher_decrypt_setup" title="psa_cipher_decrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_decrypt_setup()</span></code></a> again.</p>
+<p>You may call this function any time after the operation object has been initialized by any of the following methods:</p>
+<ul class="simple">
+<li>A call to <a class="reference internal" href="#c.psa_cipher_encrypt_setup" title="psa_cipher_encrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_encrypt_setup()</span></code></a> or <a class="reference internal" href="#c.psa_cipher_decrypt_setup" title="psa_cipher_decrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_decrypt_setup()</span></code></a>, whether it succeeds or not.</li>
+<li>Initializing the <code class="docutils literal notranslate"><span class="pre">struct</span></code> to all-bits-zero.</li>
+<li>Initializing the <code class="docutils literal notranslate"><span class="pre">struct</span></code> to logical zeros, e.g. <code class="docutils literal notranslate"><span class="pre">psa_cipher_operation_t</span> <span class="pre">operation</span> <span class="pre">=</span> <span class="pre">{0}</span></code>.</li>
+</ul>
+<p>In particular, calling <a class="reference internal" href="#c.psa_cipher_abort" title="psa_cipher_abort"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_abort()</span></code></a> after the operation has been terminated by a call to <a class="reference internal" href="#c.psa_cipher_abort" title="psa_cipher_abort"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_abort()</span></code></a> or <a class="reference internal" href="#c.psa_cipher_finish" title="psa_cipher_finish"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_finish()</span></code></a> is safe and has no effect.</p>
+</div>
+</div>
+<div class="section" id="authenticated-encryption-with-associated-data-aead">
+<h1>Authenticated encryption with associated data (AEAD)</h1>
+<div class="section" id="psa_aead_operation_t">
+<span id="c.psa_aead_operation_t"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_aead_operation_t</span></code> (type)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="k">typedef</span> <span class="k">struct</span> <span class="n">psa_aead_operation_s</span> <span class="n">psa_aead_operation_t</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>The type of the state data structure for multipart AEAD operations.</p>
+<p>Before calling any function on an AEAD operation object, the application must initialize it by any of the following means:</p>
+<ul>
+<li><p class="first">Set the structure to all-bits-zero, for example:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_aead_operation_t</span> <span class="n">operation</span><span class="p">;</span>
+<span class="n">memset</span><span class="p">(</span><span class="o">&</span><span class="n">operation</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="k">sizeof</span><span class="p">(</span><span class="n">operation</span><span class="p">));</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first">Initialize the structure to logical zero values, for example:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_aead_operation_t</span> <span class="n">operation</span> <span class="o">=</span> <span class="p">{</span><span class="mi">0</span><span class="p">};</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first">Initialize the structure to the initializer <a class="reference internal" href="#c.PSA_AEAD_OPERATION_INIT" title="PSA_AEAD_OPERATION_INIT"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_AEAD_OPERATION_INIT</span></code></a>, for example:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_aead_operation_t</span> <span class="n">operation</span> <span class="o">=</span> <span class="n">PSA_AEAD_OPERATION_INIT</span><span class="p">;</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first">Assign the result of the function <a class="reference internal" href="#c.psa_aead_operation_init" title="psa_aead_operation_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_operation_init()</span></code></a> to the structure, for example:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_aead_operation_t</span> <span class="n">operation</span><span class="p">;</span>
+<span class="n">operation</span> <span class="o">=</span> <span class="n">psa_aead_operation_init</span><span class="p">();</span>
+</pre></div>
+</div>
+</li>
+</ul>
+<p>This is an implementation-defined <code class="docutils literal notranslate"><span class="pre">struct</span></code>. Applications should not make any assumptions about the content of this structure except as directed by the documentation of a specific implementation.</p>
+</div>
+<div class="section" id="PSA_AEAD_OPERATION_INIT">
+<span id="c.PSA_AEAD_OPERATION_INIT"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_AEAD_OPERATION_INIT</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_AEAD_OPERATION_INIT {0}</span>
+</pre></div>
+</div>
+<p>This macro returns a suitable initializer for an AEAD operation object of type <a class="reference internal" href="#c.psa_aead_operation_t" title="psa_aead_operation_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_aead_operation_t</span></code></a>.</p>
+</div>
+<div class="section" id="psa_aead_encrypt">
+<span id="c.psa_aead_encrypt"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_aead_encrypt</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_aead_encrypt</span><span class="p">(</span><span class="n">psa_key_handle_t</span> <span class="n">handle</span><span class="p">,</span>
+ <span class="n">psa_algorithm_t</span> <span class="n">alg</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">nonce</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">nonce_length</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">additional_data</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">additional_data_length</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">plaintext</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">plaintext_length</span><span class="p">,</span>
+ <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">ciphertext</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">ciphertext_size</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="o">*</span> <span class="n">ciphertext_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">handle</span></code></dt>
+<dd>Handle to the key to use for the operation.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>The AEAD algorithm to compute (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_AEAD" title="PSA_ALG_IS_AEAD"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_AEAD</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true).</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">nonce</span></code></dt>
+<dd>Nonce or IV to use.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">nonce_length</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">nonce</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">additional_data</span></code></dt>
+<dd>Additional data that will be authenticated but not encrypted.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">additional_data_length</span></code></dt>
+<dd>Size of <code class="docutils literal notranslate"><span class="pre">additional_data</span></code> in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">plaintext</span></code></dt>
+<dd>Data that will be authenticated and encrypted.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">plaintext_length</span></code></dt>
+<dd>Size of <code class="docutils literal notranslate"><span class="pre">plaintext</span></code> in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">ciphertext</span></code></dt>
+<dd>Output buffer for the authenticated and encrypted data. The additional data is not part of this output. For algorithms where the encrypted data and the authentication tag are defined as separate outputs, the authentication tag is appended to the encrypted data.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">ciphertext_size</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">ciphertext</span></code> buffer in bytes. This must be at least <a class="reference internal" href="#c.PSA_AEAD_ENCRYPT_OUTPUT_SIZE" title="PSA_AEAD_ENCRYPT_OUTPUT_SIZE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_AEAD_ENCRYPT_OUTPUT_SIZE</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>, <code class="docutils literal notranslate"><span class="pre">plaintext_length</span></code>).</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">ciphertext_length</span></code></dt>
+<dd>On success, the size of the output in the <code class="docutils literal notranslate"><span class="pre">ciphertext</span></code> buffer.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_HANDLE" title="PSA_ERROR_INVALID_HANDLE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_HANDLE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_DOES_NOT_EXIST" title="PSA_ERROR_DOES_NOT_EXIST"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_DOES_NOT_EXIST</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_PERMITTED" title="PSA_ERROR_NOT_PERMITTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_PERMITTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">handle</span></code> is not compatible with <code class="docutils literal notranslate"><span class="pre">alg</span></code>.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_SUPPORTED" title="PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">alg</span></code> is not supported or is not an AEAD algorithm.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The library has not been previously initialized by <a class="reference internal" href="#c.psa_crypto_init" title="psa_crypto_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_crypto_init()</span></code></a>. It is implementation-dependent whether a failure to initialize results in this error code.</dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Process an authenticated encryption operation.</p>
+</div>
+<div class="section" id="psa_aead_decrypt">
+<span id="c.psa_aead_decrypt"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_aead_decrypt</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_aead_decrypt</span><span class="p">(</span><span class="n">psa_key_handle_t</span> <span class="n">handle</span><span class="p">,</span>
+ <span class="n">psa_algorithm_t</span> <span class="n">alg</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">nonce</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">nonce_length</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">additional_data</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">additional_data_length</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">ciphertext</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">ciphertext_length</span><span class="p">,</span>
+ <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">plaintext</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">plaintext_size</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="o">*</span> <span class="n">plaintext_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">handle</span></code></dt>
+<dd>Handle to the key to use for the operation.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>The AEAD algorithm to compute (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_AEAD" title="PSA_ALG_IS_AEAD"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_AEAD</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true).</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">nonce</span></code></dt>
+<dd>Nonce or IV to use.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">nonce_length</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">nonce</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">additional_data</span></code></dt>
+<dd>Additional data that has been authenticated but not encrypted.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">additional_data_length</span></code></dt>
+<dd>Size of <code class="docutils literal notranslate"><span class="pre">additional_data</span></code> in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">ciphertext</span></code></dt>
+<dd>Data that has been authenticated and encrypted. For algorithms where the encrypted data and the authentication tag are defined as separate inputs, the buffer must contain the encrypted data followed by the authentication tag.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">ciphertext_length</span></code></dt>
+<dd>Size of <code class="docutils literal notranslate"><span class="pre">ciphertext</span></code> in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">plaintext</span></code></dt>
+<dd>Output buffer for the decrypted data.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">plaintext_size</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">plaintext</span></code> buffer in bytes. This must be at least <a class="reference internal" href="#c.PSA_AEAD_DECRYPT_OUTPUT_SIZE" title="PSA_AEAD_DECRYPT_OUTPUT_SIZE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_AEAD_DECRYPT_OUTPUT_SIZE</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>, <code class="docutils literal notranslate"><span class="pre">ciphertext_length</span></code>).</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">plaintext_length</span></code></dt>
+<dd>On success, the size of the output in the <code class="docutils literal notranslate"><span class="pre">plaintext</span></code> buffer.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_HANDLE" title="PSA_ERROR_INVALID_HANDLE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_HANDLE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_DOES_NOT_EXIST" title="PSA_ERROR_DOES_NOT_EXIST"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_DOES_NOT_EXIST</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_SIGNATURE" title="PSA_ERROR_INVALID_SIGNATURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_SIGNATURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The ciphertext is not authentic.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_PERMITTED" title="PSA_ERROR_NOT_PERMITTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_PERMITTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">handle</span></code> is not compatible with <code class="docutils literal notranslate"><span class="pre">alg</span></code>.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_SUPPORTED" title="PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">alg</span></code> is not supported or is not an AEAD algorithm.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The library has not been previously initialized by <a class="reference internal" href="#c.psa_crypto_init" title="psa_crypto_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_crypto_init()</span></code></a>. It is implementation-dependent whether a failure to initialize results in this error code.</dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Process an authenticated decryption operation.</p>
+</div>
+<div class="section" id="psa_aead_operation_init">
+<span id="c.psa_aead_operation_init"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_aead_operation_init</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_aead_operation_t</span> <span class="nf">psa_aead_operation_init</span><span class="p">(</span><span class="kt">void</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_aead_operation_t" title="psa_aead_operation_t"><code class="docutils literal notranslate"><span class="pre">psa_aead_operation_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Return an initial value for an AEAD operation object.</p>
+</div>
+<div class="section" id="psa_aead_encrypt_setup">
+<span id="c.psa_aead_encrypt_setup"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_aead_encrypt_setup</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_aead_encrypt_setup</span><span class="p">(</span><span class="n">psa_aead_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="n">psa_key_handle_t</span> <span class="n">handle</span><span class="p">,</span>
+ <span class="n">psa_algorithm_t</span> <span class="n">alg</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>The operation object to set up. It must have been initialized as per the documentation for <a class="reference internal" href="#c.psa_aead_operation_t" title="psa_aead_operation_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_aead_operation_t</span></code></a> and not yet in use.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">handle</span></code></dt>
+<dd>Handle to the key to use for the operation. It must remain valid until the operation terminates.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>The AEAD algorithm to compute (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_AEAD" title="PSA_ALG_IS_AEAD"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_AEAD</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_HANDLE" title="PSA_ERROR_INVALID_HANDLE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_HANDLE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_PERMITTED" title="PSA_ERROR_NOT_PERMITTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_PERMITTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">handle</span></code> is not compatible with <code class="docutils literal notranslate"><span class="pre">alg</span></code>.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_SUPPORTED" title="PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">alg</span></code> is not supported or is not an AEAD algorithm.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The library has not been previously initialized by <a class="reference internal" href="#c.psa_crypto_init" title="psa_crypto_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_crypto_init()</span></code></a>. It is implementation-dependent whether a failure to initialize results in this error code.</dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Set the key for a multipart authenticated encryption operation.</p>
+<p>The sequence of operations to encrypt a message with authentication is as follows:</p>
+<ol class="arabic simple">
+<li>Allocate an operation object which will be passed to all the functions listed here.</li>
+<li>Initialize the operation object with one of the methods described in the documentation for <a class="reference internal" href="#c.psa_aead_operation_t" title="psa_aead_operation_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_aead_operation_t</span></code></a>, e.g. PSA_AEAD_OPERATION_INIT.</li>
+<li>Call <a class="reference internal" href="#c.psa_aead_encrypt_setup" title="psa_aead_encrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_encrypt_setup()</span></code></a> to specify the algorithm and key.</li>
+<li>If needed, call <a class="reference internal" href="#c.psa_aead_set_lengths" title="psa_aead_set_lengths"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_set_lengths()</span></code></a> to specify the length of the inputs to the subsequent calls to <a class="reference internal" href="#c.psa_aead_update_ad" title="psa_aead_update_ad"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update_ad()</span></code></a> and <a class="reference internal" href="#c.psa_aead_update" title="psa_aead_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update()</span></code></a>. See the documentation of <a class="reference internal" href="#c.psa_aead_set_lengths" title="psa_aead_set_lengths"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_set_lengths()</span></code></a> for details.</li>
+<li>Call either <a class="reference internal" href="#c.psa_aead_generate_nonce" title="psa_aead_generate_nonce"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_generate_nonce()</span></code></a> or <a class="reference internal" href="#c.psa_aead_set_nonce" title="psa_aead_set_nonce"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_set_nonce()</span></code></a> to generate or set the nonce. You should use <a class="reference internal" href="#c.psa_aead_generate_nonce" title="psa_aead_generate_nonce"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_generate_nonce()</span></code></a> unless the protocol you are implementing requires a specific nonce value.</li>
+<li>Call <a class="reference internal" href="#c.psa_aead_update_ad" title="psa_aead_update_ad"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update_ad()</span></code></a> zero, one or more times, passing a fragment of the non-encrypted additional authenticated data each time.</li>
+<li>Call <a class="reference internal" href="#c.psa_aead_update" title="psa_aead_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update()</span></code></a> zero, one or more times, passing a fragment of the message to encrypt each time.</li>
+<li>Call <a class="reference internal" href="#c.psa_aead_finish" title="psa_aead_finish"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_finish()</span></code></a>.</li>
+</ol>
+<p>The application may call <a class="reference internal" href="#c.psa_aead_abort" title="psa_aead_abort"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_abort()</span></code></a> at any time after the operation has been initialized.</p>
+<p>After a successful call to <a class="reference internal" href="#c.psa_aead_encrypt_setup" title="psa_aead_encrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_encrypt_setup()</span></code></a>, the application must eventually terminate the operation. The following events terminate an operation:</p>
+<ul class="simple">
+<li>A failed call to any of the <code class="docutils literal notranslate"><span class="pre">psa_aead_xxx</span></code> functions.</li>
+<li>A call to <a class="reference internal" href="#c.psa_aead_finish" title="psa_aead_finish"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_finish()</span></code></a>, <a class="reference internal" href="#c.psa_aead_verify" title="psa_aead_verify"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_verify()</span></code></a> or <a class="reference internal" href="#c.psa_aead_abort" title="psa_aead_abort"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_abort()</span></code></a>.</li>
+</ul>
+</div>
+<div class="section" id="psa_aead_decrypt_setup">
+<span id="c.psa_aead_decrypt_setup"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_aead_decrypt_setup</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_aead_decrypt_setup</span><span class="p">(</span><span class="n">psa_aead_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="n">psa_key_handle_t</span> <span class="n">handle</span><span class="p">,</span>
+ <span class="n">psa_algorithm_t</span> <span class="n">alg</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>The operation object to set up. It must have been initialized as per the documentation for <a class="reference internal" href="#c.psa_aead_operation_t" title="psa_aead_operation_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_aead_operation_t</span></code></a> and not yet in use.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">handle</span></code></dt>
+<dd>Handle to the key to use for the operation. It must remain valid until the operation terminates.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>The AEAD algorithm to compute (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_AEAD" title="PSA_ALG_IS_AEAD"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_AEAD</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_HANDLE" title="PSA_ERROR_INVALID_HANDLE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_HANDLE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_PERMITTED" title="PSA_ERROR_NOT_PERMITTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_PERMITTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">handle</span></code> is not compatible with <code class="docutils literal notranslate"><span class="pre">alg</span></code>.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_SUPPORTED" title="PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">alg</span></code> is not supported or is not an AEAD algorithm.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The library has not been previously initialized by <a class="reference internal" href="#c.psa_crypto_init" title="psa_crypto_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_crypto_init()</span></code></a>. It is implementation-dependent whether a failure to initialize results in this error code.</dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Set the key for a multipart authenticated decryption operation.</p>
+<p>The sequence of operations to decrypt a message with authentication is as follows:</p>
+<ol class="arabic simple">
+<li>Allocate an operation object which will be passed to all the functions listed here.</li>
+<li>Initialize the operation object with one of the methods described in the documentation for <a class="reference internal" href="#c.psa_aead_operation_t" title="psa_aead_operation_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_aead_operation_t</span></code></a>, e.g. PSA_AEAD_OPERATION_INIT.</li>
+<li>Call <a class="reference internal" href="#c.psa_aead_decrypt_setup" title="psa_aead_decrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_decrypt_setup()</span></code></a> to specify the algorithm and key.</li>
+<li>If needed, call <a class="reference internal" href="#c.psa_aead_set_lengths" title="psa_aead_set_lengths"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_set_lengths()</span></code></a> to specify the length of the inputs to the subsequent calls to <a class="reference internal" href="#c.psa_aead_update_ad" title="psa_aead_update_ad"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update_ad()</span></code></a> and <a class="reference internal" href="#c.psa_aead_update" title="psa_aead_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update()</span></code></a>. See the documentation of <a class="reference internal" href="#c.psa_aead_set_lengths" title="psa_aead_set_lengths"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_set_lengths()</span></code></a> for details.</li>
+<li>Call <a class="reference internal" href="#c.psa_aead_set_nonce" title="psa_aead_set_nonce"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_set_nonce()</span></code></a> with the nonce for the decryption.</li>
+<li>Call <a class="reference internal" href="#c.psa_aead_update_ad" title="psa_aead_update_ad"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update_ad()</span></code></a> zero, one or more times, passing a fragment of the non-encrypted additional authenticated data each time.</li>
+<li>Call <a class="reference internal" href="#c.psa_aead_update" title="psa_aead_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update()</span></code></a> zero, one or more times, passing a fragment of the ciphertext to decrypt each time.</li>
+<li>Call <a class="reference internal" href="#c.psa_aead_verify" title="psa_aead_verify"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_verify()</span></code></a>.</li>
+</ol>
+<p>The application may call <a class="reference internal" href="#c.psa_aead_abort" title="psa_aead_abort"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_abort()</span></code></a> at any time after the operation has been initialized.</p>
+<p>After a successful call to <a class="reference internal" href="#c.psa_aead_decrypt_setup" title="psa_aead_decrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_decrypt_setup()</span></code></a>, the application must eventually terminate the operation. The following events terminate an operation:</p>
+<ul class="simple">
+<li>A failed call to any of the <code class="docutils literal notranslate"><span class="pre">psa_aead_xxx</span></code> functions.</li>
+<li>A call to <a class="reference internal" href="#c.psa_aead_finish" title="psa_aead_finish"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_finish()</span></code></a>, <a class="reference internal" href="#c.psa_aead_verify" title="psa_aead_verify"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_verify()</span></code></a> or <a class="reference internal" href="#c.psa_aead_abort" title="psa_aead_abort"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_abort()</span></code></a>.</li>
+</ul>
+</div>
+<div class="section" id="psa_aead_generate_nonce">
+<span id="c.psa_aead_generate_nonce"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_aead_generate_nonce</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_aead_generate_nonce</span><span class="p">(</span><span class="n">psa_aead_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="kt">unsigned</span> <span class="kt">char</span> <span class="o">*</span> <span class="n">nonce</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">nonce_size</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="o">*</span> <span class="n">nonce_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>Active AEAD operation.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">nonce</span></code></dt>
+<dd>Buffer where the generated nonce is to be written.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">nonce_size</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">nonce</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">nonce_length</span></code></dt>
+<dd>On success, the number of bytes of the generated nonce.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The operation state is not valid (not set up, or nonce already set).</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BUFFER_TOO_SMALL" title="PSA_ERROR_BUFFER_TOO_SMALL"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BUFFER_TOO_SMALL</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The size of the <code class="docutils literal notranslate"><span class="pre">nonce</span></code> buffer is too small.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Generate a random nonce for an authenticated encryption operation.</p>
+<p>This function generates a random nonce for the authenticated encryption operation with an appropriate size for the chosen algorithm, key type and key size.</p>
+<p>The application must call <a class="reference internal" href="#c.psa_aead_encrypt_setup" title="psa_aead_encrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_encrypt_setup()</span></code></a> before calling this function.</p>
+<p>If this function returns an error status, the operation becomes inactive.</p>
+</div>
+<div class="section" id="psa_aead_set_nonce">
+<span id="c.psa_aead_set_nonce"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_aead_set_nonce</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_aead_set_nonce</span><span class="p">(</span><span class="n">psa_aead_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">unsigned</span> <span class="kt">char</span> <span class="o">*</span> <span class="n">nonce</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">nonce_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>Active AEAD operation.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">nonce</span></code></dt>
+<dd>Buffer containing the nonce to use.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">nonce_length</span></code></dt>
+<dd>Size of the nonce in bytes.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The operation state is not valid (not set up, or nonce already set).</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The size of <code class="docutils literal notranslate"><span class="pre">nonce</span></code> is not acceptable for the chosen algorithm.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Set the nonce for an authenticated encryption or decryption operation.</p>
+<p>This function sets the nonce for the authenticated encryption or decryption operation.</p>
+<p>The application must call <a class="reference internal" href="#c.psa_aead_encrypt_setup" title="psa_aead_encrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_encrypt_setup()</span></code></a> before calling this function.</p>
+<p>If this function returns an error status, the operation becomes inactive.</p>
+<div class="admonition note">
+<p class="first admonition-title">Note</p>
+<p class="last">When encrypting, applications should use <a class="reference internal" href="#c.psa_aead_generate_nonce" title="psa_aead_generate_nonce"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_generate_nonce()</span></code></a> instead of this function, unless implementing a protocol that requires a non-random IV.</p>
+</div>
+</div>
+<div class="section" id="psa_aead_set_lengths">
+<span id="c.psa_aead_set_lengths"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_aead_set_lengths</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_aead_set_lengths</span><span class="p">(</span><span class="n">psa_aead_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">ad_length</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">plaintext_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>Active AEAD operation.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">ad_length</span></code></dt>
+<dd>Size of the non-encrypted additional authenticated data in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">plaintext_length</span></code></dt>
+<dd>Size of the plaintext to encrypt in bytes.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The operation state is not valid (not set up, already completed, or <a class="reference internal" href="#c.psa_aead_update_ad" title="psa_aead_update_ad"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update_ad()</span></code></a> or <a class="reference internal" href="#c.psa_aead_update" title="psa_aead_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update()</span></code></a> already called).</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>At least one of the lengths is not acceptable for the chosen algorithm.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Declare the lengths of the message and additional data for AEAD.</p>
+<p>The application must call this function before calling <a class="reference internal" href="#c.psa_aead_update_ad" title="psa_aead_update_ad"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update_ad()</span></code></a> or <a class="reference internal" href="#c.psa_aead_update" title="psa_aead_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update()</span></code></a> if the algorithm for the operation requires it. If the algorithm does not require it, calling this function is optional, but if this function is called then the implementation must enforce the lengths.</p>
+<p>You may call this function before or after setting the nonce with <a class="reference internal" href="#c.psa_aead_set_nonce" title="psa_aead_set_nonce"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_set_nonce()</span></code></a> or <a class="reference internal" href="#c.psa_aead_generate_nonce" title="psa_aead_generate_nonce"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_generate_nonce()</span></code></a>.</p>
+<ul class="simple">
+<li>For <a class="reference internal" href="#c.PSA_ALG_CCM" title="PSA_ALG_CCM"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_CCM</span></code></a>, calling this function is required.</li>
+<li>For the other AEAD algorithms defined in this specification, calling this function is not required.</li>
+<li>For vendor-defined algorithm, refer to the vendor documentation.</li>
+</ul>
+</div>
+<div class="section" id="psa_aead_update_ad">
+<span id="c.psa_aead_update_ad"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_aead_update_ad</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_aead_update_ad</span><span class="p">(</span><span class="n">psa_aead_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">input</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">input_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>Active AEAD operation.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">input</span></code></dt>
+<dd>Buffer containing the fragment of additional data.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">input_length</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">input</span></code> buffer in bytes.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The operation state is not valid (not set up, nonce not set, <a class="reference internal" href="#c.psa_aead_update" title="psa_aead_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update()</span></code></a> already called, or operation already completed).</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The total input length overflows the additional data length that was previously specified with <a class="reference internal" href="#c.psa_aead_set_lengths" title="psa_aead_set_lengths"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_set_lengths()</span></code></a>.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Pass additional data to an active AEAD operation.</p>
+<p>Additional data is authenticated, but not encrypted.</p>
+<p>You may call this function multiple times to pass successive fragments of the additional data. You may not call this function after passing data to encrypt or decrypt with <a class="reference internal" href="#c.psa_aead_update" title="psa_aead_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update()</span></code></a>.</p>
+<p>Before calling this function, you must:</p>
+<ol class="arabic simple">
+<li>Call either <a class="reference internal" href="#c.psa_aead_encrypt_setup" title="psa_aead_encrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_encrypt_setup()</span></code></a> or <a class="reference internal" href="#c.psa_aead_decrypt_setup" title="psa_aead_decrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_decrypt_setup()</span></code></a>.</li>
+<li>Set the nonce with <a class="reference internal" href="#c.psa_aead_generate_nonce" title="psa_aead_generate_nonce"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_generate_nonce()</span></code></a> or <a class="reference internal" href="#c.psa_aead_set_nonce" title="psa_aead_set_nonce"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_set_nonce()</span></code></a>.</li>
+</ol>
+<p>If this function returns an error status, the operation becomes inactive.</p>
+<div class="admonition warning">
+<p class="first admonition-title">Warning</p>
+<p class="last">When decrypting, until <a class="reference internal" href="#c.psa_aead_verify" title="psa_aead_verify"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_verify()</span></code></a> has returned <a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a>, there is no guarantee that the input is valid. Therefore, until you have called <a class="reference internal" href="#c.psa_aead_verify" title="psa_aead_verify"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_verify()</span></code></a> and it has returned <a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a>, treat the input as untrusted and prepare to undo any action that depends on the input if <a class="reference internal" href="#c.psa_aead_verify" title="psa_aead_verify"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_verify()</span></code></a> returns an error status.</p>
+</div>
+</div>
+<div class="section" id="psa_aead_update">
+<span id="c.psa_aead_update"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_aead_update</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_aead_update</span><span class="p">(</span><span class="n">psa_aead_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">input</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">input_length</span><span class="p">,</span>
+ <span class="kt">unsigned</span> <span class="kt">char</span> <span class="o">*</span> <span class="n">output</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">output_size</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="o">*</span> <span class="n">output_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>Active AEAD operation.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">input</span></code></dt>
+<dd>Buffer containing the message fragment to encrypt or decrypt.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">input_length</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">input</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">output</span></code></dt>
+<dd>Buffer where the output is to be written.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">output_size</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">output</span></code> buffer in bytes. This must be at least <a class="reference internal" href="#c.PSA_AEAD_UPDATE_OUTPUT_SIZE" title="PSA_AEAD_UPDATE_OUTPUT_SIZE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_AEAD_UPDATE_OUTPUT_SIZE</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>, <code class="docutils literal notranslate"><span class="pre">input_length</span></code>) where <code class="docutils literal notranslate"><span class="pre">alg</span></code> is the algorithm that is being calculated.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">output_length</span></code></dt>
+<dd>On success, the number of bytes that make up the returned output.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The operation state is not valid (not set up, nonce not set or already completed).</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BUFFER_TOO_SMALL" title="PSA_ERROR_BUFFER_TOO_SMALL"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BUFFER_TOO_SMALL</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The size of the <code class="docutils literal notranslate"><span class="pre">output</span></code> buffer is too small. You can determine a sufficient buffer size by calling <a class="reference internal" href="#c.PSA_AEAD_UPDATE_OUTPUT_SIZE" title="PSA_AEAD_UPDATE_OUTPUT_SIZE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_AEAD_UPDATE_OUTPUT_SIZE</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>, <code class="docutils literal notranslate"><span class="pre">input_length</span></code>) where <code class="docutils literal notranslate"><span class="pre">alg</span></code> is the algorithm that is being calculated.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The total length of input to <a class="reference internal" href="#c.psa_aead_update_ad" title="psa_aead_update_ad"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update_ad()</span></code></a> so far is less than the additional data length that was previously specified with <a class="reference internal" href="#c.psa_aead_set_lengths" title="psa_aead_set_lengths"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_set_lengths()</span></code></a>.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The total input length overflows the plaintext length that was previously specified with <a class="reference internal" href="#c.psa_aead_set_lengths" title="psa_aead_set_lengths"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_set_lengths()</span></code></a>.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Encrypt or decrypt a message fragment in an active AEAD operation.</p>
+<p>Before calling this function, you must:</p>
+<ol class="arabic simple">
+<li>Call either <a class="reference internal" href="#c.psa_aead_encrypt_setup" title="psa_aead_encrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_encrypt_setup()</span></code></a> or <a class="reference internal" href="#c.psa_aead_decrypt_setup" title="psa_aead_decrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_decrypt_setup()</span></code></a>. The choice of setup function determines whether this function encrypts or decrypts its input.</li>
+<li>Set the nonce with <a class="reference internal" href="#c.psa_aead_generate_nonce" title="psa_aead_generate_nonce"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_generate_nonce()</span></code></a> or <a class="reference internal" href="#c.psa_aead_set_nonce" title="psa_aead_set_nonce"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_set_nonce()</span></code></a>.</li>
+<li>Call <a class="reference internal" href="#c.psa_aead_update_ad" title="psa_aead_update_ad"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update_ad()</span></code></a> to pass all the additional data.</li>
+</ol>
+<p>If this function returns an error status, the operation becomes inactive.</p>
+<div class="admonition warning">
+<p class="first admonition-title">Warning</p>
+<p>When decrypting, until <a class="reference internal" href="#c.psa_aead_verify" title="psa_aead_verify"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_verify()</span></code></a> has returned <a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a>, there is no guarantee that the input is valid. Therefore, until you have called <a class="reference internal" href="#c.psa_aead_verify" title="psa_aead_verify"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_verify()</span></code></a> and it has returned <a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a>:</p>
+<ul class="last simple">
+<li>Do not use the output in any way other than storing it in a confidential location. If you take any action that depends on the tentative decrypted data, this action will need to be undone if the input turns out not to be valid. Furthermore, if an adversary can observe that this action took place (for example through timing), they may be able to use this fact as an oracle to decrypt any message encrypted with the same key.</li>
+<li>In particular, do not copy the output anywhere but to a memory or storage space that you have exclusive access to.</li>
+</ul>
+</div>
+<p>This function does not require the input to be aligned to any particular block boundary. If the implementation can only process a whole block at a time, it must consume all the input provided, but it may delay the end of the corresponding output until a subsequent call to <a class="reference internal" href="#c.psa_aead_update" title="psa_aead_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update()</span></code></a>, <a class="reference internal" href="#c.psa_aead_finish" title="psa_aead_finish"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_finish()</span></code></a> or <a class="reference internal" href="#c.psa_aead_verify" title="psa_aead_verify"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_verify()</span></code></a> provides sufficient input. The amount of data that can be delayed in this way is bounded by <a class="reference internal" href="#c.PSA_AEAD_UPDATE_OUTPUT_SIZE" title="PSA_AEAD_UPDATE_OUTPUT_SIZE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_AEAD_UPDATE_OUTPUT_SIZE</span></code></a>.</p>
+</div>
+<div class="section" id="psa_aead_finish">
+<span id="c.psa_aead_finish"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_aead_finish</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_aead_finish</span><span class="p">(</span><span class="n">psa_aead_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">ciphertext</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">ciphertext_size</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="o">*</span> <span class="n">ciphertext_length</span><span class="p">,</span>
+ <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">tag</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">tag_size</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="o">*</span> <span class="n">tag_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>Active AEAD operation.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">ciphertext</span></code></dt>
+<dd>Buffer where the last part of the ciphertext is to be written.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">ciphertext_size</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">ciphertext</span></code> buffer in bytes. This must be at least <a class="reference internal" href="#c.PSA_AEAD_FINISH_OUTPUT_SIZE" title="PSA_AEAD_FINISH_OUTPUT_SIZE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_AEAD_FINISH_OUTPUT_SIZE</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) where <code class="docutils literal notranslate"><span class="pre">alg</span></code> is the algorithm that is being calculated.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">ciphertext_length</span></code></dt>
+<dd>On success, the number of bytes of returned ciphertext.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">tag</span></code></dt>
+<dd>Buffer where the authentication tag is to be written.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">tag_size</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">tag</span></code> buffer in bytes. This must be at least <a class="reference internal" href="#c.PSA_AEAD_TAG_LENGTH" title="PSA_AEAD_TAG_LENGTH"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_AEAD_TAG_LENGTH</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) where <code class="docutils literal notranslate"><span class="pre">alg</span></code> is the algorithm that is being calculated.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">tag_length</span></code></dt>
+<dd>On success, the number of bytes that make up the returned tag.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The operation state is not valid (not set up, nonce not set, decryption, or already completed).</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BUFFER_TOO_SMALL" title="PSA_ERROR_BUFFER_TOO_SMALL"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BUFFER_TOO_SMALL</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The size of the <code class="docutils literal notranslate"><span class="pre">ciphertext</span></code> or <code class="docutils literal notranslate"><span class="pre">tag</span></code> buffer is too small. You can determine a sufficient buffer size for <code class="docutils literal notranslate"><span class="pre">ciphertext</span></code> by calling <a class="reference internal" href="#c.PSA_AEAD_FINISH_OUTPUT_SIZE" title="PSA_AEAD_FINISH_OUTPUT_SIZE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_AEAD_FINISH_OUTPUT_SIZE</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) where <code class="docutils literal notranslate"><span class="pre">alg</span></code> is the algorithm that is being calculated. You can determine a sufficient buffer size for <code class="docutils literal notranslate"><span class="pre">tag</span></code> by calling <a class="reference internal" href="#c.PSA_AEAD_TAG_LENGTH" title="PSA_AEAD_TAG_LENGTH"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_AEAD_TAG_LENGTH</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>).</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The total length of input to <a class="reference internal" href="#c.psa_aead_update_ad" title="psa_aead_update_ad"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update_ad()</span></code></a> so far is less than the additional data length that was previously specified with <a class="reference internal" href="#c.psa_aead_set_lengths" title="psa_aead_set_lengths"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_set_lengths()</span></code></a>.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The total length of input to <a class="reference internal" href="#c.psa_aead_update" title="psa_aead_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update()</span></code></a> so far is less than the plaintext length that was previously specified with <a class="reference internal" href="#c.psa_aead_set_lengths" title="psa_aead_set_lengths"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_set_lengths()</span></code></a>.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Finish encrypting a message in an AEAD operation.</p>
+<p>The operation must have been set up with <a class="reference internal" href="#c.psa_aead_encrypt_setup" title="psa_aead_encrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_encrypt_setup()</span></code></a>.</p>
+<p>This function finishes the authentication of the additional data formed by concatenating the inputs passed to preceding calls to <a class="reference internal" href="#c.psa_aead_update_ad" title="psa_aead_update_ad"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update_ad()</span></code></a> with the plaintext formed by concatenating the inputs passed to preceding calls to <a class="reference internal" href="#c.psa_aead_update" title="psa_aead_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update()</span></code></a>.</p>
+<p>This function has two output buffers:</p>
+<ul class="simple">
+<li><code class="docutils literal notranslate"><span class="pre">ciphertext</span></code> contains trailing ciphertext that was buffered from preceding calls to <a class="reference internal" href="#c.psa_aead_update" title="psa_aead_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update()</span></code></a>.</li>
+<li><code class="docutils literal notranslate"><span class="pre">tag</span></code> contains the authentication tag. Its length is always <a class="reference internal" href="#c.PSA_AEAD_TAG_LENGTH" title="PSA_AEAD_TAG_LENGTH"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_AEAD_TAG_LENGTH</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) where <code class="docutils literal notranslate"><span class="pre">alg</span></code> is the AEAD algorithm that the operation performs.</li>
+</ul>
+<p>When this function returns, the operation becomes inactive.</p>
+</div>
+<div class="section" id="psa_aead_verify">
+<span id="c.psa_aead_verify"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_aead_verify</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_aead_verify</span><span class="p">(</span><span class="n">psa_aead_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">plaintext</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">plaintext_size</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="o">*</span> <span class="n">plaintext_length</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">tag</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">tag_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>Active AEAD operation.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">plaintext</span></code></dt>
+<dd>Buffer where the last part of the plaintext is to be written. This is the remaining data from previous calls to <a class="reference internal" href="#c.psa_aead_update" title="psa_aead_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update()</span></code></a> that could not be processed until the end of the input.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">plaintext_size</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">plaintext</span></code> buffer in bytes. This must be at least <a class="reference internal" href="#c.PSA_AEAD_VERIFY_OUTPUT_SIZE" title="PSA_AEAD_VERIFY_OUTPUT_SIZE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_AEAD_VERIFY_OUTPUT_SIZE</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) where <code class="docutils literal notranslate"><span class="pre">alg</span></code> is the algorithm that is being calculated.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">plaintext_length</span></code></dt>
+<dd>On success, the number of bytes of returned plaintext.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">tag</span></code></dt>
+<dd>Buffer containing the authentication tag.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">tag_length</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">tag</span></code> buffer in bytes.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The operation state is not valid (not set up, nonce not set, encryption, or already completed).</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BUFFER_TOO_SMALL" title="PSA_ERROR_BUFFER_TOO_SMALL"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BUFFER_TOO_SMALL</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The size of the <code class="docutils literal notranslate"><span class="pre">plaintext</span></code> buffer is too small. You can determine a sufficient buffer size for <code class="docutils literal notranslate"><span class="pre">plaintext</span></code> by calling <a class="reference internal" href="#c.PSA_AEAD_VERIFY_OUTPUT_SIZE" title="PSA_AEAD_VERIFY_OUTPUT_SIZE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_AEAD_VERIFY_OUTPUT_SIZE</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) where <code class="docutils literal notranslate"><span class="pre">alg</span></code> is the algorithm that is being calculated.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The total length of input to <a class="reference internal" href="#c.psa_aead_update_ad" title="psa_aead_update_ad"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update_ad()</span></code></a> so far is less than the additional data length that was previously specified with <a class="reference internal" href="#c.psa_aead_set_lengths" title="psa_aead_set_lengths"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_set_lengths()</span></code></a>.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The total length of input to <a class="reference internal" href="#c.psa_aead_update" title="psa_aead_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update()</span></code></a> so far is less than the plaintext length that was previously specified with <a class="reference internal" href="#c.psa_aead_set_lengths" title="psa_aead_set_lengths"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_set_lengths()</span></code></a>.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Finish authenticating and decrypting a message in an AEAD operation.</p>
+<p>The operation must have been set up with <a class="reference internal" href="#c.psa_aead_decrypt_setup" title="psa_aead_decrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_decrypt_setup()</span></code></a>.</p>
+<p>This function finishes the authentication of the additional data formed by concatenating the inputs passed to preceding calls to <a class="reference internal" href="#c.psa_aead_update_ad" title="psa_aead_update_ad"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update_ad()</span></code></a> with the ciphertext formed by concatenating the inputs passed to preceding calls to <a class="reference internal" href="#c.psa_aead_update" title="psa_aead_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update()</span></code></a>.</p>
+<p>When this function returns, the operation becomes inactive.</p>
+</div>
+<div class="section" id="psa_aead_abort">
+<span id="c.psa_aead_abort"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_aead_abort</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_aead_abort</span><span class="p">(</span><span class="n">psa_aead_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>Initialized AEAD operation.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">operation</span></code> is not an active AEAD operation.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Abort an AEAD operation.</p>
+<p>Aborting an operation frees all associated resources except for the <code class="docutils literal notranslate"><span class="pre">operation</span></code> structure itself. Once aborted, the operation object can be reused for another operation by calling <a class="reference internal" href="#c.psa_aead_encrypt_setup" title="psa_aead_encrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_encrypt_setup()</span></code></a> or <a class="reference internal" href="#c.psa_aead_decrypt_setup" title="psa_aead_decrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_decrypt_setup()</span></code></a> again.</p>
+<p>You may call this function any time after the operation object has been initialized by any of the following methods:</p>
+<ul class="simple">
+<li>A call to <a class="reference internal" href="#c.psa_aead_encrypt_setup" title="psa_aead_encrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_encrypt_setup()</span></code></a> or <a class="reference internal" href="#c.psa_aead_decrypt_setup" title="psa_aead_decrypt_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_decrypt_setup()</span></code></a>, whether it succeeds or not.</li>
+<li>Initializing the <code class="docutils literal notranslate"><span class="pre">struct</span></code> to all-bits-zero.</li>
+<li>Initializing the <code class="docutils literal notranslate"><span class="pre">struct</span></code> to logical zeros, e.g. <code class="docutils literal notranslate"><span class="pre">psa_aead_operation_t</span> <span class="pre">operation</span> <span class="pre">=</span> <span class="pre">{0}</span></code>.</li>
+</ul>
+<p>In particular, calling <a class="reference internal" href="#c.psa_aead_abort" title="psa_aead_abort"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_abort()</span></code></a> after the operation has been terminated by a call to <a class="reference internal" href="#c.psa_aead_abort" title="psa_aead_abort"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_abort()</span></code></a> or <a class="reference internal" href="#c.psa_aead_finish" title="psa_aead_finish"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_finish()</span></code></a> is safe and has no effect.</p>
+</div>
+</div>
+<div class="section" id="asymmetric-cryptography">
+<h1>Asymmetric cryptography</h1>
+<div class="section" id="psa_asymmetric_sign">
+<span id="c.psa_asymmetric_sign"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_asymmetric_sign</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_asymmetric_sign</span><span class="p">(</span><span class="n">psa_key_handle_t</span> <span class="n">handle</span><span class="p">,</span>
+ <span class="n">psa_algorithm_t</span> <span class="n">alg</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">hash</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">hash_length</span><span class="p">,</span>
+ <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">signature</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">signature_size</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="o">*</span> <span class="n">signature_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">handle</span></code></dt>
+<dd>Handle to the key to use for the operation. It must be an asymmetric key pair.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>A signature algorithm that is compatible with the type of <code class="docutils literal notranslate"><span class="pre">handle</span></code>.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">hash</span></code></dt>
+<dd>The hash or message to sign.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">hash_length</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">hash</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">signature</span></code></dt>
+<dd>Buffer where the signature is to be written.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">signature_size</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">signature</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">signature_length</span></code></dt>
+<dd>On success, the number of bytes that make up the returned signature value.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BUFFER_TOO_SMALL" title="PSA_ERROR_BUFFER_TOO_SMALL"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BUFFER_TOO_SMALL</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The size of the <code class="docutils literal notranslate"><span class="pre">signature</span></code> buffer is too small. You can determine a sufficient buffer size by calling <a class="reference internal" href="#c.PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE" title="PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE</span></code></a>(<code class="docutils literal notranslate"><span class="pre">key_type</span></code>, <code class="docutils literal notranslate"><span class="pre">key_bits</span></code>, <code class="docutils literal notranslate"><span class="pre">alg</span></code>) where <code class="docutils literal notranslate"><span class="pre">key_type</span></code> and <code class="docutils literal notranslate"><span class="pre">key_bits</span></code> are the type and bit-size respectively of <code class="docutils literal notranslate"><span class="pre">handle</span></code>.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_SUPPORTED" title="PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_ENTROPY" title="PSA_ERROR_INSUFFICIENT_ENTROPY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_ENTROPY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The library has not been previously initialized by <a class="reference internal" href="#c.psa_crypto_init" title="psa_crypto_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_crypto_init()</span></code></a>. It is implementation-dependent whether a failure to initialize results in this error code.</dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Sign a hash or short message with a private key.</p>
+<p>Note that to perform a hash-and-sign signature algorithm, you must first calculate the hash by calling <a class="reference internal" href="#c.psa_hash_setup" title="psa_hash_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_setup()</span></code></a>, <a class="reference internal" href="#c.psa_hash_update" title="psa_hash_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_update()</span></code></a> and <a class="reference internal" href="#c.psa_hash_finish" title="psa_hash_finish"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_finish()</span></code></a>. Then pass the resulting hash as the <code class="docutils literal notranslate"><span class="pre">hash</span></code> parameter to this function. You can use <a class="reference internal" href="#c.PSA_ALG_SIGN_GET_HASH" title="PSA_ALG_SIGN_GET_HASH"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_SIGN_GET_HASH</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) to determine the hash algorithm to use.</p>
+</div>
+<div class="section" id="psa_asymmetric_verify">
+<span id="c.psa_asymmetric_verify"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_asymmetric_verify</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_asymmetric_verify</span><span class="p">(</span><span class="n">psa_key_handle_t</span> <span class="n">handle</span><span class="p">,</span>
+ <span class="n">psa_algorithm_t</span> <span class="n">alg</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">hash</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">hash_length</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">signature</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">signature_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">handle</span></code></dt>
+<dd>Handle to the key to use for the operation. It must be a public key or an asymmetric key pair.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>A signature algorithm that is compatible with the type of <code class="docutils literal notranslate"><span class="pre">handle</span></code>.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">hash</span></code></dt>
+<dd>The hash or message whose signature is to be verified.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">hash_length</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">hash</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">signature</span></code></dt>
+<dd>Buffer containing the signature to verify.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">signature_length</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">signature</span></code> buffer in bytes.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The signature is valid.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_SIGNATURE" title="PSA_ERROR_INVALID_SIGNATURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_SIGNATURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The calculation was perfomed successfully, but the passed signature is not a valid signature.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_SUPPORTED" title="PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The library has not been previously initialized by <a class="reference internal" href="#c.psa_crypto_init" title="psa_crypto_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_crypto_init()</span></code></a>. It is implementation-dependent whether a failure to initialize results in this error code.</dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Verify the signature a hash or short message using a public key.</p>
+<p>Note that to perform a hash-and-sign signature algorithm, you must first calculate the hash by calling <a class="reference internal" href="#c.psa_hash_setup" title="psa_hash_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_setup()</span></code></a>, <a class="reference internal" href="#c.psa_hash_update" title="psa_hash_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_update()</span></code></a> and <a class="reference internal" href="#c.psa_hash_finish" title="psa_hash_finish"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_finish()</span></code></a>. Then pass the resulting hash as the <code class="docutils literal notranslate"><span class="pre">hash</span></code> parameter to this function. You can use <a class="reference internal" href="#c.PSA_ALG_SIGN_GET_HASH" title="PSA_ALG_SIGN_GET_HASH"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_SIGN_GET_HASH</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) to determine the hash algorithm to use.</p>
+</div>
+<div class="section" id="psa_asymmetric_encrypt">
+<span id="c.psa_asymmetric_encrypt"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_asymmetric_encrypt</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_asymmetric_encrypt</span><span class="p">(</span><span class="n">psa_key_handle_t</span> <span class="n">handle</span><span class="p">,</span>
+ <span class="n">psa_algorithm_t</span> <span class="n">alg</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">input</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">input_length</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">salt</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">salt_length</span><span class="p">,</span>
+ <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">output</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">output_size</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="o">*</span> <span class="n">output_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">handle</span></code></dt>
+<dd>Handle to the key to use for the operation. It must be a public key or an asymmetric key pair.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>An asymmetric encryption algorithm that is compatible with the type of <code class="docutils literal notranslate"><span class="pre">handle</span></code>.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">input</span></code></dt>
+<dd>The message to encrypt.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">input_length</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">input</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">salt</span></code></dt>
+<dd>A salt or label, if supported by the encryption algorithm. If the algorithm does not support a salt, pass <code class="docutils literal notranslate"><span class="pre">NULL</span></code>. If the algorithm supports an optional salt and you do not want to pass a salt, pass <code class="docutils literal notranslate"><span class="pre">NULL</span></code>.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">salt_length</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">salt</span></code> buffer in bytes. If <code class="docutils literal notranslate"><span class="pre">salt</span></code> is <code class="docutils literal notranslate"><span class="pre">NULL</span></code>, pass 0.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">output</span></code></dt>
+<dd>Buffer where the encrypted message is to be written.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">output_size</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">output</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">output_length</span></code></dt>
+<dd>On success, the number of bytes that make up the returned output.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BUFFER_TOO_SMALL" title="PSA_ERROR_BUFFER_TOO_SMALL"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BUFFER_TOO_SMALL</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The size of the <code class="docutils literal notranslate"><span class="pre">output</span></code> buffer is too small. You can determine a sufficient buffer size by calling <a class="reference internal" href="#c.PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE" title="PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE</span></code></a>(<code class="docutils literal notranslate"><span class="pre">key_type</span></code>, <code class="docutils literal notranslate"><span class="pre">key_bits</span></code>, <code class="docutils literal notranslate"><span class="pre">alg</span></code>) where <code class="docutils literal notranslate"><span class="pre">key_type</span></code> and <code class="docutils literal notranslate"><span class="pre">key_bits</span></code> are the type and bit-size respectively of <code class="docutils literal notranslate"><span class="pre">handle</span></code>.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_SUPPORTED" title="PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_ENTROPY" title="PSA_ERROR_INSUFFICIENT_ENTROPY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_ENTROPY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The library has not been previously initialized by <a class="reference internal" href="#c.psa_crypto_init" title="psa_crypto_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_crypto_init()</span></code></a>. It is implementation-dependent whether a failure to initialize results in this error code.</dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Encrypt a short message with a public key.</p>
+<ul class="simple">
+<li>For <a class="reference internal" href="#c.PSA_ALG_RSA_PKCS1V15_CRYPT" title="PSA_ALG_RSA_PKCS1V15_CRYPT"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_RSA_PKCS1V15_CRYPT</span></code></a>, no salt is supported.</li>
+</ul>
+</div>
+<div class="section" id="psa_asymmetric_decrypt">
+<span id="c.psa_asymmetric_decrypt"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_asymmetric_decrypt</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_asymmetric_decrypt</span><span class="p">(</span><span class="n">psa_key_handle_t</span> <span class="n">handle</span><span class="p">,</span>
+ <span class="n">psa_algorithm_t</span> <span class="n">alg</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">input</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">input_length</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">salt</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">salt_length</span><span class="p">,</span>
+ <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">output</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">output_size</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="o">*</span> <span class="n">output_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">handle</span></code></dt>
+<dd>Handle to the key to use for the operation. It must be an asymmetric key pair.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>An asymmetric encryption algorithm that is compatible with the type of <code class="docutils literal notranslate"><span class="pre">handle</span></code>.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">input</span></code></dt>
+<dd>The message to decrypt.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">input_length</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">input</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">salt</span></code></dt>
+<dd>A salt or label, if supported by the encryption algorithm. If the algorithm does not support a salt, pass <code class="docutils literal notranslate"><span class="pre">NULL</span></code>. If the algorithm supports an optional salt and you do not want to pass a salt, pass <code class="docutils literal notranslate"><span class="pre">NULL</span></code>.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">salt_length</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">salt</span></code> buffer in bytes. If <code class="docutils literal notranslate"><span class="pre">salt</span></code> is <code class="docutils literal notranslate"><span class="pre">NULL</span></code>, pass 0.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">output</span></code></dt>
+<dd>Buffer where the decrypted message is to be written.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">output_size</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">output</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">output_length</span></code></dt>
+<dd>On success, the number of bytes that make up the returned output.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BUFFER_TOO_SMALL" title="PSA_ERROR_BUFFER_TOO_SMALL"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BUFFER_TOO_SMALL</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The size of the <code class="docutils literal notranslate"><span class="pre">output</span></code> buffer is too small. You can determine a sufficient buffer size by calling <a class="reference internal" href="#c.PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE" title="PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE</span></code></a>(<code class="docutils literal notranslate"><span class="pre">key_type</span></code>, <code class="docutils literal notranslate"><span class="pre">key_bits</span></code>, <code class="docutils literal notranslate"><span class="pre">alg</span></code>) where <code class="docutils literal notranslate"><span class="pre">key_type</span></code> and <code class="docutils literal notranslate"><span class="pre">key_bits</span></code> are the type and bit-size respectively of <code class="docutils literal notranslate"><span class="pre">handle</span></code>.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_SUPPORTED" title="PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_ENTROPY" title="PSA_ERROR_INSUFFICIENT_ENTROPY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_ENTROPY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_PADDING" title="PSA_ERROR_INVALID_PADDING"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_PADDING</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The library has not been previously initialized by <a class="reference internal" href="#c.psa_crypto_init" title="psa_crypto_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_crypto_init()</span></code></a>. It is implementation-dependent whether a failure to initialize results in this error code.</dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Decrypt a short message with a private key.</p>
+<ul class="simple">
+<li>For <a class="reference internal" href="#c.PSA_ALG_RSA_PKCS1V15_CRYPT" title="PSA_ALG_RSA_PKCS1V15_CRYPT"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_RSA_PKCS1V15_CRYPT</span></code></a>, no salt is supported.</li>
+</ul>
+</div>
+</div>
+<div class="section" id="key-derivation-and-pseudorandom-generation">
+<h1>Key derivation and pseudorandom generation</h1>
+<div class="section" id="psa_key_derivation_operation_t">
+<span id="c.psa_key_derivation_operation_t"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_operation_t</span></code> (type)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="k">typedef</span> <span class="k">struct</span> <span class="n">psa_key_derivation_s</span> <span class="n">psa_key_derivation_operation_t</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>The type of the state data structure for key derivation operations.</p>
+<p>Before calling any function on a key derivation operation object, the application must initialize it by any of the following means:</p>
+<ul>
+<li><p class="first">Set the structure to all-bits-zero, for example:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_key_derivation_operation_t</span> <span class="n">operation</span><span class="p">;</span>
+<span class="n">memset</span><span class="p">(</span><span class="o">&</span><span class="n">operation</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="k">sizeof</span><span class="p">(</span><span class="n">operation</span><span class="p">));</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first">Initialize the structure to logical zero values, for example:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_key_derivation_operation_t</span> <span class="n">operation</span> <span class="o">=</span> <span class="p">{</span><span class="mi">0</span><span class="p">};</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first">Initialize the structure to the initializer <a class="reference internal" href="#c.PSA_KEY_DERIVATION_OPERATION_INIT" title="PSA_KEY_DERIVATION_OPERATION_INIT"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_OPERATION_INIT</span></code></a>, for example:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_key_derivation_operation_t</span> <span class="n">operation</span> <span class="o">=</span> <span class="n">PSA_KEY_DERIVATION_OPERATION_INIT</span><span class="p">;</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first">Assign the result of the function <a class="reference internal" href="#c.psa_key_derivation_operation_init" title="psa_key_derivation_operation_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_derivation_operation_init()</span></code></a> to the structure, for example:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_key_derivation_operation_t</span> <span class="n">operation</span><span class="p">;</span>
+<span class="n">operation</span> <span class="o">=</span> <span class="n">psa_key_derivation_operation_init</span><span class="p">();</span>
+</pre></div>
+</div>
+</li>
+</ul>
+<p>This is an implementation-defined <code class="docutils literal notranslate"><span class="pre">struct</span></code>. Applications should not make any assumptions about the content of this structure except as directed by the documentation of a specific implementation.</p>
+</div>
+<div class="section" id="PSA_KEY_DERIVATION_OPERATION_INIT">
+<span id="c.PSA_KEY_DERIVATION_OPERATION_INIT"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_OPERATION_INIT</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_DERIVATION_OPERATION_INIT {0}</span>
+</pre></div>
+</div>
+<p>This macro returns a suitable initializer for a key derivation operation object of type <a class="reference internal" href="#c.psa_key_derivation_operation_t" title="psa_key_derivation_operation_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_key_derivation_operation_t</span></code></a>.</p>
+</div>
+<div class="section" id="PSA_KEY_DERIVATION_UNLIMITED_CAPACITY">
+<span id="c.PSA_KEY_DERIVATION_UNLIMITED_CAPACITY"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_UNLIMITED_CAPACITY</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_DERIVATION_UNLIMITED_CAPACITY ((size_t)(-1))</span>
+</pre></div>
+</div>
+<p>Use the maximum possible capacity for a key derivation operation.</p>
+<p>Use this value as the capacity argument when setting up a key derivation to indicate that the operation should have the maximum possible capacity. The value of the maximum possible capacity depends on the key derivation algorithm.</p>
+</div>
+<div class="section" id="psa_key_derivation_operation_init">
+<span id="c.psa_key_derivation_operation_init"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_operation_init</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_key_derivation_operation_t</span> <span class="nf">psa_key_derivation_operation_init</span><span class="p">(</span><span class="kt">void</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_key_derivation_operation_t" title="psa_key_derivation_operation_t"><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_operation_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Return an initial value for a key derivation operation object.</p>
+</div>
+<div class="section" id="psa_key_derivation_setup">
+<span id="c.psa_key_derivation_setup"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_setup</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_key_derivation_setup</span><span class="p">(</span><span class="n">psa_key_derivation_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="n">psa_algorithm_t</span> <span class="n">alg</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>The key derivation operation object to set up. It must have been initialized but not set up yet.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>The key derivation algorithm to compute (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_KEY_DERIVATION" title="PSA_ALG_IS_KEY_DERIVATION"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_KEY_DERIVATION</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">alg</span></code> is not a key derivation algorithm.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_SUPPORTED" title="PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">alg</span></code> is not supported or is not a key derivation algorithm.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Set up a key derivation operation.</p>
+<p>A key derivation algorithm takes some inputs and uses them to generate a byte stream in a deterministic way. This byte stream can be used to produce keys and other cryptographic material.</p>
+<p>To derive a key:</p>
+<ul class="simple">
+<li>Start with an initialized object of type <a class="reference internal" href="#c.psa_key_derivation_operation_t" title="psa_key_derivation_operation_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_key_derivation_operation_t</span></code></a>.</li>
+<li>Call <a class="reference internal" href="#c.psa_key_derivation_setup" title="psa_key_derivation_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_derivation_setup()</span></code></a> to select the algorithm.</li>
+<li>Provide the inputs for the key derivation by calling <a class="reference internal" href="#c.psa_key_derivation_input_bytes" title="psa_key_derivation_input_bytes"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_derivation_input_bytes()</span></code></a> or <a class="reference internal" href="#c.psa_key_derivation_input_key" title="psa_key_derivation_input_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_derivation_input_key()</span></code></a> as appropriate. Which inputs are needed, in what order, and whether they may be keys and if so of what type depends on the algorithm.</li>
+<li>Optionally set the operation’s maximum capacity with <a class="reference internal" href="#c.psa_key_derivation_set_capacity" title="psa_key_derivation_set_capacity"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_derivation_set_capacity()</span></code></a>. You may do this before, in the middle of or after providing inputs. For some algorithms, this step is mandatory because the output depends on the maximum capacity.</li>
+<li>To derive a key, call <a class="reference internal" href="#c.psa_key_derivation_output_key" title="psa_key_derivation_output_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_derivation_output_key()</span></code></a>. To derive a byte string for a different purpose, call</li>
+<li><a class="reference internal" href="#c.psa_key_derivation_output_bytes" title="psa_key_derivation_output_bytes"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_derivation_output_bytes()</span></code></a>. Successive calls to these functions use successive output bytes calculated by the key derivation algorithm.</li>
+<li>Clean up the key derivation operation object with <a class="reference internal" href="#c.psa_key_derivation_abort" title="psa_key_derivation_abort"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_derivation_abort()</span></code></a>.</li>
+</ul>
+</div>
+<div class="section" id="psa_key_derivation_get_capacity">
+<span id="c.psa_key_derivation_get_capacity"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_get_capacity</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_key_derivation_get_capacity</span><span class="p">(</span><span class="k">const</span> <span class="n">psa_key_derivation_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="o">*</span> <span class="n">capacity</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>The operation to query.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">capacity</span></code></dt>
+<dd>On success, the capacity of the operation.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Retrieve the current capacity of a key derivation operation.</p>
+<p>The capacity of a key derivation is the maximum number of bytes that it can return. When you get <em>N</em> bytes of output from a key derivation operation, this reduces its capacity by <em>N</em>.</p>
+</div>
+<div class="section" id="psa_key_derivation_set_capacity">
+<span id="c.psa_key_derivation_set_capacity"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_set_capacity</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_key_derivation_set_capacity</span><span class="p">(</span><span class="n">psa_key_derivation_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">capacity</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>The key derivation operation object to modify.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">capacity</span></code></dt>
+<dd>The new capacity of the operation. It must be less or equal to the operation’s current capacity.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">capacity</span></code> is larger than the operation’s current capacity. In this case, the operation object remains valid and its capacity remains unchanged.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Set the maximum capacity of a key derivation operation.</p>
+<p>The capacity of a key derivation operation is the maximum number of bytes that the key derivation operation can return from this point onwards.</p>
+</div>
+<div class="section" id="psa_key_derivation_input_bytes">
+<span id="c.psa_key_derivation_input_bytes"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_input_bytes</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_key_derivation_input_bytes</span><span class="p">(</span><span class="n">psa_key_derivation_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="n">psa_key_derivation_step_t</span> <span class="n">step</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">data</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">data_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>The key derivation operation object to use. It must have been set up with <a class="reference internal" href="#c.psa_key_derivation_setup" title="psa_key_derivation_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_derivation_setup()</span></code></a> and must not have produced any output yet.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">step</span></code></dt>
+<dd>Which step the input data is for.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">data</span></code></dt>
+<dd>Input data to use.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">data_length</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">data</span></code> buffer in bytes.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">step</span></code> is not compatible with the operation’s algorithm.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">step</span></code> does not allow direct inputs.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The value of <code class="docutils literal notranslate"><span class="pre">step</span></code> is not valid given the state of <code class="docutils literal notranslate"><span class="pre">operation</span></code>.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The library has not been previously initialized by <a class="reference internal" href="#c.psa_crypto_init" title="psa_crypto_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_crypto_init()</span></code></a>. It is implementation-dependent whether a failure to initialize results in this error code.</dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Provide an input for key derivation or key agreement.</p>
+<p>Which inputs are required and in what order depends on the algorithm. Refer to the documentation of each key derivation or key agreement algorithm for information.</p>
+<p>This function passes direct inputs. Some inputs must be passed as keys using <a class="reference internal" href="#c.psa_key_derivation_input_key" title="psa_key_derivation_input_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_derivation_input_key()</span></code></a> instead of this function. Refer to the documentation of individual step types for information.</p>
+</div>
+<div class="section" id="psa_key_derivation_input_key">
+<span id="c.psa_key_derivation_input_key"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_input_key</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_key_derivation_input_key</span><span class="p">(</span><span class="n">psa_key_derivation_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="n">psa_key_derivation_step_t</span> <span class="n">step</span><span class="p">,</span>
+ <span class="n">psa_key_handle_t</span> <span class="n">handle</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>The key derivation operation object to use. It must have been set up with <a class="reference internal" href="#c.psa_key_derivation_setup" title="psa_key_derivation_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_derivation_setup()</span></code></a> and must not have produced any output yet.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">step</span></code></dt>
+<dd>Which step the input data is for.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">handle</span></code></dt>
+<dd>Handle to the key. It must have an appropriate type for <code class="docutils literal notranslate"><span class="pre">step</span></code> and must allow the usage <a class="reference internal" href="#c.PSA_KEY_USAGE_DERIVE" title="PSA_KEY_USAGE_DERIVE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_DERIVE</span></code></a>.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_HANDLE" title="PSA_ERROR_INVALID_HANDLE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_HANDLE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_DOES_NOT_EXIST" title="PSA_ERROR_DOES_NOT_EXIST"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_DOES_NOT_EXIST</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_PERMITTED" title="PSA_ERROR_NOT_PERMITTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_PERMITTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">step</span></code> is not compatible with the operation’s algorithm.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">step</span></code> does not allow key inputs.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The value of <code class="docutils literal notranslate"><span class="pre">step</span></code> is not valid given the state of <code class="docutils literal notranslate"><span class="pre">operation</span></code>.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The library has not been previously initialized by <a class="reference internal" href="#c.psa_crypto_init" title="psa_crypto_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_crypto_init()</span></code></a>. It is implementation-dependent whether a failure to initialize results in this error code.</dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Provide an input for key derivation in the form of a key.</p>
+<p>Which inputs are required and in what order depends on the algorithm. Refer to the documentation of each key derivation or key agreement algorithm for information.</p>
+<p>This function passes key inputs. Some inputs must be passed as keys of the appropriate type using this function, while others must be passed as direct inputs using <a class="reference internal" href="#c.psa_key_derivation_input_bytes" title="psa_key_derivation_input_bytes"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_derivation_input_bytes()</span></code></a>. Refer to the documentation of individual step types for information.</p>
+</div>
+<div class="section" id="psa_key_derivation_key_agreement">
+<span id="c.psa_key_derivation_key_agreement"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_key_agreement</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_key_derivation_key_agreement</span><span class="p">(</span><span class="n">psa_key_derivation_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="n">psa_key_derivation_step_t</span> <span class="n">step</span><span class="p">,</span>
+ <span class="n">psa_key_handle_t</span> <span class="n">private_key</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">peer_key</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">peer_key_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>The key derivation operation object to use. It must have been set up with <a class="reference internal" href="#c.psa_key_derivation_setup" title="psa_key_derivation_setup"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_derivation_setup()</span></code></a> with a key agreement and derivation algorithm <code class="docutils literal notranslate"><span class="pre">alg</span></code> (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_KEY_AGREEMENT" title="PSA_ALG_IS_KEY_AGREEMENT"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_KEY_AGREEMENT</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true and <a class="reference internal" href="#c.PSA_ALG_IS_RAW_KEY_AGREEMENT" title="PSA_ALG_IS_RAW_KEY_AGREEMENT"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_RAW_KEY_AGREEMENT</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is false). The operation must be ready for an input of the type given by <code class="docutils literal notranslate"><span class="pre">step</span></code>.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">step</span></code></dt>
+<dd>Which step the input data is for.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">private_key</span></code></dt>
+<dd>Handle to the private key to use.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">peer_key</span></code></dt>
+<dd>Public key of the peer. The peer key must be in the same format that <a class="reference internal" href="#c.psa_import_key" title="psa_import_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_import_key()</span></code></a> accepts for the public key type corresponding to the type of private_key. That is, this function performs the equivalent of <a class="reference internal" href="#c.psa_import_key" title="psa_import_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_import_key</span></code></a>(…, <code class="docutils literal notranslate"><span class="pre">peer_key</span></code>, <code class="docutils literal notranslate"><span class="pre">peer_key_length</span></code>) where with key attributes indicating the public key type corresponding to the type of <code class="docutils literal notranslate"><span class="pre">private_key</span></code>. For example, for EC keys, this means that peer_key is interpreted as a point on the curve that the private key is on. The standard formats for public keys are documented in the documentation of <a class="reference internal" href="#c.psa_export_public_key" title="psa_export_public_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_export_public_key()</span></code></a>.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">peer_key_length</span></code></dt>
+<dd>Size of <code class="docutils literal notranslate"><span class="pre">peer_key</span></code> in bytes.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_HANDLE" title="PSA_ERROR_INVALID_HANDLE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_HANDLE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_DOES_NOT_EXIST" title="PSA_ERROR_DOES_NOT_EXIST"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_DOES_NOT_EXIST</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_PERMITTED" title="PSA_ERROR_NOT_PERMITTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_PERMITTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">private_key</span></code> is not compatible with <code class="docutils literal notranslate"><span class="pre">alg</span></code>, or <code class="docutils literal notranslate"><span class="pre">peer_key</span></code> is not valid for <code class="docutils literal notranslate"><span class="pre">alg</span></code> or not compatible with <code class="docutils literal notranslate"><span class="pre">private_key</span></code>.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_SUPPORTED" title="PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">alg</span></code> is not supported or is not a key derivation algorithm.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Perform a key agreement and use the shared secret as input to a key derivation.</p>
+<p>A key agreement algorithm takes two inputs: a private key <code class="docutils literal notranslate"><span class="pre">private_key</span></code> a public key <code class="docutils literal notranslate"><span class="pre">peer_key</span></code>. The result of this function is passed as input to a key derivation. The output of this key derivation can be extracted by reading from the resulting operation to produce keys and other cryptographic material.</p>
+</div>
+<div class="section" id="psa_key_derivation_output_bytes">
+<span id="c.psa_key_derivation_output_bytes"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_output_bytes</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_key_derivation_output_bytes</span><span class="p">(</span><span class="n">psa_key_derivation_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">output</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">output_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>The key derivation operation object to read from.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">output</span></code></dt>
+<dd>Buffer where the output will be written.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">output_length</span></code></dt>
+<dd>Number of bytes to output.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_DATA" title="PSA_ERROR_INSUFFICIENT_DATA"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_DATA</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The operation’s capacity was less than <code class="docutils literal notranslate"><span class="pre">output_length</span></code> bytes. Note that in this case, no output is written to the output buffer. The operation’s capacity is set to 0, thus subsequent calls to this function will not succeed, even with a smaller output buffer.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Read some data from a key derivation operation.</p>
+<p>This function calculates output bytes from a key derivation algorithm and return those bytes. If you view the key derivation’s output as a stream of bytes, this function destructively reads the requested number of bytes from the stream. The operation’s capacity decreases by the number of bytes read.</p>
+</div>
+<div class="section" id="psa_key_derivation_output_key">
+<span id="c.psa_key_derivation_output_key"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_output_key</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_key_derivation_output_key</span><span class="p">(</span><span class="k">const</span> <span class="n">psa_key_attributes_t</span> <span class="o">*</span> <span class="n">attributes</span><span class="p">,</span>
+ <span class="n">psa_key_derivation_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">,</span>
+ <span class="n">psa_key_handle_t</span> <span class="o">*</span> <span class="n">handle</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">attributes</span></code></dt>
+<dd>The attributes for the new key.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>The key derivation operation object to read from.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">handle</span></code></dt>
+<dd>On success, a handle to the newly created key. <code class="docutils literal notranslate"><span class="pre">0</span></code> on failure.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success. If the key is persistent, the key material and the key’s metadata have been saved to persistent storage.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_ALREADY_EXISTS" title="PSA_ERROR_ALREADY_EXISTS"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_ALREADY_EXISTS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>This is an attempt to create a persistent key, and there is already a persistent key with the given identifier.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_DATA" title="PSA_ERROR_INSUFFICIENT_DATA"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_DATA</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>There was not enough data to create the desired key. Note that in this case, no output is written to the output buffer. The operation’s capacity is set to 0, thus subsequent calls to this function will not succeed, even with a smaller output buffer.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_SUPPORTED" title="PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The key type or key size is not supported, either by the implementation in general or in this particular location.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_STORAGE" title="PSA_ERROR_INSUFFICIENT_STORAGE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_STORAGE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The library has not been previously initialized by <a class="reference internal" href="#c.psa_crypto_init" title="psa_crypto_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_crypto_init()</span></code></a>. It is implementation-dependent whether a failure to initialize results in this error code.</dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Derive a key from an ongoing key derivation operation.</p>
+<p>This function calculates output bytes from a key derivation algorithm and uses those bytes to generate a key deterministically. If you view the key derivation’s output as a stream of bytes, this function destructively reads as many bytes as required from the stream. The operation’s capacity decreases by the number of bytes read.</p>
+<p>How much output is produced and consumed from the operation, and how the key is derived, depends on the key type:</p>
+<ul class="simple">
+<li>For key types for which the key is an arbitrary sequence of bytes of a given size, this function is functionally equivalent to calling <a class="reference internal" href="#c.psa_key_derivation_output_bytes" title="psa_key_derivation_output_bytes"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_derivation_output_bytes</span></code></a> and passing the resulting output to <a class="reference internal" href="#c.psa_import_key" title="psa_import_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_import_key</span></code></a>. However, this function has a security benefit: if the implementation provides an isolation boundary then the key material is not exposed outside the isolation boundary. As a consequence, for these key types, this function always consumes exactly (<code class="docutils literal notranslate"><span class="pre">bits</span></code> / 8) bytes from the operation. The following key types defined in this specification follow this scheme:<ul>
+<li><a class="reference internal" href="#c.PSA_KEY_TYPE_AES" title="PSA_KEY_TYPE_AES"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_AES</span></code></a>;</li>
+<li><a class="reference internal" href="#c.PSA_KEY_TYPE_ARC4" title="PSA_KEY_TYPE_ARC4"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_ARC4</span></code></a>;</li>
+<li><a class="reference internal" href="#c.PSA_KEY_TYPE_CAMELLIA" title="PSA_KEY_TYPE_CAMELLIA"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_CAMELLIA</span></code></a>;</li>
+<li><a class="reference internal" href="#c.PSA_KEY_TYPE_DERIVE" title="PSA_KEY_TYPE_DERIVE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_DERIVE</span></code></a>;</li>
+<li><a class="reference internal" href="#c.PSA_KEY_TYPE_HMAC" title="PSA_KEY_TYPE_HMAC"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_HMAC</span></code></a>.</li>
+</ul>
+</li>
+<li>For ECC keys on a Montgomery elliptic curve (<a class="reference internal" href="#c.PSA_KEY_TYPE_ECC_KEY_PAIR" title="PSA_KEY_TYPE_ECC_KEY_PAIR"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_ECC_KEY_PAIR</span></code></a>(<code class="docutils literal notranslate"><span class="pre">curve</span></code>) where <code class="docutils literal notranslate"><span class="pre">curve</span></code> designates a Montgomery curve), this function always draws a byte string whose length is determined by the curve, and sets the mandatory bits accordingly. That is:<ul>
+<li><a class="reference internal" href="#c.PSA_ECC_CURVE_CURVE25519" title="PSA_ECC_CURVE_CURVE25519"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_CURVE25519</span></code></a>: draw a 32-byte string and process it as specified in RFC 7748 §5.</li>
+<li><a class="reference internal" href="#c.PSA_ECC_CURVE_CURVE448" title="PSA_ECC_CURVE_CURVE448"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_CURVE448</span></code></a>: draw a 56-byte string and process it as specified in RFC 7748 §5.</li>
+</ul>
+</li>
+<li>For key types for which the key is represented by a single sequence of <code class="docutils literal notranslate"><span class="pre">bits</span></code> bits with constraints as to which bit sequences are acceptable, this function draws a byte string of length (<code class="docutils literal notranslate"><span class="pre">bits</span></code> / 8) bytes rounded up to the nearest whole number of bytes. If the resulting byte string is acceptable, it becomes the key, otherwise the drawn bytes are discarded. This process is repeated until an acceptable byte string is drawn. The byte string drawn from the operation is interpreted as specified for the output produced by <a class="reference internal" href="#c.psa_export_key" title="psa_export_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_export_key()</span></code></a>. The following key types defined in this specification follow this scheme:<ul>
+<li><a class="reference internal" href="#c.PSA_KEY_TYPE_DES" title="PSA_KEY_TYPE_DES"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_DES</span></code></a>. Force-set the parity bits, but discard forbidden weak keys. For 2-key and 3-key triple-DES, the three keys are generated successively (for example, for 3-key triple-DES, if the first 8 bytes specify a weak key and the next 8 bytes do not, discard the first 8 bytes, use the next 8 bytes as the first key, and continue reading output from the operation to derive the other two keys).</li>
+<li>Finite-field Diffie-Hellman keys (<a class="reference internal" href="#c.PSA_KEY_TYPE_DH_KEY_PAIR" title="PSA_KEY_TYPE_DH_KEY_PAIR"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_DH_KEY_PAIR</span></code></a>(<code class="docutils literal notranslate"><span class="pre">group</span></code>) where <code class="docutils literal notranslate"><span class="pre">group</span></code> designates any Diffie-Hellman group) and ECC keys on a Weierstrass elliptic curve (<a class="reference internal" href="#c.PSA_KEY_TYPE_ECC_KEY_PAIR" title="PSA_KEY_TYPE_ECC_KEY_PAIR"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_ECC_KEY_PAIR</span></code></a>(<code class="docutils literal notranslate"><span class="pre">curve</span></code>) where <code class="docutils literal notranslate"><span class="pre">curve</span></code> designates a Weierstrass curve). For these key types, interpret the byte string as integer in big-endian order. Discard it if it is not in the range [0, <em>N</em> - 2] where <em>N</em> is the boundary of the private key domain (the prime <em>p</em> for Diffie-Hellman, the subprime <em>q</em> for DSA, or the order of the curve’s base point for ECC). Add 1 to the resulting integer and use this as the private key <em>x</em>. This method allows compliance to NIST standards, specifically the methods titled “key-pair generation by testing candidates” in NIST SP 800-56A §5.6.1.1.4 for Diffie-Hellman, in FIPS 186-4 §B.1.2 for DSA, and in NIST SP 800-56A §5.6.1.2.2 or FIPS 186-4 §B.4.2 for elliptic curve keys.</li>
+</ul>
+</li>
+<li>For other key types, including <a class="reference internal" href="#c.PSA_KEY_TYPE_RSA_KEY_PAIR" title="PSA_KEY_TYPE_RSA_KEY_PAIR"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_RSA_KEY_PAIR</span></code></a>, the way in which the operation output is consumed is implementation-defined.</li>
+</ul>
+<p>In all cases, the data that is read is discarded from the operation. The operation’s capacity is decreased by the number of bytes read.</p>
+</div>
+<div class="section" id="psa_key_derivation_abort">
+<span id="c.psa_key_derivation_abort"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_abort</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_key_derivation_abort</span><span class="p">(</span><span class="n">psa_key_derivation_operation_t</span> <span class="o">*</span> <span class="n">operation</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">operation</span></code></dt>
+<dd>The operation to abort.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Abort a key derivation operation.</p>
+<p>Once a key derivation operation has been aborted, its capacity is zero. Aborting an operation frees all associated resources except for the <code class="docutils literal notranslate"><span class="pre">operation</span></code> structure itself.</p>
+<p>This function may be called at any time as long as the operation object has been initialized to <a class="reference internal" href="#c.PSA_KEY_DERIVATION_OPERATION_INIT" title="PSA_KEY_DERIVATION_OPERATION_INIT"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_OPERATION_INIT</span></code></a>, to <a class="reference internal" href="#c.psa_key_derivation_operation_init" title="psa_key_derivation_operation_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_derivation_operation_init()</span></code></a> or a zero value. In particular, it is valid to call <a class="reference internal" href="#c.psa_key_derivation_abort" title="psa_key_derivation_abort"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_derivation_abort()</span></code></a> twice, or to call <a class="reference internal" href="#c.psa_key_derivation_abort" title="psa_key_derivation_abort"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_derivation_abort()</span></code></a> on an operation that has not been set up.</p>
+<p>Once aborted, the key derivation operation object may be called.</p>
+</div>
+<div class="section" id="psa_raw_key_agreement">
+<span id="c.psa_raw_key_agreement"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_raw_key_agreement</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_raw_key_agreement</span><span class="p">(</span><span class="n">psa_algorithm_t</span> <span class="n">alg</span><span class="p">,</span>
+ <span class="n">psa_key_handle_t</span> <span class="n">private_key</span><span class="p">,</span>
+ <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">peer_key</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">peer_key_length</span><span class="p">,</span>
+ <span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">output</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">output_size</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="o">*</span> <span class="n">output_length</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>The key agreement algorithm to compute (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_RAW_KEY_AGREEMENT" title="PSA_ALG_IS_RAW_KEY_AGREEMENT"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_RAW_KEY_AGREEMENT</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true).</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">private_key</span></code></dt>
+<dd>Handle to the private key to use.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">peer_key</span></code></dt>
+<dd>Public key of the peer. It must be in the same format that <a class="reference internal" href="#c.psa_import_key" title="psa_import_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_import_key()</span></code></a> accepts. The standard formats for public keys are documented in the documentation of <a class="reference internal" href="#c.psa_export_public_key" title="psa_export_public_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_export_public_key()</span></code></a>.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">peer_key_length</span></code></dt>
+<dd>Size of <code class="docutils literal notranslate"><span class="pre">peer_key</span></code> in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">output</span></code></dt>
+<dd>Buffer where the decrypted message is to be written.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">output_size</span></code></dt>
+<dd>Size of the <code class="docutils literal notranslate"><span class="pre">output</span></code> buffer in bytes.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">output_length</span></code></dt>
+<dd>On success, the number of bytes that make up the returned output.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_HANDLE" title="PSA_ERROR_INVALID_HANDLE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_HANDLE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_PERMITTED" title="PSA_ERROR_NOT_PERMITTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_PERMITTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">alg</span></code> is not a key agreement algorithm</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">private_key</span></code> is not compatible with <code class="docutils literal notranslate"><span class="pre">alg</span></code>, or <code class="docutils literal notranslate"><span class="pre">peer_key</span></code> is not valid for <code class="docutils literal notranslate"><span class="pre">alg</span></code> or not compatible with <code class="docutils literal notranslate"><span class="pre">private_key</span></code>.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_SUPPORTED" title="PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd><code class="docutils literal notranslate"><span class="pre">alg</span></code> is not a supported key agreement algorithm.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Perform a key agreement and return the raw shared secret.</p>
+<div class="admonition warning">
+<p class="first admonition-title">Warning</p>
+<p class="last">The raw result of a key agreement algorithm such as finite-field Diffie-Hellman or elliptic curve Diffie-Hellman has biases and should not be used directly as key material. It should instead be passed as input to a key derivation algorithm. To chain a key agreement with a key derivation, use <a class="reference internal" href="#c.psa_key_derivation_key_agreement" title="psa_key_derivation_key_agreement"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_derivation_key_agreement()</span></code></a> and other functions from the key derivation interface.</p>
+</div>
+</div>
+</div>
+<div class="section" id="random-generation">
+<h1>Random generation</h1>
+<div class="section" id="psa_generate_random">
+<span id="c.psa_generate_random"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_generate_random</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_generate_random</span><span class="p">(</span><span class="kt">uint8_t</span> <span class="o">*</span> <span class="n">output</span><span class="p">,</span>
+ <span class="kt">size_t</span> <span class="n">output_size</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">output</span></code></dt>
+<dd>Output buffer for the generated data.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">output_size</span></code></dt>
+<dd>Number of bytes to generate and output.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_SUPPORTED" title="PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_ENTROPY" title="PSA_ERROR_INSUFFICIENT_ENTROPY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_ENTROPY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The library has not been previously initialized by <a class="reference internal" href="#c.psa_crypto_init" title="psa_crypto_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_crypto_init()</span></code></a>. It is implementation-dependent whether a failure to initialize results in this error code.</dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Generate random bytes.</p>
+<div class="admonition warning">
+<p class="first admonition-title">Warning</p>
+<p class="last">This function <strong>can</strong> fail! Callers MUST check the return status and MUST NOT use the content of the output buffer if the return status is not <a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a>.</p>
+</div>
+<div class="admonition note">
+<p class="first admonition-title">Note</p>
+<p class="last">To generate a key, use <a class="reference internal" href="#c.psa_generate_key" title="psa_generate_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_generate_key()</span></code></a> instead.</p>
+</div>
+</div>
+<div class="section" id="psa_generate_key">
+<span id="c.psa_generate_key"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_generate_key</span></code> (function)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_status_t</span> <span class="nf">psa_generate_key</span><span class="p">(</span><span class="k">const</span> <span class="n">psa_key_attributes_t</span> <span class="o">*</span> <span class="n">attributes</span><span class="p">,</span>
+ <span class="n">psa_key_handle_t</span> <span class="o">*</span> <span class="n">handle</span><span class="p">);</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">attributes</span></code></dt>
+<dd>The attributes for the new key.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">handle</span></code></dt>
+<dd>On success, a handle to the newly created key. <code class="docutils literal notranslate"><span class="pre">0</span></code> on failure.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.psa_status_t" title="psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>Success. If the key is persistent, the key material and the key’s metadata have been saved to persistent storage.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_ALREADY_EXISTS" title="PSA_ERROR_ALREADY_EXISTS"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_ALREADY_EXISTS</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>This is an attempt to create a persistent key, and there is already a persistent key with the given identifier.</dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_NOT_SUPPORTED" title="PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_MEMORY" title="PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_ENTROPY" title="PSA_ERROR_INSUFFICIENT_ENTROPY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_ENTROPY</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"></code><a class="reference internal" href="#c.PSA_ERROR_BAD_STATE" title="PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code></a><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code><code class="docutils literal notranslate"></code></dt>
+<dd>The library has not been previously initialized by <a class="reference internal" href="#c.psa_crypto_init" title="psa_crypto_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_crypto_init()</span></code></a>. It is implementation-dependent whether a failure to initialize results in this error code.</dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Generate a key or key pair.</p>
+<p>The key is generated randomly. Its location, policy, type and size are taken from <code class="docutils literal notranslate"><span class="pre">attributes</span></code>.</p>
+<p>The following type-specific considerations apply:</p>
+<ul class="simple">
+<li>For RSA keys (<a class="reference internal" href="#c.PSA_KEY_TYPE_RSA_KEY_PAIR" title="PSA_KEY_TYPE_RSA_KEY_PAIR"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_RSA_KEY_PAIR</span></code></a>), the public exponent is 65537. The modulus is a product of two probabilistic primes between 2^{n-1} and 2^n where n is the bit size specified in the attributes.</li>
+</ul>
+</div>
+</div>
+<div class="section" id="error-codes">
+<h1>Error codes</h1>
+<div class="section" id="psa_status_t">
+<span id="c.psa_status_t"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code> (type)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="k">typedef</span> <span class="kt">int32_t</span> <span class="n">psa_status_t</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>Function return status.</p>
+<p>This is either <a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a> (which is zero), indicating success, or a small negative value indicating that an error occurred. Errors are encoded as one of the <code class="docutils literal notranslate"><span class="pre">PSA_ERROR_xxx</span></code> values defined here.</p>
+</div>
+<div class="section" id="PSA_SUCCESS">
+<span id="c.PSA_SUCCESS"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_SUCCESS ((psa_status_t)0)</span>
+</pre></div>
+</div>
+<p>The action was completed successfully.</p>
+</div>
+<div class="section" id="PSA_ERROR_GENERIC_ERROR">
+<span id="c.PSA_ERROR_GENERIC_ERROR"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_GENERIC_ERROR</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ERROR_GENERIC_ERROR ((psa_status_t)-132)</span>
+</pre></div>
+</div>
+<p>An error occurred that does not correspond to any defined failure cause.</p>
+<p>Implementations may use this error code if none of the other standard error codes are applicable.</p>
+</div>
+<div class="section" id="PSA_ERROR_NOT_SUPPORTED">
+<span id="c.PSA_ERROR_NOT_SUPPORTED"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ERROR_NOT_SUPPORTED ((psa_status_t)-134)</span>
+</pre></div>
+</div>
+<p>The requested operation or a parameter is not supported by this implementation.</p>
+<p>Implementations should return this error code when an enumeration parameter such as a key type, algorithm, etc. is not recognized. If a combination of parameters is recognized and identified as not valid, return <a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a> instead.</p>
+</div>
+<div class="section" id="PSA_ERROR_NOT_PERMITTED">
+<span id="c.PSA_ERROR_NOT_PERMITTED"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_PERMITTED</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ERROR_NOT_PERMITTED ((psa_status_t)-133)</span>
+</pre></div>
+</div>
+<p>The requested action is denied by a policy.</p>
+<p>Implementations should return this error code when the parameters are recognized as valid and supported, and a policy explicitly denies the requested operation.</p>
+<p>If a subset of the parameters of a function call identify a forbidden operation, and another subset of the parameters are not valid or not supported, it is unspecified whether the function returns <a class="reference internal" href="#c.PSA_ERROR_NOT_PERMITTED" title="PSA_ERROR_NOT_PERMITTED"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_PERMITTED</span></code></a>, <a class="reference internal" href="#c.PSA_ERROR_NOT_SUPPORTED" title="PSA_ERROR_NOT_SUPPORTED"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code></a> or <a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a>.</p>
+</div>
+<div class="section" id="PSA_ERROR_BUFFER_TOO_SMALL">
+<span id="c.PSA_ERROR_BUFFER_TOO_SMALL"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BUFFER_TOO_SMALL</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ERROR_BUFFER_TOO_SMALL ((psa_status_t)-138)</span>
+</pre></div>
+</div>
+<p>An output buffer is too small.</p>
+<p>Applications can call the <code class="docutils literal notranslate"><span class="pre">PSA_xxx_SIZE</span></code> macro listed in the function description to determine a sufficient buffer size.</p>
+<p>Implementations should preferably return this error code only in cases when performing the operation with a larger output buffer would succeed. However implementations may return this error if a function has invalid or unsupported parameters in addition to the parameters that determine the necessary output buffer size.</p>
+</div>
+<div class="section" id="PSA_ERROR_ALREADY_EXISTS">
+<span id="c.PSA_ERROR_ALREADY_EXISTS"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_ALREADY_EXISTS</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ERROR_ALREADY_EXISTS ((psa_status_t)-139)</span>
+</pre></div>
+</div>
+<p>Asking for an item that already exists.</p>
+<p>Implementations should return this error, when attempting to write an item (like a key) that already exists.</p>
+</div>
+<div class="section" id="PSA_ERROR_DOES_NOT_EXIST">
+<span id="c.PSA_ERROR_DOES_NOT_EXIST"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_DOES_NOT_EXIST</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ERROR_DOES_NOT_EXIST ((psa_status_t)-140)</span>
+</pre></div>
+</div>
+<p>Asking for an item that doesn’t exist.</p>
+<p>Implementations should return this error, if a requested item (like a key) does not exist.</p>
+</div>
+<div class="section" id="PSA_ERROR_BAD_STATE">
+<span id="c.PSA_ERROR_BAD_STATE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ERROR_BAD_STATE ((psa_status_t)-137)</span>
+</pre></div>
+</div>
+<p>The requested action cannot be performed in the current state.</p>
+<p>Multipart operations return this error when one of the functions is called out of sequence. Refer to the function descriptions for permitted sequencing of functions.</p>
+<p>Implementations shall not return this error code to indicate that a key either exists or not, but shall instead return <a class="reference internal" href="#c.PSA_ERROR_ALREADY_EXISTS" title="PSA_ERROR_ALREADY_EXISTS"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ERROR_ALREADY_EXISTS</span></code></a> or <a class="reference internal" href="#c.PSA_ERROR_DOES_NOT_EXIST" title="PSA_ERROR_DOES_NOT_EXIST"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ERROR_DOES_NOT_EXIST</span></code></a> as applicable.</p>
+<p>Implementations shall not return this error code to indicate that a key handle is invalid, but shall return <a class="reference internal" href="#c.PSA_ERROR_INVALID_HANDLE" title="PSA_ERROR_INVALID_HANDLE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_HANDLE</span></code></a> instead.</p>
+</div>
+<div class="section" id="PSA_ERROR_INVALID_ARGUMENT">
+<span id="c.PSA_ERROR_INVALID_ARGUMENT"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ERROR_INVALID_ARGUMENT ((psa_status_t)-135)</span>
+</pre></div>
+</div>
+<p>The parameters passed to the function are invalid.</p>
+<p>Implementations may return this error any time a parameter or combination of parameters are recognized as invalid.</p>
+<p>Implementations shall not return this error code to indicate that a key handle is invalid, but shall return <a class="reference internal" href="#c.PSA_ERROR_INVALID_HANDLE" title="PSA_ERROR_INVALID_HANDLE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_HANDLE</span></code></a> instead.</p>
+</div>
+<div class="section" id="PSA_ERROR_INSUFFICIENT_MEMORY">
+<span id="c.PSA_ERROR_INSUFFICIENT_MEMORY"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ERROR_INSUFFICIENT_MEMORY ((psa_status_t)-141)</span>
+</pre></div>
+</div>
+<p>There is not enough runtime memory.</p>
+<p>If the action is carried out across multiple security realms, this error can refer to available memory in any of the security realms.</p>
+</div>
+<div class="section" id="PSA_ERROR_INSUFFICIENT_STORAGE">
+<span id="c.PSA_ERROR_INSUFFICIENT_STORAGE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_STORAGE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ERROR_INSUFFICIENT_STORAGE ((psa_status_t)-142)</span>
+</pre></div>
+</div>
+<p>There is not enough persistent storage.</p>
+<p>Functions that modify the key storage return this error code if there is insufficient storage space on the host media. In addition, many functions that do not otherwise access storage may return this error code if the implementation requires a mandatory log entry for the requested action and the log storage space is full.</p>
+</div>
+<div class="section" id="PSA_ERROR_COMMUNICATION_FAILURE">
+<span id="c.PSA_ERROR_COMMUNICATION_FAILURE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ERROR_COMMUNICATION_FAILURE ((psa_status_t)-145)</span>
+</pre></div>
+</div>
+<p>There was a communication failure inside the implementation.</p>
+<p>This can indicate a communication failure between the application and an external cryptoprocessor or between the cryptoprocessor and an external volatile or persistent memory. A communication failure may be transient or permanent depending on the cause.</p>
+<div class="admonition warning">
+<p class="first admonition-title">Warning</p>
+<p class="last">If a function returns this error, it is undetermined whether the requested action has completed or not. Implementations should return <a class="reference internal" href="#c.PSA_SUCCESS" title="PSA_SUCCESS"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code></a> on successful completion whenver possible, however functions may return <a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a> if the requested action was completed successfully in an external cryptoprocessor but there was a breakdown of communication before the cryptoprocessor could report the status to the application.</p>
+</div>
+</div>
+<div class="section" id="PSA_ERROR_STORAGE_FAILURE">
+<span id="c.PSA_ERROR_STORAGE_FAILURE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_STORAGE_FAILURE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ERROR_STORAGE_FAILURE ((psa_status_t)-146)</span>
+</pre></div>
+</div>
+<p>There was a storage failure that may have led to data loss.</p>
+<p>This error indicates that some persistent storage is corrupted. It should not be used for a corruption of volatile memory (use <a class="reference internal" href="#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a>), for a communication error between the cryptoprocessor and its external storage (use <a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a>), or when the storage is in a valid state but is full (use <a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_STORAGE" title="PSA_ERROR_INSUFFICIENT_STORAGE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_STORAGE</span></code></a>).</p>
+<p>Note that a storage failure does not indicate that any data that was previously read is invalid. However this previously read data may no longer be readable from storage.</p>
+<p>When a storage failure occurs, it is no longer possible to ensure the global integrity of the keystore. Depending on the global integrity guarantees offered by the implementation, access to other data may or may not fail even if the data is still readable but its integrity cannot be guaranteed.</p>
+<p>Implementations should only use this error code to report a permanent storage corruption. However application writers should keep in mind that transient errors while reading the storage may be reported using this error code.</p>
+</div>
+<div class="section" id="PSA_ERROR_HARDWARE_FAILURE">
+<span id="c.PSA_ERROR_HARDWARE_FAILURE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ERROR_HARDWARE_FAILURE ((psa_status_t)-147)</span>
+</pre></div>
+</div>
+<p>A hardware failure was detected.</p>
+<p>A hardware failure may be transient or permanent depending on the cause.</p>
+</div>
+<div class="section" id="PSA_ERROR_CORRUPTION_DETECTED">
+<span id="c.PSA_ERROR_CORRUPTION_DETECTED"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ERROR_CORRUPTION_DETECTED ((psa_status_t)-151)</span>
+</pre></div>
+</div>
+<p>A tampering attempt was detected.</p>
+<p>If an application receives this error code, there is no guarantee that previously accessed or computed data was correct and remains confidential. Applications should not perform any security function and should enter a safe failure state.</p>
+<p>Implementations may return this error code if they detect an invalid state that cannot happen during normal operation and that indicates that the implementation’s security guarantees no longer hold. Depending on the implementation architecture and on its security and safety goals, the implementation may forcibly terminate the application.</p>
+<p>This error code is intended as a last resort when a security breach is detected and it is unsure whether the keystore data is still protected. Implementations shall only return this error code to report an alarm from a tampering detector, to indicate that the confidentiality of stored data can no longer be guaranteed, or to indicate that the integrity of previously returned data is now considered compromised. Implementations shall not use this error code to indicate a hardware failure that merely makes it impossible to perform the requested operation (use <a class="reference internal" href="#c.PSA_ERROR_COMMUNICATION_FAILURE" title="PSA_ERROR_COMMUNICATION_FAILURE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code></a>, <a class="reference internal" href="#c.PSA_ERROR_STORAGE_FAILURE" title="PSA_ERROR_STORAGE_FAILURE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ERROR_STORAGE_FAILURE</span></code></a>, <a class="reference internal" href="#c.PSA_ERROR_HARDWARE_FAILURE" title="PSA_ERROR_HARDWARE_FAILURE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code></a>, <a class="reference internal" href="#c.PSA_ERROR_INSUFFICIENT_ENTROPY" title="PSA_ERROR_INSUFFICIENT_ENTROPY"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_ENTROPY</span></code></a> or other applicable error code instead).</p>
+<p>This error indicates an attack against the application. Implementations shall not return this error code as a consequence of the behavior of the application itself.</p>
+</div>
+<div class="section" id="PSA_ERROR_INSUFFICIENT_ENTROPY">
+<span id="c.PSA_ERROR_INSUFFICIENT_ENTROPY"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_ENTROPY</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ERROR_INSUFFICIENT_ENTROPY ((psa_status_t)-148)</span>
+</pre></div>
+</div>
+<p>There is not enough entropy to generate random data needed for the requested action.</p>
+<p>This error indicates a failure of a hardware random generator. Application writers should note that this error can be returned not only by functions whose purpose is to generate random data, such as key, IV or nonce generation, but also by functions that execute an algorithm with a randomized result, as well as functions that use randomization of intermediate computations as a countermeasure to certain attacks.</p>
+<p>Implementations should avoid returning this error after <a class="reference internal" href="#c.psa_crypto_init" title="psa_crypto_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_crypto_init()</span></code></a> has succeeded. Implementations should generate sufficient entropy during initialization and subsequently use a cryptographically secure pseudorandom generator (PRNG). However implementations may return this error at any time if a policy requires the PRNG to be reseeded during normal operation.</p>
+</div>
+<div class="section" id="PSA_ERROR_INVALID_SIGNATURE">
+<span id="c.PSA_ERROR_INVALID_SIGNATURE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_SIGNATURE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ERROR_INVALID_SIGNATURE ((psa_status_t)-149)</span>
+</pre></div>
+</div>
+<p>The signature, MAC or hash is incorrect.</p>
+<p>Verification functions return this error if the verification calculations completed successfully, and the value to be verified was determined to be incorrect.</p>
+<p>If the value to verify has an invalid size, implementations may return either <a class="reference internal" href="#c.PSA_ERROR_INVALID_ARGUMENT" title="PSA_ERROR_INVALID_ARGUMENT"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code></a> or <a class="reference internal" href="#c.PSA_ERROR_INVALID_SIGNATURE" title="PSA_ERROR_INVALID_SIGNATURE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_SIGNATURE</span></code></a>.</p>
+</div>
+<div class="section" id="PSA_ERROR_INVALID_PADDING">
+<span id="c.PSA_ERROR_INVALID_PADDING"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_PADDING</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ERROR_INVALID_PADDING ((psa_status_t)-150)</span>
+</pre></div>
+</div>
+<p>The decrypted padding is incorrect.</p>
+<div class="admonition warning">
+<p class="first admonition-title">Warning</p>
+<p class="last">In some protocols, when decrypting data, it is essential that the behavior of the application does not depend on whether the padding is correct, down to precise timing. Applications should prefer protocols that use authenticated encryption rather than plain encryption. If the application must perform a decryption of unauthenticated data, the application writer should take care not to reveal whether the padding is invalid.</p>
+</div>
+<p>Implementations should strive to make valid and invalid padding as close as possible to indistinguishable to an external observer. In particular, the timing of a decryption operation should not depend on the validity of the padding.</p>
+</div>
+<div class="section" id="PSA_ERROR_INSUFFICIENT_DATA">
+<span id="c.PSA_ERROR_INSUFFICIENT_DATA"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_DATA</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ERROR_INSUFFICIENT_DATA ((psa_status_t)-143)</span>
+</pre></div>
+</div>
+<p>Return this error when there’s insufficient data when attempting to read from a resource.</p>
+</div>
+<div class="section" id="PSA_ERROR_INVALID_HANDLE">
+<span id="c.PSA_ERROR_INVALID_HANDLE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_HANDLE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ERROR_INVALID_HANDLE ((psa_status_t)-136)</span>
+</pre></div>
+</div>
+<p>The key handle is not valid.</p>
+</div>
+</div>
+<div class="section" id="key-and-algorithm-types">
+<h1>Key and algorithm types</h1>
+<div class="section" id="psa_key_type_t">
+<span id="c.psa_key_type_t"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_key_type_t</span></code> (type)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="k">typedef</span> <span class="kt">uint32_t</span> <span class="n">psa_key_type_t</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>Encoding of a key type.</p>
+</div>
+<div class="section" id="psa_ecc_curve_t">
+<span id="c.psa_ecc_curve_t"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_ecc_curve_t</span></code> (type)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="k">typedef</span> <span class="kt">uint16_t</span> <span class="n">psa_ecc_curve_t</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>The type of PSA elliptic curve identifiers.</p>
+</div>
+<div class="section" id="psa_dh_group_t">
+<span id="c.psa_dh_group_t"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_dh_group_t</span></code> (type)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="k">typedef</span> <span class="kt">uint16_t</span> <span class="n">psa_dh_group_t</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>The type of PSA Diffie-Hellman group identifiers.</p>
+</div>
+<div class="section" id="psa_algorithm_t">
+<span id="c.psa_algorithm_t"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code> (type)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="k">typedef</span> <span class="kt">uint32_t</span> <span class="n">psa_algorithm_t</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>Encoding of a cryptographic algorithm.</p>
+<p>For algorithms that can be applied to multiple key types, this type does not encode the key type. For example, for symmetric ciphers based on a block cipher, <a class="reference internal" href="#c.psa_algorithm_t" title="psa_algorithm_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code></a> encodes the block cipher mode and the padding mode while the block cipher itself is encoded via <a class="reference internal" href="#c.psa_key_type_t" title="psa_key_type_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_key_type_t</span></code></a>.</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_NONE">
+<span id="c.PSA_KEY_TYPE_NONE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_NONE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_NONE ((psa_key_type_t)0x00000000)</span>
+</pre></div>
+</div>
+<p>An invalid key type value.</p>
+<p>Zero is not the encoding of any key type.</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_VENDOR_FLAG">
+<span id="c.PSA_KEY_TYPE_VENDOR_FLAG"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_VENDOR_FLAG</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_VENDOR_FLAG ((psa_key_type_t)0x80000000)</span>
+</pre></div>
+</div>
+<p>Vendor-defined flag.</p>
+<p>Key types defined by this standard will never have the <a class="reference internal" href="#c.PSA_KEY_TYPE_VENDOR_FLAG" title="PSA_KEY_TYPE_VENDOR_FLAG"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_VENDOR_FLAG</span></code></a> bit set. Vendors who define additional key types must use an encoding with the <a class="reference internal" href="#c.PSA_KEY_TYPE_VENDOR_FLAG" title="PSA_KEY_TYPE_VENDOR_FLAG"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_VENDOR_FLAG</span></code></a> bit set and should respect the bitwise structure used by standard encodings whenever practical.</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_CATEGORY_MASK">
+<span id="c.PSA_KEY_TYPE_CATEGORY_MASK"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_CATEGORY_MASK</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_CATEGORY_MASK ((psa_key_type_t)0x70000000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_KEY_TYPE_CATEGORY_SYMMETRIC">
+<span id="c.PSA_KEY_TYPE_CATEGORY_SYMMETRIC"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_CATEGORY_SYMMETRIC</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_CATEGORY_SYMMETRIC ((psa_key_type_t)0x40000000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_KEY_TYPE_CATEGORY_RAW">
+<span id="c.PSA_KEY_TYPE_CATEGORY_RAW"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_CATEGORY_RAW</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_CATEGORY_RAW ((psa_key_type_t)0x50000000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY">
+<span id="c.PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY ((psa_key_type_t)0x60000000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_KEY_TYPE_CATEGORY_KEY_PAIR">
+<span id="c.PSA_KEY_TYPE_CATEGORY_KEY_PAIR"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_CATEGORY_KEY_PAIR</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_CATEGORY_KEY_PAIR ((psa_key_type_t)0x70000000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_KEY_TYPE_CATEGORY_FLAG_PAIR">
+<span id="c.PSA_KEY_TYPE_CATEGORY_FLAG_PAIR"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_CATEGORY_FLAG_PAIR</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_CATEGORY_FLAG_PAIR ((psa_key_type_t)0x10000000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_KEY_TYPE_IS_VENDOR_DEFINED">
+<span id="c.PSA_KEY_TYPE_IS_VENDOR_DEFINED"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_VENDOR_DEFINED</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_IS_VENDOR_DEFINED(type) \</span>
+<span class="cp"> (((type) & PSA_KEY_TYPE_VENDOR_FLAG) != 0)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">type</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether a key type is vendor-defined.</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_IS_UNSTRUCTURED">
+<span id="c.PSA_KEY_TYPE_IS_UNSTRUCTURED"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_UNSTRUCTURED</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_IS_UNSTRUCTURED(type) \</span>
+<span class="cp"> (((type) & PSA_KEY_TYPE_CATEGORY_MASK & ~(psa_key_type_t)0x10000000) == PSA_KEY_TYPE_CATEGORY_SYMMETRIC)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">type</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether a key type is an unstructured array of bytes.</p>
+<p>This encompasses both symmetric keys and non-key data.</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_IS_ASYMMETRIC">
+<span id="c.PSA_KEY_TYPE_IS_ASYMMETRIC"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_ASYMMETRIC</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_IS_ASYMMETRIC(type) \</span>
+<span class="cp"> (((type) & PSA_KEY_TYPE_CATEGORY_MASK & ~PSA_KEY_TYPE_CATEGORY_FLAG_PAIR) == PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">type</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether a key type is asymmetric: either a key pair or a public key.</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_IS_PUBLIC_KEY">
+<span id="c.PSA_KEY_TYPE_IS_PUBLIC_KEY"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_PUBLIC_KEY</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_IS_PUBLIC_KEY(type) \</span>
+<span class="cp"> (((type) & PSA_KEY_TYPE_CATEGORY_MASK) == PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">type</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether a key type is the public part of a key pair.</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_IS_KEY_PAIR">
+<span id="c.PSA_KEY_TYPE_IS_KEY_PAIR"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_KEY_PAIR</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_IS_KEY_PAIR(type) \</span>
+<span class="cp"> (((type) & PSA_KEY_TYPE_CATEGORY_MASK) == PSA_KEY_TYPE_CATEGORY_KEY_PAIR)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">type</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether a key type is a key pair containing a private part and a public part.</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_KEY_PAIR_OF_PUBLIC_KEY">
+<span id="c.PSA_KEY_TYPE_KEY_PAIR_OF_PUBLIC_KEY"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_KEY_PAIR_OF_PUBLIC_KEY</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_KEY_PAIR_OF_PUBLIC_KEY(type) \</span>
+<span class="cp"> ((type) | PSA_KEY_TYPE_CATEGORY_FLAG_PAIR)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">type</span></code></dt>
+<dd>A public key type or key pair type.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>The corresponding key pair type. If <code class="docutils literal notranslate"><span class="pre">type</span></code> is not a public key or a key pair, the return value is undefined.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>The key pair type corresponding to a public key type.</p>
+<p>You may also pass a key pair type as <code class="docutils literal notranslate"><span class="pre">type</span></code>, it will be left unchanged.</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR">
+<span id="c.PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR(type) \</span>
+<span class="cp"> ((type) & ~PSA_KEY_TYPE_CATEGORY_FLAG_PAIR)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">type</span></code></dt>
+<dd>A public key type or key pair type.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>The corresponding public key type. If <code class="docutils literal notranslate"><span class="pre">type</span></code> is not a public key or a key pair, the return value is undefined.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>The public key type corresponding to a key pair type.</p>
+<p>You may also pass a key pair type as <code class="docutils literal notranslate"><span class="pre">type</span></code>, it will be left unchanged.</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_RAW_DATA">
+<span id="c.PSA_KEY_TYPE_RAW_DATA"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_RAW_DATA</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_RAW_DATA ((psa_key_type_t)0x50000001)</span>
+</pre></div>
+</div>
+<p>Raw data.</p>
+<p>A “key” of this type cannot be used for any cryptographic operation. Applications may use this type to store arbitrary data in the keystore.</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_HMAC">
+<span id="c.PSA_KEY_TYPE_HMAC"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_HMAC</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_HMAC ((psa_key_type_t)0x51000000)</span>
+</pre></div>
+</div>
+<p>HMAC key.</p>
+<p>The key policy determines which underlying hash algorithm the key can be used for.</p>
+<p>HMAC keys should generally have the same size as the underlying hash. This size can be calculated with <a class="reference internal" href="#c.PSA_HASH_SIZE" title="PSA_HASH_SIZE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_HASH_SIZE</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) where <code class="docutils literal notranslate"><span class="pre">alg</span></code> is the HMAC algorithm or the underlying hash algorithm.</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_DERIVE">
+<span id="c.PSA_KEY_TYPE_DERIVE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_DERIVE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_DERIVE ((psa_key_type_t)0x52000000)</span>
+</pre></div>
+</div>
+<p>A secret for key derivation.</p>
+<p>The key policy determines which key derivation algorithm the key can be used for.</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_AES">
+<span id="c.PSA_KEY_TYPE_AES"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_AES</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_AES ((psa_key_type_t)0x40000001)</span>
+</pre></div>
+</div>
+<p>Key for a cipher, AEAD or MAC algorithm based on the AES block cipher.</p>
+<p>The size of the key can be 16 bytes (AES-128), 24 bytes (AES-192) or 32 bytes (AES-256).</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_DES">
+<span id="c.PSA_KEY_TYPE_DES"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_DES</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_DES ((psa_key_type_t)0x40000002)</span>
+</pre></div>
+</div>
+<p>Key for a cipher or MAC algorithm based on DES or 3DES (Triple-DES).</p>
+<p>The size of the key can be 8 bytes (single DES), 16 bytes (2-key 3DES) or 24 bytes (3-key 3DES).</p>
+<p>Note that single DES and 2-key 3DES are weak and strongly deprecated and should only be used to decrypt legacy data. 3-key 3DES is weak and deprecated and should only be used in legacy protocols.</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_CAMELLIA">
+<span id="c.PSA_KEY_TYPE_CAMELLIA"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_CAMELLIA</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_CAMELLIA ((psa_key_type_t)0x40000003)</span>
+</pre></div>
+</div>
+<p>Key for a cipher, AEAD or MAC algorithm based on the Camellia block cipher.</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_ARC4">
+<span id="c.PSA_KEY_TYPE_ARC4"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_ARC4</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_ARC4 ((psa_key_type_t)0x40000004)</span>
+</pre></div>
+</div>
+<p>Key for the RC4 stream cipher.</p>
+<p>Note that RC4 is weak and deprecated and should only be used in legacy protocols.</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_CHACHA20">
+<span id="c.PSA_KEY_TYPE_CHACHA20"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_CHACHA20</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_CHACHA20 ((psa_key_type_t)0x40000005)</span>
+</pre></div>
+</div>
+<p>Key for the ChaCha20 stream cipher or the Chacha20-Poly1305 AEAD algorithm.</p>
+<p>ChaCha20 and the ChaCha20_Poly1305 construction are defined in RFC 7539.</p>
+<p>Implementations must support 12-byte nonces, may support 8-byte nonces, and should reject other sizes.</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_RSA_PUBLIC_KEY">
+<span id="c.PSA_KEY_TYPE_RSA_PUBLIC_KEY"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_RSA_PUBLIC_KEY</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_RSA_PUBLIC_KEY ((psa_key_type_t)0x60010000)</span>
+</pre></div>
+</div>
+<p>RSA public key.</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_RSA_KEY_PAIR">
+<span id="c.PSA_KEY_TYPE_RSA_KEY_PAIR"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_RSA_KEY_PAIR</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_RSA_KEY_PAIR ((psa_key_type_t)0x70010000)</span>
+</pre></div>
+</div>
+<p>RSA key pair (private and public key).</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_IS_RSA">
+<span id="c.PSA_KEY_TYPE_IS_RSA"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_RSA</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_IS_RSA(type) \</span>
+<span class="cp"> (PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR(type) == PSA_KEY_TYPE_RSA_PUBLIC_KEY)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">type</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether a key type is an RSA key (pair or public-only).</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE">
+<span id="c.PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE ((psa_key_type_t)0x60030000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_KEY_TYPE_ECC_KEY_PAIR_BASE">
+<span id="c.PSA_KEY_TYPE_ECC_KEY_PAIR_BASE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_ECC_KEY_PAIR_BASE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_ECC_KEY_PAIR_BASE ((psa_key_type_t)0x70030000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_KEY_TYPE_ECC_CURVE_MASK">
+<span id="c.PSA_KEY_TYPE_ECC_CURVE_MASK"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_ECC_CURVE_MASK</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_ECC_CURVE_MASK ((psa_key_type_t)0x0000ffff)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_KEY_TYPE_ECC_KEY_PAIR">
+<span id="c.PSA_KEY_TYPE_ECC_KEY_PAIR"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_ECC_KEY_PAIR</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_ECC_KEY_PAIR(curve) \</span>
+<span class="cp"> (PSA_KEY_TYPE_ECC_KEY_PAIR_BASE | (curve))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">curve</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Elliptic curve key pair.</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_ECC_PUBLIC_KEY">
+<span id="c.PSA_KEY_TYPE_ECC_PUBLIC_KEY"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_ECC_PUBLIC_KEY</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_ECC_PUBLIC_KEY(curve) \</span>
+<span class="cp"> (PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE | (curve))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">curve</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Elliptic curve public key.</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_IS_ECC">
+<span id="c.PSA_KEY_TYPE_IS_ECC"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_ECC</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_IS_ECC(type) \</span>
+<span class="cp"> ((PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR(type) & ~PSA_KEY_TYPE_ECC_CURVE_MASK) == PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">type</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether a key type is an elliptic curve key (pair or public-only).</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_IS_ECC_KEY_PAIR">
+<span id="c.PSA_KEY_TYPE_IS_ECC_KEY_PAIR"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_ECC_KEY_PAIR</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_IS_ECC_KEY_PAIR(type) \</span>
+<span class="cp"> (((type) & ~PSA_KEY_TYPE_ECC_CURVE_MASK) == PSA_KEY_TYPE_ECC_KEY_PAIR_BASE)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">type</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether a key type is an elliptic curve key pair.</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY">
+<span id="c.PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY(type) \</span>
+<span class="cp"> (((type) & ~PSA_KEY_TYPE_ECC_CURVE_MASK) == PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">type</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether a key type is an elliptic curve public key.</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_GET_CURVE">
+<span id="c.PSA_KEY_TYPE_GET_CURVE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_GET_CURVE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_GET_CURVE(type) \</span>
+<span class="cp"> ((psa_ecc_curve_t) (PSA_KEY_TYPE_IS_ECC(type) ? ((type) & PSA_KEY_TYPE_ECC_CURVE_MASK) : 0))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">type</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Extract the curve from an elliptic curve key type.</p>
+</div>
+<div class="section" id="PSA_ECC_CURVE_SECT163K1">
+<span id="c.PSA_ECC_CURVE_SECT163K1"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT163K1</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_SECT163K1 ((psa_ecc_curve_t) 0x0001)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ECC_CURVE_SECT163R1">
+<span id="c.PSA_ECC_CURVE_SECT163R1"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT163R1</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_SECT163R1 ((psa_ecc_curve_t) 0x0002)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ECC_CURVE_SECT163R2">
+<span id="c.PSA_ECC_CURVE_SECT163R2"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT163R2</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_SECT163R2 ((psa_ecc_curve_t) 0x0003)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ECC_CURVE_SECT193R1">
+<span id="c.PSA_ECC_CURVE_SECT193R1"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT193R1</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_SECT193R1 ((psa_ecc_curve_t) 0x0004)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ECC_CURVE_SECT193R2">
+<span id="c.PSA_ECC_CURVE_SECT193R2"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT193R2</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_SECT193R2 ((psa_ecc_curve_t) 0x0005)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ECC_CURVE_SECT233K1">
+<span id="c.PSA_ECC_CURVE_SECT233K1"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT233K1</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_SECT233K1 ((psa_ecc_curve_t) 0x0006)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ECC_CURVE_SECT233R1">
+<span id="c.PSA_ECC_CURVE_SECT233R1"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT233R1</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_SECT233R1 ((psa_ecc_curve_t) 0x0007)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ECC_CURVE_SECT239K1">
+<span id="c.PSA_ECC_CURVE_SECT239K1"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT239K1</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_SECT239K1 ((psa_ecc_curve_t) 0x0008)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ECC_CURVE_SECT283K1">
+<span id="c.PSA_ECC_CURVE_SECT283K1"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT283K1</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_SECT283K1 ((psa_ecc_curve_t) 0x0009)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ECC_CURVE_SECT283R1">
+<span id="c.PSA_ECC_CURVE_SECT283R1"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT283R1</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_SECT283R1 ((psa_ecc_curve_t) 0x000a)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ECC_CURVE_SECT409K1">
+<span id="c.PSA_ECC_CURVE_SECT409K1"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT409K1</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_SECT409K1 ((psa_ecc_curve_t) 0x000b)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ECC_CURVE_SECT409R1">
+<span id="c.PSA_ECC_CURVE_SECT409R1"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT409R1</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_SECT409R1 ((psa_ecc_curve_t) 0x000c)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ECC_CURVE_SECT571K1">
+<span id="c.PSA_ECC_CURVE_SECT571K1"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT571K1</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_SECT571K1 ((psa_ecc_curve_t) 0x000d)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ECC_CURVE_SECT571R1">
+<span id="c.PSA_ECC_CURVE_SECT571R1"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT571R1</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_SECT571R1 ((psa_ecc_curve_t) 0x000e)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ECC_CURVE_SECP160K1">
+<span id="c.PSA_ECC_CURVE_SECP160K1"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP160K1</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_SECP160K1 ((psa_ecc_curve_t) 0x000f)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ECC_CURVE_SECP160R1">
+<span id="c.PSA_ECC_CURVE_SECP160R1"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP160R1</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_SECP160R1 ((psa_ecc_curve_t) 0x0010)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ECC_CURVE_SECP160R2">
+<span id="c.PSA_ECC_CURVE_SECP160R2"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP160R2</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_SECP160R2 ((psa_ecc_curve_t) 0x0011)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ECC_CURVE_SECP192K1">
+<span id="c.PSA_ECC_CURVE_SECP192K1"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP192K1</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_SECP192K1 ((psa_ecc_curve_t) 0x0012)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ECC_CURVE_SECP192R1">
+<span id="c.PSA_ECC_CURVE_SECP192R1"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP192R1</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_SECP192R1 ((psa_ecc_curve_t) 0x0013)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ECC_CURVE_SECP224K1">
+<span id="c.PSA_ECC_CURVE_SECP224K1"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP224K1</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_SECP224K1 ((psa_ecc_curve_t) 0x0014)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ECC_CURVE_SECP224R1">
+<span id="c.PSA_ECC_CURVE_SECP224R1"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP224R1</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_SECP224R1 ((psa_ecc_curve_t) 0x0015)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ECC_CURVE_SECP256K1">
+<span id="c.PSA_ECC_CURVE_SECP256K1"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP256K1</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_SECP256K1 ((psa_ecc_curve_t) 0x0016)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ECC_CURVE_SECP256R1">
+<span id="c.PSA_ECC_CURVE_SECP256R1"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP256R1</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_SECP256R1 ((psa_ecc_curve_t) 0x0017)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ECC_CURVE_SECP384R1">
+<span id="c.PSA_ECC_CURVE_SECP384R1"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP384R1</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_SECP384R1 ((psa_ecc_curve_t) 0x0018)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ECC_CURVE_SECP521R1">
+<span id="c.PSA_ECC_CURVE_SECP521R1"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP521R1</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_SECP521R1 ((psa_ecc_curve_t) 0x0019)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ECC_CURVE_BRAINPOOL_P256R1">
+<span id="c.PSA_ECC_CURVE_BRAINPOOL_P256R1"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_BRAINPOOL_P256R1</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_BRAINPOOL_P256R1 ((psa_ecc_curve_t) 0x001a)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ECC_CURVE_BRAINPOOL_P384R1">
+<span id="c.PSA_ECC_CURVE_BRAINPOOL_P384R1"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_BRAINPOOL_P384R1</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_BRAINPOOL_P384R1 ((psa_ecc_curve_t) 0x001b)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ECC_CURVE_BRAINPOOL_P512R1">
+<span id="c.PSA_ECC_CURVE_BRAINPOOL_P512R1"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_BRAINPOOL_P512R1</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_BRAINPOOL_P512R1 ((psa_ecc_curve_t) 0x001c)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ECC_CURVE_CURVE25519">
+<span id="c.PSA_ECC_CURVE_CURVE25519"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_CURVE25519</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_CURVE25519 ((psa_ecc_curve_t) 0x001d)</span>
+</pre></div>
+</div>
+<p>Curve25519.</p>
+<p>This is the curve defined in Bernstein et al., <em>Curve25519: new Diffie-Hellman speed records</em>, LNCS 3958, 2006. The algorithm <a class="reference internal" href="#c.PSA_ALG_ECDH" title="PSA_ALG_ECDH"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_ECDH</span></code></a> performs X25519 when used with this curve.</p>
+</div>
+<div class="section" id="PSA_ECC_CURVE_CURVE448">
+<span id="c.PSA_ECC_CURVE_CURVE448"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_CURVE448</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_CURVE448 ((psa_ecc_curve_t) 0x001e)</span>
+</pre></div>
+</div>
+<p>Curve448.</p>
+<p>This is the curve defined in Hamburg, <em>Ed448-Goldilocks, a new elliptic curve</em>, NIST ECC Workshop, 2015. The algorithm <a class="reference internal" href="#c.PSA_ALG_ECDH" title="PSA_ALG_ECDH"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_ECDH</span></code></a> performs X448 when used with this curve.</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_DH_PUBLIC_KEY_BASE">
+<span id="c.PSA_KEY_TYPE_DH_PUBLIC_KEY_BASE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_DH_PUBLIC_KEY_BASE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_DH_PUBLIC_KEY_BASE ((psa_key_type_t)0x60040000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_KEY_TYPE_DH_KEY_PAIR_BASE">
+<span id="c.PSA_KEY_TYPE_DH_KEY_PAIR_BASE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_DH_KEY_PAIR_BASE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_DH_KEY_PAIR_BASE ((psa_key_type_t)0x70040000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_KEY_TYPE_DH_GROUP_MASK">
+<span id="c.PSA_KEY_TYPE_DH_GROUP_MASK"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_DH_GROUP_MASK</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_DH_GROUP_MASK ((psa_key_type_t)0x0000ffff)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_KEY_TYPE_DH_KEY_PAIR">
+<span id="c.PSA_KEY_TYPE_DH_KEY_PAIR"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_DH_KEY_PAIR</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_DH_KEY_PAIR(group) \</span>
+<span class="cp"> (PSA_KEY_TYPE_DH_KEY_PAIR_BASE | (group))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">group</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Diffie-Hellman key pair.</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_DH_PUBLIC_KEY">
+<span id="c.PSA_KEY_TYPE_DH_PUBLIC_KEY"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_DH_PUBLIC_KEY</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_DH_PUBLIC_KEY(group) \</span>
+<span class="cp"> (PSA_KEY_TYPE_DH_PUBLIC_KEY_BASE | (group))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">group</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Diffie-Hellman public key.</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_IS_DH">
+<span id="c.PSA_KEY_TYPE_IS_DH"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_DH</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_IS_DH(type) \</span>
+<span class="cp"> ((PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR(type) & ~PSA_KEY_TYPE_DH_GROUP_MASK) == PSA_KEY_TYPE_DH_PUBLIC_KEY_BASE)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">type</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether a key type is a Diffie-Hellman key (pair or public-only).</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_IS_DH_KEY_PAIR">
+<span id="c.PSA_KEY_TYPE_IS_DH_KEY_PAIR"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_DH_KEY_PAIR</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_IS_DH_KEY_PAIR(type) \</span>
+<span class="cp"> (((type) & ~PSA_KEY_TYPE_DH_GROUP_MASK) == PSA_KEY_TYPE_DH_KEY_PAIR_BASE)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">type</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether a key type is a Diffie-Hellman key pair.</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_IS_DH_PUBLIC_KEY">
+<span id="c.PSA_KEY_TYPE_IS_DH_PUBLIC_KEY"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_DH_PUBLIC_KEY</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_IS_DH_PUBLIC_KEY(type) \</span>
+<span class="cp"> (((type) & ~PSA_KEY_TYPE_DH_GROUP_MASK) == PSA_KEY_TYPE_DH_PUBLIC_KEY_BASE)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">type</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether a key type is a Diffie-Hellman public key.</p>
+</div>
+<div class="section" id="PSA_KEY_TYPE_GET_GROUP">
+<span id="c.PSA_KEY_TYPE_GET_GROUP"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_GET_GROUP</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_TYPE_GET_GROUP(type) \</span>
+<span class="cp"> ((psa_dh_group_t) (PSA_KEY_TYPE_IS_DH(type) ? ((type) & PSA_KEY_TYPE_DH_GROUP_MASK) : 0))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">type</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Extract the group from a Diffie-Hellman key type.</p>
+</div>
+<div class="section" id="PSA_DH_GROUP_FFDHE2048">
+<span id="c.PSA_DH_GROUP_FFDHE2048"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_DH_GROUP_FFDHE2048</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_DH_GROUP_FFDHE2048 ((psa_dh_group_t) 0x0100)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_DH_GROUP_FFDHE3072">
+<span id="c.PSA_DH_GROUP_FFDHE3072"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_DH_GROUP_FFDHE3072</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_DH_GROUP_FFDHE3072 ((psa_dh_group_t) 0x0101)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_DH_GROUP_FFDHE4096">
+<span id="c.PSA_DH_GROUP_FFDHE4096"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_DH_GROUP_FFDHE4096</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_DH_GROUP_FFDHE4096 ((psa_dh_group_t) 0x0102)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_DH_GROUP_FFDHE6144">
+<span id="c.PSA_DH_GROUP_FFDHE6144"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_DH_GROUP_FFDHE6144</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_DH_GROUP_FFDHE6144 ((psa_dh_group_t) 0x0103)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_DH_GROUP_FFDHE8192">
+<span id="c.PSA_DH_GROUP_FFDHE8192"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_DH_GROUP_FFDHE8192</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_DH_GROUP_FFDHE8192 ((psa_dh_group_t) 0x0104)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_BLOCK_CIPHER_BLOCK_SIZE">
+<span id="c.PSA_BLOCK_CIPHER_BLOCK_SIZE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_BLOCK_CIPHER_BLOCK_SIZE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_BLOCK_CIPHER_BLOCK_SIZE(type) \</span>
+<span class="cp"> ( (type) == PSA_KEY_TYPE_AES ? 16 : (type) == PSA_KEY_TYPE_DES ? 8 : (type) == PSA_KEY_TYPE_CAMELLIA ? 16 : (type) == PSA_KEY_TYPE_ARC4 ? 1 : 0)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">type</span></code></dt>
+<dd>A cipher key type (value of type <a class="reference internal" href="#c.psa_key_type_t" title="psa_key_type_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_key_type_t</span></code></a>).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>The block size for a block cipher, or 1 for a stream cipher. The return value is undefined if <code class="docutils literal notranslate"><span class="pre">type</span></code> is not a supported cipher key type.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>The block size of a block cipher.</p>
+<div class="admonition note">
+<p class="first admonition-title">Note</p>
+<p class="last">It is possible to build stream cipher algorithms on top of a block cipher, for example CTR mode (<a class="reference internal" href="#c.PSA_ALG_CTR" title="PSA_ALG_CTR"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_CTR</span></code></a>). This macro only takes the key type into account, so it cannot be used to determine the size of the data that <a class="reference internal" href="#c.psa_cipher_update" title="psa_cipher_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_update()</span></code></a> might buffer for future processing in general.</p>
+</div>
+<div class="admonition note">
+<p class="first admonition-title">Note</p>
+<p class="last">This macro returns a compile-time constant if its argument is one.</p>
+</div>
+<div class="admonition warning">
+<p class="first admonition-title">Warning</p>
+<p class="last">This macro may evaluate its argument multiple times.</p>
+</div>
+</div>
+<div class="section" id="PSA_ALG_VENDOR_FLAG">
+<span id="c.PSA_ALG_VENDOR_FLAG"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_VENDOR_FLAG</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_VENDOR_FLAG ((psa_algorithm_t)0x80000000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_CATEGORY_MASK">
+<span id="c.PSA_ALG_CATEGORY_MASK"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CATEGORY_MASK</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_CATEGORY_MASK ((psa_algorithm_t)0x7f000000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_CATEGORY_HASH">
+<span id="c.PSA_ALG_CATEGORY_HASH"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CATEGORY_HASH</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_CATEGORY_HASH ((psa_algorithm_t)0x01000000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_CATEGORY_MAC">
+<span id="c.PSA_ALG_CATEGORY_MAC"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CATEGORY_MAC</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_CATEGORY_MAC ((psa_algorithm_t)0x02000000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_CATEGORY_CIPHER">
+<span id="c.PSA_ALG_CATEGORY_CIPHER"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CATEGORY_CIPHER</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_CATEGORY_CIPHER ((psa_algorithm_t)0x04000000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_CATEGORY_AEAD">
+<span id="c.PSA_ALG_CATEGORY_AEAD"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CATEGORY_AEAD</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_CATEGORY_AEAD ((psa_algorithm_t)0x06000000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_CATEGORY_SIGN">
+<span id="c.PSA_ALG_CATEGORY_SIGN"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CATEGORY_SIGN</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_CATEGORY_SIGN ((psa_algorithm_t)0x10000000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION">
+<span id="c.PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION ((psa_algorithm_t)0x12000000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_CATEGORY_KEY_DERIVATION">
+<span id="c.PSA_ALG_CATEGORY_KEY_DERIVATION"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CATEGORY_KEY_DERIVATION</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_CATEGORY_KEY_DERIVATION ((psa_algorithm_t)0x20000000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_CATEGORY_KEY_AGREEMENT">
+<span id="c.PSA_ALG_CATEGORY_KEY_AGREEMENT"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CATEGORY_KEY_AGREEMENT</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_CATEGORY_KEY_AGREEMENT ((psa_algorithm_t)0x30000000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_IS_VENDOR_DEFINED">
+<span id="c.PSA_ALG_IS_VENDOR_DEFINED"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_VENDOR_DEFINED</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_IS_VENDOR_DEFINED(alg) (((alg) & PSA_ALG_VENDOR_FLAG) != 0)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+</div>
+<div class="section" id="PSA_ALG_IS_HASH">
+<span id="c.PSA_ALG_IS_HASH"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_HASH</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_IS_HASH(alg) \</span>
+<span class="cp"> (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_HASH)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>An algorithm identifier (value of type <a class="reference internal" href="#c.psa_algorithm_t" title="psa_algorithm_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code></a>).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is a hash algorithm, 0 otherwise. This macro may return either 0 or 1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is not a supported algorithm identifier.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether the specified algorithm is a hash algorithm.</p>
+</div>
+<div class="section" id="PSA_ALG_IS_MAC">
+<span id="c.PSA_ALG_IS_MAC"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_MAC</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_IS_MAC(alg) \</span>
+<span class="cp"> (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_MAC)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>An algorithm identifier (value of type <a class="reference internal" href="#c.psa_algorithm_t" title="psa_algorithm_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code></a>).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is a MAC algorithm, 0 otherwise. This macro may return either 0 or 1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is not a supported algorithm identifier.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether the specified algorithm is a MAC algorithm.</p>
+</div>
+<div class="section" id="PSA_ALG_IS_CIPHER">
+<span id="c.PSA_ALG_IS_CIPHER"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_CIPHER</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_IS_CIPHER(alg) \</span>
+<span class="cp"> (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_CIPHER)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>An algorithm identifier (value of type <a class="reference internal" href="#c.psa_algorithm_t" title="psa_algorithm_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code></a>).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is a symmetric cipher algorithm, 0 otherwise. This macro may return either 0 or 1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is not a supported algorithm identifier.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether the specified algorithm is a symmetric cipher algorithm.</p>
+</div>
+<div class="section" id="PSA_ALG_IS_AEAD">
+<span id="c.PSA_ALG_IS_AEAD"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_AEAD</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_IS_AEAD(alg) \</span>
+<span class="cp"> (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_AEAD)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>An algorithm identifier (value of type <a class="reference internal" href="#c.psa_algorithm_t" title="psa_algorithm_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code></a>).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is an AEAD algorithm, 0 otherwise. This macro may return either 0 or 1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is not a supported algorithm identifier.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether the specified algorithm is an authenticated encryption with associated data (AEAD) algorithm.</p>
+</div>
+<div class="section" id="PSA_ALG_IS_SIGN">
+<span id="c.PSA_ALG_IS_SIGN"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_SIGN</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_IS_SIGN(alg) \</span>
+<span class="cp"> (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_SIGN)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>An algorithm identifier (value of type <a class="reference internal" href="#c.psa_algorithm_t" title="psa_algorithm_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code></a>).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is a public-key signature algorithm, 0 otherwise. This macro may return either 0 or 1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is not a supported algorithm identifier.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether the specified algorithm is a public-key signature algorithm.</p>
+</div>
+<div class="section" id="PSA_ALG_IS_ASYMMETRIC_ENCRYPTION">
+<span id="c.PSA_ALG_IS_ASYMMETRIC_ENCRYPTION"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_ASYMMETRIC_ENCRYPTION</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_IS_ASYMMETRIC_ENCRYPTION(alg) \</span>
+<span class="cp"> (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>An algorithm identifier (value of type <a class="reference internal" href="#c.psa_algorithm_t" title="psa_algorithm_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code></a>).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is a public-key encryption algorithm, 0 otherwise. This macro may return either 0 or 1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is not a supported algorithm identifier.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether the specified algorithm is a public-key encryption algorithm.</p>
+</div>
+<div class="section" id="PSA_ALG_IS_KEY_AGREEMENT">
+<span id="c.PSA_ALG_IS_KEY_AGREEMENT"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_KEY_AGREEMENT</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_IS_KEY_AGREEMENT(alg) \</span>
+<span class="cp"> (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_KEY_AGREEMENT)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>An algorithm identifier (value of type <a class="reference internal" href="#c.psa_algorithm_t" title="psa_algorithm_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code></a>).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is a key agreement algorithm, 0 otherwise. This macro may return either 0 or 1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is not a supported algorithm identifier.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether the specified algorithm is a key agreement algorithm.</p>
+</div>
+<div class="section" id="PSA_ALG_IS_KEY_DERIVATION">
+<span id="c.PSA_ALG_IS_KEY_DERIVATION"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_KEY_DERIVATION</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_IS_KEY_DERIVATION(alg) \</span>
+<span class="cp"> (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_KEY_DERIVATION)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>An algorithm identifier (value of type <a class="reference internal" href="#c.psa_algorithm_t" title="psa_algorithm_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code></a>).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is a key derivation algorithm, 0 otherwise. This macro may return either 0 or 1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is not a supported algorithm identifier.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether the specified algorithm is a key derivation algorithm.</p>
+</div>
+<div class="section" id="PSA_ALG_HASH_MASK">
+<span id="c.PSA_ALG_HASH_MASK"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_HASH_MASK</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_HASH_MASK ((psa_algorithm_t)0x000000ff)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_MD2">
+<span id="c.PSA_ALG_MD2"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_MD2</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_MD2 ((psa_algorithm_t)0x01000001)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_MD4">
+<span id="c.PSA_ALG_MD4"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_MD4</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_MD4 ((psa_algorithm_t)0x01000002)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_MD5">
+<span id="c.PSA_ALG_MD5"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_MD5</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_MD5 ((psa_algorithm_t)0x01000003)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_RIPEMD160">
+<span id="c.PSA_ALG_RIPEMD160"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RIPEMD160</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_RIPEMD160 ((psa_algorithm_t)0x01000004)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_SHA_1">
+<span id="c.PSA_ALG_SHA_1"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA_1</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_SHA_1 ((psa_algorithm_t)0x01000005)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_SHA_224">
+<span id="c.PSA_ALG_SHA_224"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA_224</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_SHA_224 ((psa_algorithm_t)0x01000008)</span>
+</pre></div>
+</div>
+<p>SHA2-224.</p>
+</div>
+<div class="section" id="PSA_ALG_SHA_256">
+<span id="c.PSA_ALG_SHA_256"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA_256</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_SHA_256 ((psa_algorithm_t)0x01000009)</span>
+</pre></div>
+</div>
+<p>SHA2-256.</p>
+</div>
+<div class="section" id="PSA_ALG_SHA_384">
+<span id="c.PSA_ALG_SHA_384"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA_384</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_SHA_384 ((psa_algorithm_t)0x0100000a)</span>
+</pre></div>
+</div>
+<p>SHA2-384.</p>
+</div>
+<div class="section" id="PSA_ALG_SHA_512">
+<span id="c.PSA_ALG_SHA_512"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA_512</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_SHA_512 ((psa_algorithm_t)0x0100000b)</span>
+</pre></div>
+</div>
+<p>SHA2-512.</p>
+</div>
+<div class="section" id="PSA_ALG_SHA_512_224">
+<span id="c.PSA_ALG_SHA_512_224"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA_512_224</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_SHA_512_224 ((psa_algorithm_t)0x0100000c)</span>
+</pre></div>
+</div>
+<p>SHA2-512/224.</p>
+</div>
+<div class="section" id="PSA_ALG_SHA_512_256">
+<span id="c.PSA_ALG_SHA_512_256"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA_512_256</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_SHA_512_256 ((psa_algorithm_t)0x0100000d)</span>
+</pre></div>
+</div>
+<p>SHA2-512/256.</p>
+</div>
+<div class="section" id="PSA_ALG_SHA3_224">
+<span id="c.PSA_ALG_SHA3_224"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA3_224</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_SHA3_224 ((psa_algorithm_t)0x01000010)</span>
+</pre></div>
+</div>
+<p>SHA3-224.</p>
+</div>
+<div class="section" id="PSA_ALG_SHA3_256">
+<span id="c.PSA_ALG_SHA3_256"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA3_256</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_SHA3_256 ((psa_algorithm_t)0x01000011)</span>
+</pre></div>
+</div>
+<p>SHA3-256.</p>
+</div>
+<div class="section" id="PSA_ALG_SHA3_384">
+<span id="c.PSA_ALG_SHA3_384"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA3_384</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_SHA3_384 ((psa_algorithm_t)0x01000012)</span>
+</pre></div>
+</div>
+<p>SHA3-384.</p>
+</div>
+<div class="section" id="PSA_ALG_SHA3_512">
+<span id="c.PSA_ALG_SHA3_512"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA3_512</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_SHA3_512 ((psa_algorithm_t)0x01000013)</span>
+</pre></div>
+</div>
+<p>SHA3-512.</p>
+</div>
+<div class="section" id="PSA_ALG_ANY_HASH">
+<span id="c.PSA_ALG_ANY_HASH"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_ANY_HASH</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_ANY_HASH ((psa_algorithm_t)0x010000ff)</span>
+</pre></div>
+</div>
+<p>In a hash-and-sign algorithm policy, allow any hash algorithm.</p>
+<p>This value may be used to form the algorithm usage field of a policy for a signature algorithm that is parametrized by a hash. The key may then be used to perform operations using the same signature algorithm parametrized with any supported hash.</p>
+<p>That is, suppose that <code class="docutils literal notranslate"><span class="pre">PSA_xxx_SIGNATURE</span></code> is one of the following macros:</p>
+<ul>
+<li><p class="first"><a class="reference internal" href="#c.PSA_ALG_RSA_PKCS1V15_SIGN" title="PSA_ALG_RSA_PKCS1V15_SIGN"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_RSA_PKCS1V15_SIGN</span></code></a>, <a class="reference internal" href="#c.PSA_ALG_RSA_PSS" title="PSA_ALG_RSA_PSS"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_RSA_PSS</span></code></a>,</p>
+</li>
+<li><p class="first"><a class="reference internal" href="#c.PSA_ALG_ECDSA" title="PSA_ALG_ECDSA"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_ECDSA</span></code></a>, <a class="reference internal" href="#c.PSA_ALG_DETERMINISTIC_ECDSA" title="PSA_ALG_DETERMINISTIC_ECDSA"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_DETERMINISTIC_ECDSA</span></code></a>. Then you may create and use a key as follows:</p>
+</li>
+<li><p class="first">Set the key usage field using <a class="reference internal" href="#c.PSA_ALG_ANY_HASH" title="PSA_ALG_ANY_HASH"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_ANY_HASH</span></code></a>, for example:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_set_key_usage_flags</span><span class="p">(</span><span class="o">&</span><span class="n">attributes</span><span class="p">,</span> <span class="n">PSA_KEY_USAGE_SIGN</span><span class="p">);</span> <span class="c1">// or VERIFY</span>
+<span class="n">psa_set_key_algorithm</span><span class="p">(</span><span class="o">&</span><span class="n">attributes</span><span class="p">,</span> <span class="n">PSA_xxx_SIGNATURE</span><span class="p">(</span><span class="n">PSA_ALG_ANY_HASH</span><span class="p">));</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first">Import or generate key material.</p>
+</li>
+<li><p class="first">Call <a class="reference internal" href="#c.psa_asymmetric_sign" title="psa_asymmetric_sign"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_asymmetric_sign()</span></code></a> or <a class="reference internal" href="#c.psa_asymmetric_verify" title="psa_asymmetric_verify"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_asymmetric_verify()</span></code></a>, passing an algorithm built from <code class="docutils literal notranslate"><span class="pre">PSA_xxx_SIGNATURE</span></code> and a specific hash. Each call to sign or verify a message may use a different hash.</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_asymmetric_sign</span><span class="p">(</span><span class="n">handle</span><span class="p">,</span> <span class="n">PSA_xxx_SIGNATURE</span><span class="p">(</span><span class="n">PSA_ALG_SHA_256</span><span class="p">),</span> <span class="p">...);</span>
+<span class="n">psa_asymmetric_sign</span><span class="p">(</span><span class="n">handle</span><span class="p">,</span> <span class="n">PSA_xxx_SIGNATURE</span><span class="p">(</span><span class="n">PSA_ALG_SHA_512</span><span class="p">),</span> <span class="p">...);</span>
+<span class="n">psa_asymmetric_sign</span><span class="p">(</span><span class="n">handle</span><span class="p">,</span> <span class="n">PSA_xxx_SIGNATURE</span><span class="p">(</span><span class="n">PSA_ALG_SHA3_256</span><span class="p">),</span> <span class="p">...);</span>
+</pre></div>
+</div>
+</li>
+</ul>
+<p>This value may not be used to build other algorithms that are parametrized over a hash. For any valid use of this macro to build an algorithm <code class="docutils literal notranslate"><span class="pre">alg</span></code>, <a class="reference internal" href="#c.PSA_ALG_IS_HASH_AND_SIGN" title="PSA_ALG_IS_HASH_AND_SIGN"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_HASH_AND_SIGN</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true.</p>
+<p>This value may not be used to build an algorithm specification to perform an operation. It is only valid to build policies.</p>
+</div>
+<div class="section" id="PSA_ALG_MAC_SUBCATEGORY_MASK">
+<span id="c.PSA_ALG_MAC_SUBCATEGORY_MASK"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_MAC_SUBCATEGORY_MASK</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_MAC_SUBCATEGORY_MASK ((psa_algorithm_t)0x00c00000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_HMAC_BASE">
+<span id="c.PSA_ALG_HMAC_BASE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_HMAC_BASE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_HMAC_BASE ((psa_algorithm_t)0x02800000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_HMAC">
+<span id="c.PSA_ALG_HMAC"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_HMAC</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_HMAC(hash_alg) \</span>
+<span class="cp"> (PSA_ALG_HMAC_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">hash_alg</span></code></dt>
+<dd>A hash algorithm (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_HASH" title="PSA_ALG_IS_HASH"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_HASH</span></code></a>(<code class="docutils literal notranslate"><span class="pre">hash_alg</span></code>) is true).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>The corresponding HMAC algorithm.</p>
+<p>Unspecified if <code class="docutils literal notranslate"><span class="pre">hash_alg</span></code> is not a supported hash algorithm.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Macro to build an HMAC algorithm.</p>
+<p>For example, <a class="reference internal" href="#c.PSA_ALG_HMAC" title="PSA_ALG_HMAC"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_HMAC</span></code></a>(<a class="reference internal" href="#c.PSA_ALG_SHA_256" title="PSA_ALG_SHA_256"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_SHA_256</span></code></a>) is HMAC-SHA-256.</p>
+</div>
+<div class="section" id="PSA_ALG_HMAC_GET_HASH">
+<span id="c.PSA_ALG_HMAC_GET_HASH"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_HMAC_GET_HASH</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_HMAC_GET_HASH(hmac_alg) \</span>
+<span class="cp"> (PSA_ALG_CATEGORY_HASH | ((hmac_alg) & PSA_ALG_HASH_MASK))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">hmac_alg</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+</div>
+<div class="section" id="PSA_ALG_IS_HMAC">
+<span id="c.PSA_ALG_IS_HMAC"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_HMAC</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_IS_HMAC(alg) \</span>
+<span class="cp"> (((alg) & (PSA_ALG_CATEGORY_MASK | PSA_ALG_MAC_SUBCATEGORY_MASK)) == PSA_ALG_HMAC_BASE)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>An algorithm identifier (value of type <a class="reference internal" href="#c.psa_algorithm_t" title="psa_algorithm_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code></a>).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is an HMAC algorithm, 0 otherwise. This macro may return either 0 or 1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is not a supported algorithm identifier.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether the specified algorithm is an HMAC algorithm.</p>
+<p>HMAC is a family of MAC algorithms that are based on a hash function.</p>
+</div>
+<div class="section" id="PSA_ALG_MAC_TRUNCATION_MASK">
+<span id="c.PSA_ALG_MAC_TRUNCATION_MASK"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_MAC_TRUNCATION_MASK</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_MAC_TRUNCATION_MASK ((psa_algorithm_t)0x00003f00)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_MAC_TRUNCATION_OFFSET">
+<span id="c.PSA_MAC_TRUNCATION_OFFSET"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_MAC_TRUNCATION_OFFSET</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_MAC_TRUNCATION_OFFSET 8</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_TRUNCATED_MAC">
+<span id="c.PSA_ALG_TRUNCATED_MAC"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_TRUNCATED_MAC</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_TRUNCATED_MAC(mac_alg, mac_length) \</span>
+<span class="cp"> (((mac_alg) & ~PSA_ALG_MAC_TRUNCATION_MASK) | ((mac_length) << PSA_MAC_TRUNCATION_OFFSET & PSA_ALG_MAC_TRUNCATION_MASK))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">mac_alg</span></code></dt>
+<dd>A MAC algorithm identifier (value of type <a class="reference internal" href="#c.psa_algorithm_t" title="psa_algorithm_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code></a> such that <a class="reference internal" href="#c.PSA_ALG_IS_MAC" title="PSA_ALG_IS_MAC"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_MAC</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true). This may be a truncated or untruncated MAC algorithm.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">mac_length</span></code></dt>
+<dd>Desired length of the truncated MAC in bytes. This must be at most the full length of the MAC and must be at least an implementation-specified minimum. The implementation-specified minimum shall not be zero.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>The corresponding MAC algorithm with the specified length.</p>
+<p>Unspecified if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is not a supported MAC algorithm or if <code class="docutils literal notranslate"><span class="pre">mac_length</span></code> is too small or too large for the specified MAC algorithm.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Macro to build a truncated MAC algorithm.</p>
+<p>A truncated MAC algorithm is identical to the corresponding MAC algorithm except that the MAC value for the truncated algorithm consists of only the first <code class="docutils literal notranslate"><span class="pre">mac_length</span></code> bytes of the MAC value for the untruncated algorithm.</p>
+<div class="admonition note">
+<p class="first admonition-title">Note</p>
+<p class="last">This macro may allow constructing algorithm identifiers that are not valid, either because the specified length is larger than the untruncated MAC or because the specified length is smaller than permitted by the implementation.</p>
+</div>
+<div class="admonition note">
+<p class="first admonition-title">Note</p>
+<p class="last">It is implementation-defined whether a truncated MAC that is truncated to the same length as the MAC of the untruncated algorithm is considered identical to the untruncated algorithm for policy comparison purposes.</p>
+</div>
+</div>
+<div class="section" id="PSA_ALG_FULL_LENGTH_MAC">
+<span id="c.PSA_ALG_FULL_LENGTH_MAC"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_FULL_LENGTH_MAC</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_FULL_LENGTH_MAC(mac_alg) \</span>
+<span class="cp"> ((mac_alg) & ~PSA_ALG_MAC_TRUNCATION_MASK)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">mac_alg</span></code></dt>
+<dd>A MAC algorithm identifier (value of type <a class="reference internal" href="#c.psa_algorithm_t" title="psa_algorithm_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code></a> such that <a class="reference internal" href="#c.PSA_ALG_IS_MAC" title="PSA_ALG_IS_MAC"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_MAC</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true). This may be a truncated or untruncated MAC algorithm.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>The corresponding base MAC algorithm.</p>
+<p>Unspecified if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is not a supported MAC algorithm.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Macro to build the base MAC algorithm corresponding to a truncated MAC algorithm.</p>
+</div>
+<div class="section" id="PSA_MAC_TRUNCATED_LENGTH">
+<span id="c.PSA_MAC_TRUNCATED_LENGTH"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_MAC_TRUNCATED_LENGTH</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_MAC_TRUNCATED_LENGTH(mac_alg) \</span>
+<span class="cp"> (((mac_alg) & PSA_ALG_MAC_TRUNCATION_MASK) >> PSA_MAC_TRUNCATION_OFFSET)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">mac_alg</span></code></dt>
+<dd>A MAC algorithm identifier (value of type <a class="reference internal" href="#c.psa_algorithm_t" title="psa_algorithm_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code></a> such that <a class="reference internal" href="#c.PSA_ALG_IS_MAC" title="PSA_ALG_IS_MAC"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_MAC</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>Length of the truncated MAC in bytes.</p>
+<p>0 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is a non-truncated MAC algorithm.</p>
+<p>Unspecified if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is not a supported MAC algorithm.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Length to which a MAC algorithm is truncated.</p>
+</div>
+<div class="section" id="PSA_ALG_CIPHER_MAC_BASE">
+<span id="c.PSA_ALG_CIPHER_MAC_BASE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CIPHER_MAC_BASE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_CIPHER_MAC_BASE ((psa_algorithm_t)0x02c00000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_CBC_MAC">
+<span id="c.PSA_ALG_CBC_MAC"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CBC_MAC</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_CBC_MAC ((psa_algorithm_t)0x02c00001)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_CMAC">
+<span id="c.PSA_ALG_CMAC"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CMAC</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_CMAC ((psa_algorithm_t)0x02c00002)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_GMAC">
+<span id="c.PSA_ALG_GMAC"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_GMAC</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_GMAC ((psa_algorithm_t)0x02c00003)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_IS_BLOCK_CIPHER_MAC">
+<span id="c.PSA_ALG_IS_BLOCK_CIPHER_MAC"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_BLOCK_CIPHER_MAC</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_IS_BLOCK_CIPHER_MAC(alg) \</span>
+<span class="cp"> (((alg) & (PSA_ALG_CATEGORY_MASK | PSA_ALG_MAC_SUBCATEGORY_MASK)) == PSA_ALG_CIPHER_MAC_BASE)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>An algorithm identifier (value of type <a class="reference internal" href="#c.psa_algorithm_t" title="psa_algorithm_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code></a>).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is a MAC algorithm based on a block cipher, 0 otherwise. This macro may return either 0 or 1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is not a supported algorithm identifier.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether the specified algorithm is a MAC algorithm based on a block cipher.</p>
+</div>
+<div class="section" id="PSA_ALG_CIPHER_STREAM_FLAG">
+<span id="c.PSA_ALG_CIPHER_STREAM_FLAG"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CIPHER_STREAM_FLAG</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_CIPHER_STREAM_FLAG ((psa_algorithm_t)0x00800000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_CIPHER_FROM_BLOCK_FLAG">
+<span id="c.PSA_ALG_CIPHER_FROM_BLOCK_FLAG"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CIPHER_FROM_BLOCK_FLAG</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_CIPHER_FROM_BLOCK_FLAG ((psa_algorithm_t)0x00400000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_IS_STREAM_CIPHER">
+<span id="c.PSA_ALG_IS_STREAM_CIPHER"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_STREAM_CIPHER</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_IS_STREAM_CIPHER(alg) \</span>
+<span class="cp"> (((alg) & (PSA_ALG_CATEGORY_MASK | PSA_ALG_CIPHER_STREAM_FLAG)) == (PSA_ALG_CATEGORY_CIPHER | PSA_ALG_CIPHER_STREAM_FLAG))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>An algorithm identifier (value of type <a class="reference internal" href="#c.psa_algorithm_t" title="psa_algorithm_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code></a>).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is a stream cipher algorithm, 0 otherwise. This macro may return either 0 or 1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is not a supported algorithm identifier or if it is not a symmetric cipher algorithm.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether the specified algorithm is a stream cipher.</p>
+<p>A stream cipher is a symmetric cipher that encrypts or decrypts messages by applying a bitwise-xor with a stream of bytes that is generated from a key.</p>
+</div>
+<div class="section" id="PSA_ALG_ARC4">
+<span id="c.PSA_ALG_ARC4"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_ARC4</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_ARC4 ((psa_algorithm_t)0x04800001)</span>
+</pre></div>
+</div>
+<p>The ARC4 stream cipher algorithm.</p>
+</div>
+<div class="section" id="PSA_ALG_CHACHA20">
+<span id="c.PSA_ALG_CHACHA20"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CHACHA20</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_CHACHA20 ((psa_algorithm_t)0x04800005)</span>
+</pre></div>
+</div>
+<p>The ChaCha20 stream cipher.</p>
+<p>ChaCha20 is defined in RFC 7539.</p>
+<p>The nonce size for <a class="reference internal" href="#c.psa_cipher_set_iv" title="psa_cipher_set_iv"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_set_iv()</span></code></a> or <a class="reference internal" href="#c.psa_cipher_generate_iv" title="psa_cipher_generate_iv"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_cipher_generate_iv()</span></code></a> must be 12.</p>
+<p>The initial block counter is always 0.</p>
+</div>
+<div class="section" id="PSA_ALG_CTR">
+<span id="c.PSA_ALG_CTR"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CTR</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_CTR ((psa_algorithm_t)0x04c00001)</span>
+</pre></div>
+</div>
+<p>The CTR stream cipher mode.</p>
+<p>CTR is a stream cipher which is built from a block cipher. The underlying block cipher is determined by the key type. For example, to use AES-128-CTR, use this algorithm with a key of type <a class="reference internal" href="#c.PSA_KEY_TYPE_AES" title="PSA_KEY_TYPE_AES"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_AES</span></code></a> and a length of 128 bits (16 bytes).</p>
+</div>
+<div class="section" id="PSA_ALG_CFB">
+<span id="c.PSA_ALG_CFB"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CFB</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_CFB ((psa_algorithm_t)0x04c00002)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_OFB">
+<span id="c.PSA_ALG_OFB"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_OFB</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_OFB ((psa_algorithm_t)0x04c00003)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_XTS">
+<span id="c.PSA_ALG_XTS"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_XTS</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_XTS ((psa_algorithm_t)0x044000ff)</span>
+</pre></div>
+</div>
+<p>The XTS cipher mode.</p>
+<p>XTS is a cipher mode which is built from a block cipher. It requires at least one full block of input, but beyond this minimum the input does not need to be a whole number of blocks.</p>
+</div>
+<div class="section" id="PSA_ALG_CBC_NO_PADDING">
+<span id="c.PSA_ALG_CBC_NO_PADDING"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CBC_NO_PADDING</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_CBC_NO_PADDING ((psa_algorithm_t)0x04600100)</span>
+</pre></div>
+</div>
+<p>The CBC block cipher chaining mode, with no padding.</p>
+<p>The underlying block cipher is determined by the key type.</p>
+<p>This symmetric cipher mode can only be used with messages whose lengths are whole number of blocks for the chosen block cipher.</p>
+</div>
+<div class="section" id="PSA_ALG_CBC_PKCS7">
+<span id="c.PSA_ALG_CBC_PKCS7"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CBC_PKCS7</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_CBC_PKCS7 ((psa_algorithm_t)0x04600101)</span>
+</pre></div>
+</div>
+<p>The CBC block cipher chaining mode with PKCS#7 padding.</p>
+<p>The underlying block cipher is determined by the key type.</p>
+<p>This is the padding method defined by PKCS#7 (RFC 2315) §10.3.</p>
+</div>
+<div class="section" id="PSA_ALG_AEAD_FROM_BLOCK_FLAG">
+<span id="c.PSA_ALG_AEAD_FROM_BLOCK_FLAG"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_AEAD_FROM_BLOCK_FLAG</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_AEAD_FROM_BLOCK_FLAG ((psa_algorithm_t)0x00400000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_IS_AEAD_ON_BLOCK_CIPHER">
+<span id="c.PSA_ALG_IS_AEAD_ON_BLOCK_CIPHER"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_AEAD_ON_BLOCK_CIPHER</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_IS_AEAD_ON_BLOCK_CIPHER(alg) \</span>
+<span class="cp"> (((alg) & (PSA_ALG_CATEGORY_MASK | PSA_ALG_AEAD_FROM_BLOCK_FLAG)) == (PSA_ALG_CATEGORY_AEAD | PSA_ALG_AEAD_FROM_BLOCK_FLAG))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>An algorithm identifier (value of type <a class="reference internal" href="#c.psa_algorithm_t" title="psa_algorithm_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code></a>).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is an AEAD algorithm which is an AEAD mode based on a block cipher, 0 otherwise. This macro may return either 0 or 1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is not a supported algorithm identifier.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether the specified algorithm is an AEAD mode on a block cipher.</p>
+</div>
+<div class="section" id="PSA_ALG_CCM">
+<span id="c.PSA_ALG_CCM"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CCM</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_CCM ((psa_algorithm_t)0x06401001)</span>
+</pre></div>
+</div>
+<p>The CCM authenticated encryption algorithm.</p>
+</div>
+<div class="section" id="PSA_ALG_GCM">
+<span id="c.PSA_ALG_GCM"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_GCM</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_GCM ((psa_algorithm_t)0x06401002)</span>
+</pre></div>
+</div>
+<p>The GCM authenticated encryption algorithm.</p>
+</div>
+<div class="section" id="PSA_ALG_CHACHA20_POLY1305">
+<span id="c.PSA_ALG_CHACHA20_POLY1305"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CHACHA20_POLY1305</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_CHACHA20_POLY1305 ((psa_algorithm_t)0x06001005)</span>
+</pre></div>
+</div>
+<p>The Chacha20-Poly1305 AEAD algorithm.</p>
+<p>The ChaCha20_Poly1305 construction is defined in RFC 7539.</p>
+<p>Implementations must support 12-byte nonces, may support 8-byte nonces, and should reject other sizes.</p>
+<p>Implementations must support 16-byte tags and should reject other sizes.</p>
+</div>
+<div class="section" id="PSA_ALG_AEAD_TAG_LENGTH_MASK">
+<span id="c.PSA_ALG_AEAD_TAG_LENGTH_MASK"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_AEAD_TAG_LENGTH_MASK</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_AEAD_TAG_LENGTH_MASK ((psa_algorithm_t)0x00003f00)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_AEAD_TAG_LENGTH_OFFSET">
+<span id="c.PSA_AEAD_TAG_LENGTH_OFFSET"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_AEAD_TAG_LENGTH_OFFSET</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_AEAD_TAG_LENGTH_OFFSET 8</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_AEAD_WITH_TAG_LENGTH">
+<span id="c.PSA_ALG_AEAD_WITH_TAG_LENGTH"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_AEAD_WITH_TAG_LENGTH</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_AEAD_WITH_TAG_LENGTH(aead_alg, tag_length) \</span>
+<span class="cp"> (((aead_alg) & ~PSA_ALG_AEAD_TAG_LENGTH_MASK) | ((tag_length) << PSA_AEAD_TAG_LENGTH_OFFSET & PSA_ALG_AEAD_TAG_LENGTH_MASK))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">aead_alg</span></code></dt>
+<dd>An AEAD algorithm identifier (value of type <a class="reference internal" href="#c.psa_algorithm_t" title="psa_algorithm_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code></a> such that <a class="reference internal" href="#c.PSA_ALG_IS_AEAD" title="PSA_ALG_IS_AEAD"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_AEAD</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true).</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">tag_length</span></code></dt>
+<dd>Desired length of the authentication tag in bytes.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>The corresponding AEAD algorithm with the specified length.</p>
+<p>Unspecified if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is not a supported AEAD algorithm or if <code class="docutils literal notranslate"><span class="pre">tag_length</span></code> is not valid for the specified AEAD algorithm.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Macro to build a shortened AEAD algorithm.</p>
+<p>A shortened AEAD algorithm is similar to the corresponding AEAD algorithm, but has an authentication tag that consists of fewer bytes. Depending on the algorithm, the tag length may affect the calculation of the ciphertext.</p>
+</div>
+<div class="section" id="PSA_ALG_AEAD_WITH_DEFAULT_TAG_LENGTH">
+<span id="c.PSA_ALG_AEAD_WITH_DEFAULT_TAG_LENGTH"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_AEAD_WITH_DEFAULT_TAG_LENGTH</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_AEAD_WITH_DEFAULT_TAG_LENGTH(aead_alg) \</span>
+<span class="cp"> ( PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE(aead_alg, PSA_ALG_CCM) PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE(aead_alg, PSA_ALG_GCM) PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE(aead_alg, PSA_ALG_CHACHA20_POLY1305) 0)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">aead_alg</span></code></dt>
+<dd>An AEAD algorithm (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_AEAD" title="PSA_ALG_IS_AEAD"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_AEAD</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>The corresponding AEAD algorithm with the default tag length for that algorithm.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Calculate the corresponding AEAD algorithm with the default tag length.</p>
+</div>
+<div class="section" id="PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE">
+<span id="c.PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE(aead_alg, ref) \</span>
+<span class="cp"> PSA_ALG_AEAD_WITH_TAG_LENGTH(aead_alg, 0) == PSA_ALG_AEAD_WITH_TAG_LENGTH(ref, 0) ? ref :</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">aead_alg</span></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">ref</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+</div>
+<div class="section" id="PSA_ALG_RSA_PKCS1V15_SIGN_BASE">
+<span id="c.PSA_ALG_RSA_PKCS1V15_SIGN_BASE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RSA_PKCS1V15_SIGN_BASE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_RSA_PKCS1V15_SIGN_BASE ((psa_algorithm_t)0x10020000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_RSA_PKCS1V15_SIGN">
+<span id="c.PSA_ALG_RSA_PKCS1V15_SIGN"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RSA_PKCS1V15_SIGN</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_RSA_PKCS1V15_SIGN(hash_alg) \</span>
+<span class="cp"> (PSA_ALG_RSA_PKCS1V15_SIGN_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">hash_alg</span></code></dt>
+<dd>A hash algorithm (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_HASH" title="PSA_ALG_IS_HASH"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_HASH</span></code></a>(<code class="docutils literal notranslate"><span class="pre">hash_alg</span></code>) is true). This includes <a class="reference internal" href="#c.PSA_ALG_ANY_HASH" title="PSA_ALG_ANY_HASH"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_ANY_HASH</span></code></a> when specifying the algorithm in a usage policy.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>The corresponding RSA PKCS#1 v1.5 signature algorithm.</p>
+<p>Unspecified if <code class="docutils literal notranslate"><span class="pre">hash_alg</span></code> is not a supported hash algorithm.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>RSA PKCS#1 v1.5 signature with hashing.</p>
+<p>This is the signature scheme defined by RFC 8017 (PKCS#1: RSA Cryptography Specifications) under the name RSASSA-PKCS1-v1_5.</p>
+</div>
+<div class="section" id="PSA_ALG_RSA_PKCS1V15_SIGN_RAW">
+<span id="c.PSA_ALG_RSA_PKCS1V15_SIGN_RAW"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RSA_PKCS1V15_SIGN_RAW</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_RSA_PKCS1V15_SIGN_RAW PSA_ALG_RSA_PKCS1V15_SIGN_BASE</span>
+</pre></div>
+</div>
+<p>Raw PKCS#1 v1.5 signature.</p>
+<p>The input to this algorithm is the DigestInfo structure used by RFC 8017 (PKCS#1: RSA Cryptography Specifications), §9.2 steps 3–6.</p>
+</div>
+<div class="section" id="PSA_ALG_IS_RSA_PKCS1V15_SIGN">
+<span id="c.PSA_ALG_IS_RSA_PKCS1V15_SIGN"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_RSA_PKCS1V15_SIGN</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_IS_RSA_PKCS1V15_SIGN(alg) \</span>
+<span class="cp"> (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_RSA_PKCS1V15_SIGN_BASE)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+</div>
+<div class="section" id="PSA_ALG_RSA_PSS_BASE">
+<span id="c.PSA_ALG_RSA_PSS_BASE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RSA_PSS_BASE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_RSA_PSS_BASE ((psa_algorithm_t)0x10030000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_RSA_PSS">
+<span id="c.PSA_ALG_RSA_PSS"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RSA_PSS</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_RSA_PSS(hash_alg) \</span>
+<span class="cp"> (PSA_ALG_RSA_PSS_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">hash_alg</span></code></dt>
+<dd>A hash algorithm (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_HASH" title="PSA_ALG_IS_HASH"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_HASH</span></code></a>(<code class="docutils literal notranslate"><span class="pre">hash_alg</span></code>) is true). This includes <a class="reference internal" href="#c.PSA_ALG_ANY_HASH" title="PSA_ALG_ANY_HASH"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_ANY_HASH</span></code></a> when specifying the algorithm in a usage policy.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>The corresponding RSA PSS signature algorithm.</p>
+<p>Unspecified if <code class="docutils literal notranslate"><span class="pre">hash_alg</span></code> is not a supported hash algorithm.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>RSA PSS signature with hashing.</p>
+<p>This is the signature scheme defined by RFC 8017 (PKCS#1: RSA Cryptography Specifications) under the name RSASSA-PSS, with the message generation function MGF1, and with a salt length equal to the length of the hash. The specified hash algorithm is used to hash the input message, to create the salted hash, and for the mask generation.</p>
+</div>
+<div class="section" id="PSA_ALG_IS_RSA_PSS">
+<span id="c.PSA_ALG_IS_RSA_PSS"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_RSA_PSS</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_IS_RSA_PSS(alg) \</span>
+<span class="cp"> (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_RSA_PSS_BASE)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+</div>
+<div class="section" id="PSA_ALG_ECDSA_BASE">
+<span id="c.PSA_ALG_ECDSA_BASE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_ECDSA_BASE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_ECDSA_BASE ((psa_algorithm_t)0x10060000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_ECDSA">
+<span id="c.PSA_ALG_ECDSA"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_ECDSA</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_ECDSA(hash_alg) \</span>
+<span class="cp"> (PSA_ALG_ECDSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">hash_alg</span></code></dt>
+<dd>A hash algorithm (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_HASH" title="PSA_ALG_IS_HASH"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_HASH</span></code></a>(<code class="docutils literal notranslate"><span class="pre">hash_alg</span></code>) is true). This includes <a class="reference internal" href="#c.PSA_ALG_ANY_HASH" title="PSA_ALG_ANY_HASH"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_ANY_HASH</span></code></a> when specifying the algorithm in a usage policy.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>The corresponding ECDSA signature algorithm.</p>
+<p>Unspecified if <code class="docutils literal notranslate"><span class="pre">hash_alg</span></code> is not a supported hash algorithm.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>ECDSA signature with hashing.</p>
+<p>This is the ECDSA signature scheme defined by ANSI X9.62, with a random per-message secret number (<em>k</em>).</p>
+<p>The representation of the signature as a byte string consists of the concatentation of the signature values <em>r</em> and <em>s</em>. Each of <em>r</em> and <em>s</em> is encoded as an <em>N</em>-octet string, where <em>N</em> is the length of the base point of the curve in octets. Each value is represented in big-endian order (most significant octet first).</p>
+</div>
+<div class="section" id="PSA_ALG_ECDSA_ANY">
+<span id="c.PSA_ALG_ECDSA_ANY"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_ECDSA_ANY</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_ECDSA_ANY PSA_ALG_ECDSA_BASE</span>
+</pre></div>
+</div>
+<p>ECDSA signature without hashing.</p>
+<p>This is the same signature scheme as <a class="reference internal" href="#c.PSA_ALG_ECDSA" title="PSA_ALG_ECDSA"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_ECDSA()</span></code></a>, but without specifying a hash algorithm. This algorithm may only be used to sign or verify a sequence of bytes that should be an already-calculated hash. Note that the input is padded with zeros on the left or truncated on the left as required to fit the curve size.</p>
+</div>
+<div class="section" id="PSA_ALG_DETERMINISTIC_ECDSA_BASE">
+<span id="c.PSA_ALG_DETERMINISTIC_ECDSA_BASE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_DETERMINISTIC_ECDSA_BASE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_DETERMINISTIC_ECDSA_BASE ((psa_algorithm_t)0x10070000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_DETERMINISTIC_ECDSA">
+<span id="c.PSA_ALG_DETERMINISTIC_ECDSA"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_DETERMINISTIC_ECDSA</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_DETERMINISTIC_ECDSA(hash_alg) \</span>
+<span class="cp"> (PSA_ALG_DETERMINISTIC_ECDSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">hash_alg</span></code></dt>
+<dd>A hash algorithm (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_HASH" title="PSA_ALG_IS_HASH"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_HASH</span></code></a>(<code class="docutils literal notranslate"><span class="pre">hash_alg</span></code>) is true). This includes <a class="reference internal" href="#c.PSA_ALG_ANY_HASH" title="PSA_ALG_ANY_HASH"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_ANY_HASH</span></code></a> when specifying the algorithm in a usage policy.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>The corresponding deterministic ECDSA signature algorithm.</p>
+<p>Unspecified if <code class="docutils literal notranslate"><span class="pre">hash_alg</span></code> is not a supported hash algorithm.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Deterministic ECDSA signature with hashing.</p>
+<p>This is the deterministic ECDSA signature scheme defined by RFC 6979.</p>
+<p>The representation of a signature is the same as with <a class="reference internal" href="#c.PSA_ALG_ECDSA" title="PSA_ALG_ECDSA"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_ECDSA()</span></code></a>.</p>
+<p>Note that when this algorithm is used for verification, signatures made with randomized ECDSA (<a class="reference internal" href="#c.PSA_ALG_ECDSA" title="PSA_ALG_ECDSA"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_ECDSA</span></code></a>(<code class="docutils literal notranslate"><span class="pre">hash_alg</span></code>)) with the same private key are accepted. In other words, <a class="reference internal" href="#c.PSA_ALG_DETERMINISTIC_ECDSA" title="PSA_ALG_DETERMINISTIC_ECDSA"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_DETERMINISTIC_ECDSA</span></code></a>(<code class="docutils literal notranslate"><span class="pre">hash_alg</span></code>) differs from <a class="reference internal" href="#c.PSA_ALG_ECDSA" title="PSA_ALG_ECDSA"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_ECDSA</span></code></a>(<code class="docutils literal notranslate"><span class="pre">hash_alg</span></code>) only for signature, not for verification.</p>
+</div>
+<div class="section" id="PSA_ALG_IS_ECDSA">
+<span id="c.PSA_ALG_IS_ECDSA"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_ECDSA</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_IS_ECDSA(alg) \</span>
+<span class="cp"> (((alg) & ~PSA_ALG_HASH_MASK & ~PSA_ALG_DSA_DETERMINISTIC_FLAG) == PSA_ALG_ECDSA_BASE)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+</div>
+<div class="section" id="PSA_ALG_ECDSA_IS_DETERMINISTIC">
+<span id="c.PSA_ALG_ECDSA_IS_DETERMINISTIC"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_ECDSA_IS_DETERMINISTIC</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_ECDSA_IS_DETERMINISTIC(alg) \</span>
+<span class="cp"> (((alg) & PSA_ALG_DSA_DETERMINISTIC_FLAG) != 0)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+</div>
+<div class="section" id="PSA_ALG_IS_DETERMINISTIC_ECDSA">
+<span id="c.PSA_ALG_IS_DETERMINISTIC_ECDSA"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_DETERMINISTIC_ECDSA</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_IS_DETERMINISTIC_ECDSA(alg) \</span>
+<span class="cp"> (PSA_ALG_IS_ECDSA(alg) && PSA_ALG_ECDSA_IS_DETERMINISTIC(alg))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+</div>
+<div class="section" id="PSA_ALG_IS_RANDOMIZED_ECDSA">
+<span id="c.PSA_ALG_IS_RANDOMIZED_ECDSA"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_RANDOMIZED_ECDSA</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_IS_RANDOMIZED_ECDSA(alg) \</span>
+<span class="cp"> (PSA_ALG_IS_ECDSA(alg) && !PSA_ALG_ECDSA_IS_DETERMINISTIC(alg))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+</div>
+<div class="section" id="PSA_ALG_IS_HASH_AND_SIGN">
+<span id="c.PSA_ALG_IS_HASH_AND_SIGN"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_HASH_AND_SIGN</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_IS_HASH_AND_SIGN(alg) \</span>
+<span class="cp"> (PSA_ALG_IS_RSA_PSS(alg) || PSA_ALG_IS_RSA_PKCS1V15_SIGN(alg) || PSA_ALG_IS_ECDSA(alg))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>An algorithm identifier (value of type <a class="reference internal" href="#c.psa_algorithm_t" title="psa_algorithm_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code></a>).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is a hash-and-sign algorithm, 0 otherwise. This macro may return either 0 or 1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is not a supported algorithm identifier.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether the specified algorithm is a hash-and-sign algorithm.</p>
+<p>Hash-and-sign algorithms are public-key signature algorithms structured in two parts: first the calculation of a hash in a way that does not depend on the key, then the calculation of a signature from the hash value and the key.</p>
+</div>
+<div class="section" id="PSA_ALG_SIGN_GET_HASH">
+<span id="c.PSA_ALG_SIGN_GET_HASH"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SIGN_GET_HASH</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_SIGN_GET_HASH(alg) \</span>
+<span class="cp"> (PSA_ALG_IS_HASH_AND_SIGN(alg) ? ((alg) & PSA_ALG_HASH_MASK) == 0 ? </span><span class="cm">/*"raw" algorithm*/</span><span class="cp"> 0 : ((alg) & PSA_ALG_HASH_MASK) | PSA_ALG_CATEGORY_HASH : 0)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>A signature algorithm (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_SIGN" title="PSA_ALG_IS_SIGN"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_SIGN</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>The underlying hash algorithm if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is a hash-and-sign algorithm.</p>
+<p>0 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is a signature algorithm that does not follow the hash-and-sign structure.</p>
+<p>Unspecified if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is not a signature algorithm or if it is not supported by the implementation.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Get the hash used by a hash-and-sign signature algorithm.</p>
+<p>A hash-and-sign algorithm is a signature algorithm which is composed of two phases: first a hashing phase which does not use the key and produces a hash of the input message, then a signing phase which only uses the hash and the key and not the message itself.</p>
+</div>
+<div class="section" id="PSA_ALG_RSA_PKCS1V15_CRYPT">
+<span id="c.PSA_ALG_RSA_PKCS1V15_CRYPT"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RSA_PKCS1V15_CRYPT</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_RSA_PKCS1V15_CRYPT ((psa_algorithm_t)0x12020000)</span>
+</pre></div>
+</div>
+<p>RSA PKCS#1 v1.5 encryption.</p>
+</div>
+<div class="section" id="PSA_ALG_RSA_OAEP_BASE">
+<span id="c.PSA_ALG_RSA_OAEP_BASE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RSA_OAEP_BASE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_RSA_OAEP_BASE ((psa_algorithm_t)0x12030000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_RSA_OAEP">
+<span id="c.PSA_ALG_RSA_OAEP"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RSA_OAEP</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_RSA_OAEP(hash_alg) \</span>
+<span class="cp"> (PSA_ALG_RSA_OAEP_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">hash_alg</span></code></dt>
+<dd>The hash algorithm (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_HASH" title="PSA_ALG_IS_HASH"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_HASH</span></code></a>(<code class="docutils literal notranslate"><span class="pre">hash_alg</span></code>) is true) to use for MGF1.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>The corresponding RSA OAEP signature algorithm.</p>
+<p>Unspecified if <code class="docutils literal notranslate"><span class="pre">hash_alg</span></code> is not a supported hash algorithm.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>RSA OAEP encryption.</p>
+<p>This is the encryption scheme defined by RFC 8017 (PKCS#1: RSA Cryptography Specifications) under the name RSAES-OAEP, with the message generation function MGF1.</p>
+</div>
+<div class="section" id="PSA_ALG_IS_RSA_OAEP">
+<span id="c.PSA_ALG_IS_RSA_OAEP"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_RSA_OAEP</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_IS_RSA_OAEP(alg) \</span>
+<span class="cp"> (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_RSA_OAEP_BASE)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+</div>
+<div class="section" id="PSA_ALG_RSA_OAEP_GET_HASH">
+<span id="c.PSA_ALG_RSA_OAEP_GET_HASH"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RSA_OAEP_GET_HASH</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_RSA_OAEP_GET_HASH(alg) \</span>
+<span class="cp"> (PSA_ALG_IS_RSA_OAEP(alg) ? ((alg) & PSA_ALG_HASH_MASK) | PSA_ALG_CATEGORY_HASH : 0)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+</div>
+<div class="section" id="PSA_ALG_HKDF_BASE">
+<span id="c.PSA_ALG_HKDF_BASE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_HKDF_BASE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_HKDF_BASE ((psa_algorithm_t)0x20000100)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_HKDF">
+<span id="c.PSA_ALG_HKDF"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_HKDF</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_HKDF(hash_alg) \</span>
+<span class="cp"> (PSA_ALG_HKDF_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">hash_alg</span></code></dt>
+<dd>A hash algorithm (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_HASH" title="PSA_ALG_IS_HASH"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_HASH</span></code></a>(<code class="docutils literal notranslate"><span class="pre">hash_alg</span></code>) is true).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>The corresponding HKDF algorithm.</p>
+<p>Unspecified if <code class="docutils literal notranslate"><span class="pre">hash_alg</span></code> is not a supported hash algorithm.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Macro to build an HKDF algorithm.</p>
+<p>For example, <code class="docutils literal notranslate"><span class="pre">PSA_ALG_HKDF(PSA_ALG_SHA256)</span></code> is HKDF using HMAC-SHA-256.</p>
+<p>This key derivation algorithm uses the following inputs:</p>
+<ul class="simple">
+<li><a class="reference internal" href="#c.PSA_KEY_DERIVATION_INPUT_SALT" title="PSA_KEY_DERIVATION_INPUT_SALT"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_SALT</span></code></a> is the salt used in the “extract” step. It is optional; if omitted, the derivation uses an empty salt.</li>
+<li><a class="reference internal" href="#c.PSA_KEY_DERIVATION_INPUT_SECRET" title="PSA_KEY_DERIVATION_INPUT_SECRET"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_SECRET</span></code></a> is the secret key used in the “extract” step.</li>
+<li><a class="reference internal" href="#c.PSA_KEY_DERIVATION_INPUT_INFO" title="PSA_KEY_DERIVATION_INPUT_INFO"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_INFO</span></code></a> is the info string used in the “expand” step. You must pass <a class="reference internal" href="#c.PSA_KEY_DERIVATION_INPUT_SALT" title="PSA_KEY_DERIVATION_INPUT_SALT"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_SALT</span></code></a> before <a class="reference internal" href="#c.PSA_KEY_DERIVATION_INPUT_SECRET" title="PSA_KEY_DERIVATION_INPUT_SECRET"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_SECRET</span></code></a>. You may pass <a class="reference internal" href="#c.PSA_KEY_DERIVATION_INPUT_INFO" title="PSA_KEY_DERIVATION_INPUT_INFO"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_INFO</span></code></a> at any time after steup and before starting to generate output.</li>
+</ul>
+</div>
+<div class="section" id="PSA_ALG_IS_HKDF">
+<span id="c.PSA_ALG_IS_HKDF"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_HKDF</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_IS_HKDF(alg) \</span>
+<span class="cp"> (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_HKDF_BASE)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>An algorithm identifier (value of type <a class="reference internal" href="#c.psa_algorithm_t" title="psa_algorithm_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code></a>).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is an HKDF algorithm, 0 otherwise. This macro may return either 0 or 1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is not a supported key derivation algorithm identifier.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether the specified algorithm is an HKDF algorithm.</p>
+<p>HKDF is a family of key derivation algorithms that are based on a hash function and the HMAC construction.</p>
+</div>
+<div class="section" id="PSA_ALG_HKDF_GET_HASH">
+<span id="c.PSA_ALG_HKDF_GET_HASH"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_HKDF_GET_HASH</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_HKDF_GET_HASH(hkdf_alg) \</span>
+<span class="cp"> (PSA_ALG_CATEGORY_HASH | ((hkdf_alg) & PSA_ALG_HASH_MASK))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">hkdf_alg</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+</div>
+<div class="section" id="PSA_ALG_TLS12_PRF_BASE">
+<span id="c.PSA_ALG_TLS12_PRF_BASE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_TLS12_PRF_BASE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_TLS12_PRF_BASE ((psa_algorithm_t)0x20000200)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_TLS12_PRF">
+<span id="c.PSA_ALG_TLS12_PRF"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_TLS12_PRF</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_TLS12_PRF(hash_alg) \</span>
+<span class="cp"> (PSA_ALG_TLS12_PRF_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">hash_alg</span></code></dt>
+<dd>A hash algorithm (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_HASH" title="PSA_ALG_IS_HASH"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_HASH</span></code></a>(<code class="docutils literal notranslate"><span class="pre">hash_alg</span></code>) is true).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>The corresponding TLS-1.2 PRF algorithm.</p>
+<p>Unspecified if <code class="docutils literal notranslate"><span class="pre">hash_alg</span></code> is not a supported hash algorithm.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Macro to build a TLS-1.2 PRF algorithm.</p>
+<p>TLS 1.2 uses a custom pseudorandom function (PRF) for key schedule, specified in Section 5 of RFC 5246. It is based on HMAC and can be used with either SHA-256 or SHA-384.</p>
+<p>This key derivation algorithm uses the following inputs:</p>
+<ul class="simple">
+<li><a class="reference internal" href="#c.PSA_KEY_DERIVATION_INPUT_SECRET" title="PSA_KEY_DERIVATION_INPUT_SECRET"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_SECRET</span></code></a> is the secret key.</li>
+<li><a class="reference internal" href="#c.PSA_KEY_DERIVATION_INPUT_LABEL" title="PSA_KEY_DERIVATION_INPUT_LABEL"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_LABEL</span></code></a> is the label.</li>
+<li><a class="reference internal" href="#c.PSA_KEY_DERIVATION_INPUT_SEED" title="PSA_KEY_DERIVATION_INPUT_SEED"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_SEED</span></code></a> is the seed.</li>
+</ul>
+<p>For the application to TLS-1.2 key expansion, the seed is the concatenation of ServerHello.Random + ClientHello.Random, and the label is “key expansion”.</p>
+<p>For example, <code class="docutils literal notranslate"><span class="pre">PSA_ALG_TLS12_PRF(PSA_ALG_SHA256)</span></code> represents the TLS 1.2 PRF using HMAC-SHA-256.</p>
+</div>
+<div class="section" id="PSA_ALG_IS_TLS12_PRF">
+<span id="c.PSA_ALG_IS_TLS12_PRF"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_TLS12_PRF</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_IS_TLS12_PRF(alg) \</span>
+<span class="cp"> (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_TLS12_PRF_BASE)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>An algorithm identifier (value of type <a class="reference internal" href="#c.psa_algorithm_t" title="psa_algorithm_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code></a>).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is a TLS-1.2 PRF algorithm, 0 otherwise. This macro may return either 0 or 1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is not a supported key derivation algorithm identifier.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether the specified algorithm is a TLS-1.2 PRF algorithm.</p>
+</div>
+<div class="section" id="PSA_ALG_TLS12_PRF_GET_HASH">
+<span id="c.PSA_ALG_TLS12_PRF_GET_HASH"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_TLS12_PRF_GET_HASH</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_TLS12_PRF_GET_HASH(hkdf_alg) \</span>
+<span class="cp"> (PSA_ALG_CATEGORY_HASH | ((hkdf_alg) & PSA_ALG_HASH_MASK))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">hkdf_alg</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+</div>
+<div class="section" id="PSA_ALG_TLS12_PSK_TO_MS_BASE">
+<span id="c.PSA_ALG_TLS12_PSK_TO_MS_BASE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_TLS12_PSK_TO_MS_BASE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_TLS12_PSK_TO_MS_BASE ((psa_algorithm_t)0x20000300)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_TLS12_PSK_TO_MS">
+<span id="c.PSA_ALG_TLS12_PSK_TO_MS"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_TLS12_PSK_TO_MS</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_TLS12_PSK_TO_MS(hash_alg) \</span>
+<span class="cp"> (PSA_ALG_TLS12_PSK_TO_MS_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">hash_alg</span></code></dt>
+<dd>A hash algorithm (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_HASH" title="PSA_ALG_IS_HASH"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_HASH</span></code></a>(<code class="docutils literal notranslate"><span class="pre">hash_alg</span></code>) is true).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>The corresponding TLS-1.2 PSK to MS algorithm.</p>
+<p>Unspecified if <code class="docutils literal notranslate"><span class="pre">hash_alg</span></code> is not a supported hash algorithm.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Macro to build a TLS-1.2 PSK-to-MasterSecret algorithm.</p>
+<p>In a pure-PSK handshake in TLS 1.2, the master secret is derived from the PreSharedKey (PSK) through the application of padding (RFC 4279, Section 2) and the TLS-1.2 PRF (RFC 5246, Section 5). The latter is based on HMAC and can be used with either SHA-256 or SHA-384.</p>
+<p>This key derivation algorithm uses the following inputs:</p>
+<ul class="simple">
+<li><a class="reference internal" href="#c.PSA_KEY_DERIVATION_INPUT_SECRET" title="PSA_KEY_DERIVATION_INPUT_SECRET"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_SECRET</span></code></a> is the secret key.</li>
+<li><a class="reference internal" href="#c.PSA_KEY_DERIVATION_INPUT_LABEL" title="PSA_KEY_DERIVATION_INPUT_LABEL"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_LABEL</span></code></a> is the label.</li>
+<li><a class="reference internal" href="#c.PSA_KEY_DERIVATION_INPUT_SEED" title="PSA_KEY_DERIVATION_INPUT_SEED"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_SEED</span></code></a> is the seed.</li>
+</ul>
+<p>For the application to TLS-1.2, the seed (which is forwarded to the TLS-1.2 PRF) is the concatenation of the ClientHello.Random + ServerHello.Random, and the label is “master secret” or “extended master secret”.</p>
+<p>For example, <code class="docutils literal notranslate"><span class="pre">PSA_ALG_TLS12_PSK_TO_MS(PSA_ALG_SHA256)</span></code> represents the TLS-1.2 PSK to MasterSecret derivation PRF using HMAC-SHA-256.</p>
+</div>
+<div class="section" id="PSA_ALG_IS_TLS12_PSK_TO_MS">
+<span id="c.PSA_ALG_IS_TLS12_PSK_TO_MS"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_TLS12_PSK_TO_MS</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_IS_TLS12_PSK_TO_MS(alg) \</span>
+<span class="cp"> (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_TLS12_PSK_TO_MS_BASE)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>An algorithm identifier (value of type <a class="reference internal" href="#c.psa_algorithm_t" title="psa_algorithm_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code></a>).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is a TLS-1.2 PSK to MS algorithm, 0 otherwise. This macro may return either 0 or 1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is not a supported key derivation algorithm identifier.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether the specified algorithm is a TLS-1.2 PSK to MS algorithm.</p>
+</div>
+<div class="section" id="PSA_ALG_TLS12_PSK_TO_MS_GET_HASH">
+<span id="c.PSA_ALG_TLS12_PSK_TO_MS_GET_HASH"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_TLS12_PSK_TO_MS_GET_HASH</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_TLS12_PSK_TO_MS_GET_HASH(hkdf_alg) \</span>
+<span class="cp"> (PSA_ALG_CATEGORY_HASH | ((hkdf_alg) & PSA_ALG_HASH_MASK))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">hkdf_alg</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+</div>
+<div class="section" id="PSA_ALG_KEY_DERIVATION_MASK">
+<span id="c.PSA_ALG_KEY_DERIVATION_MASK"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_KEY_DERIVATION_MASK</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_KEY_DERIVATION_MASK ((psa_algorithm_t)0x0803ffff)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_KEY_AGREEMENT_MASK">
+<span id="c.PSA_ALG_KEY_AGREEMENT_MASK"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_KEY_AGREEMENT_MASK</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_KEY_AGREEMENT_MASK ((psa_algorithm_t)0x10fc0000)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ALG_KEY_AGREEMENT">
+<span id="c.PSA_ALG_KEY_AGREEMENT"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_KEY_AGREEMENT</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_KEY_AGREEMENT(ka_alg, kdf_alg) ((ka_alg) | (kdf_alg))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">ka_alg</span></code></dt>
+<dd>A key agreement algorithm (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_KEY_AGREEMENT" title="PSA_ALG_IS_KEY_AGREEMENT"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_KEY_AGREEMENT</span></code></a>(<code class="docutils literal notranslate"><span class="pre">ka_alg</span></code>) is true).</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">kdf_alg</span></code></dt>
+<dd>A key derivation algorithm (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_KEY_DERIVATION" title="PSA_ALG_IS_KEY_DERIVATION"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_KEY_DERIVATION</span></code></a>(<code class="docutils literal notranslate"><span class="pre">kdf_alg</span></code>) is true).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>The corresponding key agreement and derivation algorithm.</p>
+<p>Unspecified if <code class="docutils literal notranslate"><span class="pre">ka_alg</span></code> is not a supported key agreement algorithm or <code class="docutils literal notranslate"><span class="pre">kdf_alg</span></code> is not a supported key derivation algorithm.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Macro to build a combined algorithm that chains a key agreement with a key derivation.</p>
+</div>
+<div class="section" id="PSA_ALG_KEY_AGREEMENT_GET_KDF">
+<span id="c.PSA_ALG_KEY_AGREEMENT_GET_KDF"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_KEY_AGREEMENT_GET_KDF</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_KEY_AGREEMENT_GET_KDF(alg) \</span>
+<span class="cp"> (((alg) & PSA_ALG_KEY_DERIVATION_MASK) | PSA_ALG_CATEGORY_KEY_DERIVATION)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+</div>
+<div class="section" id="PSA_ALG_KEY_AGREEMENT_GET_BASE">
+<span id="c.PSA_ALG_KEY_AGREEMENT_GET_BASE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_KEY_AGREEMENT_GET_BASE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_KEY_AGREEMENT_GET_BASE(alg) \</span>
+<span class="cp"> (((alg) & PSA_ALG_KEY_AGREEMENT_MASK) | PSA_ALG_CATEGORY_KEY_AGREEMENT)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+</div>
+<div class="section" id="PSA_ALG_IS_RAW_KEY_AGREEMENT">
+<span id="c.PSA_ALG_IS_RAW_KEY_AGREEMENT"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_RAW_KEY_AGREEMENT</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_IS_RAW_KEY_AGREEMENT(alg) \</span>
+<span class="cp"> (PSA_ALG_IS_KEY_AGREEMENT(alg) && PSA_ALG_KEY_AGREEMENT_GET_KDF(alg) == PSA_ALG_CATEGORY_KEY_DERIVATION)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>An algorithm identifier (value of type <a class="reference internal" href="#c.psa_algorithm_t" title="psa_algorithm_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code></a>).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is a raw key agreement algorithm, 0 otherwise. This macro may return either 0 or 1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is not a supported algorithm identifier.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether the specified algorithm is a raw key agreement algorithm.</p>
+<p>A raw key agreement algorithm is one that does not specify a key derivation function. Usually, raw key agreement algorithms are constructed directly with a <code class="docutils literal notranslate"><span class="pre">PSA_ALG_xxx</span></code> macro while non-raw key agreement algorithms are constructed with <a class="reference internal" href="#c.PSA_ALG_KEY_AGREEMENT" title="PSA_ALG_KEY_AGREEMENT"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_KEY_AGREEMENT()</span></code></a>.</p>
+</div>
+<div class="section" id="PSA_ALG_IS_KEY_DERIVATION_OR_AGREEMENT">
+<span id="c.PSA_ALG_IS_KEY_DERIVATION_OR_AGREEMENT"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_KEY_DERIVATION_OR_AGREEMENT</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_IS_KEY_DERIVATION_OR_AGREEMENT(alg) \</span>
+<span class="cp"> ((PSA_ALG_IS_KEY_DERIVATION(alg) || PSA_ALG_IS_KEY_AGREEMENT(alg)))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+</div>
+<div class="section" id="PSA_ALG_FFDH">
+<span id="c.PSA_ALG_FFDH"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_FFDH</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_FFDH ((psa_algorithm_t)0x30100000)</span>
+</pre></div>
+</div>
+<p>The finite-field Diffie-Hellman (DH) key agreement algorithm.</p>
+<p>The shared secret produced by key agreement is <code class="docutils literal notranslate"><span class="pre">g^{ab}</span></code> in big-endian format. It is <code class="docutils literal notranslate"><span class="pre">ceiling(m</span> <span class="pre">/</span> <span class="pre">8)</span></code> bytes long where <code class="docutils literal notranslate"><span class="pre">m</span></code> is the size of the prime <code class="docutils literal notranslate"><span class="pre">p</span></code> in bits.</p>
+</div>
+<div class="section" id="PSA_ALG_IS_FFDH">
+<span id="c.PSA_ALG_IS_FFDH"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_FFDH</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_IS_FFDH(alg) \</span>
+<span class="cp"> (PSA_ALG_KEY_AGREEMENT_GET_BASE(alg) == PSA_ALG_FFDH)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>An algorithm identifier (value of type <a class="reference internal" href="#c.psa_algorithm_t" title="psa_algorithm_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code></a>).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is a finite field Diffie-Hellman algorithm, 0 otherwise. This macro may return either 0 or 1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is not a supported key agreement algorithm identifier.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether the specified algorithm is a finite field Diffie-Hellman algorithm.</p>
+<p>This includes the raw finite field Diffie-Hellman algorithm as well as finite-field Diffie-Hellman followed by any supporter key derivation algorithm.</p>
+</div>
+<div class="section" id="PSA_ALG_ECDH">
+<span id="c.PSA_ALG_ECDH"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_ECDH</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_ECDH ((psa_algorithm_t)0x30200000)</span>
+</pre></div>
+</div>
+<p>The elliptic curve Diffie-Hellman (ECDH) key agreement algorithm.</p>
+<p>The shared secret produced by key agreement is the x-coordinate of the shared secret point. It is always <code class="docutils literal notranslate"><span class="pre">ceiling(m</span> <span class="pre">/</span> <span class="pre">8)</span></code> bytes long where <code class="docutils literal notranslate"><span class="pre">m</span></code> is the bit size associated with the curve, i.e. the bit size of the order of the curve’s coordinate field. When <code class="docutils literal notranslate"><span class="pre">m</span></code> is not a multiple of 8, the byte containing the most significant bit of the shared secret is padded with zero bits. The byte order is either little-endian or big-endian depending on the curve type.</p>
+<ul class="simple">
+<li>For Montgomery curves (curve types <code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_CURVEXXX</span></code>), the shared secret is the x-coordinate of <code class="docutils literal notranslate"><span class="pre">d_A</span> <span class="pre">Q_B</span> <span class="pre">=</span> <span class="pre">d_B</span> <span class="pre">Q_A</span></code> in little-endian byte order. The bit size is 448 for Curve448 and 255 for Curve25519.</li>
+<li>For Weierstrass curves over prime fields (curve types <code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECPXXX</span></code> and <code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_BRAINPOOL_PXXX</span></code>), the shared secret is the x-coordinate of <code class="docutils literal notranslate"><span class="pre">d_A</span> <span class="pre">Q_B</span> <span class="pre">=</span> <span class="pre">d_B</span> <span class="pre">Q_A</span></code> in big-endian byte order. The bit size is <code class="docutils literal notranslate"><span class="pre">m</span> <span class="pre">=</span> <span class="pre">ceiling(log_2(p))</span></code> for the field <code class="docutils literal notranslate"><span class="pre">F_p</span></code>.</li>
+<li>For Weierstrass curves over binary fields (curve types <code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECTXXX</span></code>), the shared secret is the x-coordinate of <code class="docutils literal notranslate"><span class="pre">d_A</span> <span class="pre">Q_B</span> <span class="pre">=</span> <span class="pre">d_B</span> <span class="pre">Q_A</span></code> in big-endian byte order. The bit size is <code class="docutils literal notranslate"><span class="pre">m</span></code> for the field <code class="docutils literal notranslate"><span class="pre">F_{2^m}</span></code>.</li>
+</ul>
+</div>
+<div class="section" id="PSA_ALG_IS_ECDH">
+<span id="c.PSA_ALG_IS_ECDH"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_ECDH</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_IS_ECDH(alg) \</span>
+<span class="cp"> (PSA_ALG_KEY_AGREEMENT_GET_BASE(alg) == PSA_ALG_ECDH)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>An algorithm identifier (value of type <a class="reference internal" href="#c.psa_algorithm_t" title="psa_algorithm_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code></a>).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is an elliptic curve Diffie-Hellman algorithm, 0 otherwise. This macro may return either 0 or 1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is not a supported key agreement algorithm identifier.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether the specified algorithm is an elliptic curve Diffie-Hellman algorithm.</p>
+<p>This includes the raw elliptic curve Diffie-Hellman algorithm as well as elliptic curve Diffie-Hellman followed by any supporter key derivation algorithm.</p>
+</div>
+<div class="section" id="PSA_ALG_IS_WILDCARD">
+<span id="c.PSA_ALG_IS_WILDCARD"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_WILDCARD</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_IS_WILDCARD(alg) \</span>
+<span class="cp"> (PSA_ALG_IS_HASH_AND_SIGN(alg) ? PSA_ALG_SIGN_GET_HASH(alg) == PSA_ALG_ANY_HASH : (alg) == PSA_ALG_ANY_HASH)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>An algorithm identifier (value of type <a class="reference internal" href="#c.psa_algorithm_t" title="psa_algorithm_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code></a>).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is a wildcard algorithm encoding.</p>
+<p>0 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is a non-wildcard algorithm encoding (suitable for an operation).</p>
+<p>This macro may return either 0 or 1 if <code class="docutils literal notranslate"><span class="pre">alg</span></code> is not a supported algorithm identifier.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Whether the specified algorithm encoding is a wildcard.</p>
+<p>Wildcard values may only be used to set the usage algorithm field in a policy, not to perform an operation.</p>
+</div>
+</div>
+<div class="section" id="key-lifetimes">
+<h1>Key lifetimes</h1>
+<div class="section" id="psa_key_lifetime_t">
+<span id="c.psa_key_lifetime_t"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_key_lifetime_t</span></code> (type)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="k">typedef</span> <span class="kt">uint32_t</span> <span class="n">psa_key_lifetime_t</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>Encoding of key lifetimes.</p>
+<p>The lifetime of a key indicates where it is stored and what system actions may create and destroy it.</p>
+<p>Keys with the lifetime <a class="reference internal" href="#c.PSA_KEY_LIFETIME_VOLATILE" title="PSA_KEY_LIFETIME_VOLATILE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_LIFETIME_VOLATILE</span></code></a> are automatically destroyed when the application terminates or on a power reset.</p>
+<p>Keys with a lifetime other than <a class="reference internal" href="#c.PSA_KEY_LIFETIME_VOLATILE" title="PSA_KEY_LIFETIME_VOLATILE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_LIFETIME_VOLATILE</span></code></a> are said to be <em>persistent</em>. Persistent keys are preserved if the application or the system restarts. Persistent keys have a key identifier of type <a class="reference internal" href="#c.psa_key_id_t" title="psa_key_id_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_key_id_t</span></code></a>. The application can call <a class="reference internal" href="#c.psa_open_key" title="psa_open_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_open_key()</span></code></a> to open a persistent key that it created previously.</p>
+</div>
+<div class="section" id="psa_key_id_t">
+<span id="c.psa_key_id_t"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_key_id_t</span></code> (type)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="k">typedef</span> <span class="kt">uint32_t</span> <span class="n">psa_key_id_t</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>Encoding of identifiers of persistent keys.</p>
+<ul class="simple">
+<li>Applications may freely choose key identifiers in the range <a class="reference internal" href="#c.PSA_KEY_ID_USER_MIN" title="PSA_KEY_ID_USER_MIN"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_ID_USER_MIN</span></code></a> to <a class="reference internal" href="#c.PSA_KEY_ID_USER_MAX" title="PSA_KEY_ID_USER_MAX"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_ID_USER_MAX</span></code></a>.</li>
+<li>Implementations may define additional key identifiers in the range <a class="reference internal" href="#c.PSA_KEY_ID_VENDOR_MIN" title="PSA_KEY_ID_VENDOR_MIN"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_ID_VENDOR_MIN</span></code></a> to <a class="reference internal" href="#c.PSA_KEY_ID_VENDOR_MAX" title="PSA_KEY_ID_VENDOR_MAX"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_ID_VENDOR_MAX</span></code></a>.</li>
+<li>0 is reserved as an invalid key identifier.</li>
+<li>Key identifiers outside these ranges are reserved for future use.</li>
+</ul>
+</div>
+<div class="section" id="PSA_KEY_LIFETIME_VOLATILE">
+<span id="c.PSA_KEY_LIFETIME_VOLATILE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_LIFETIME_VOLATILE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_LIFETIME_VOLATILE ((psa_key_lifetime_t)0x00000000)</span>
+</pre></div>
+</div>
+<p>A volatile key only exists as long as the handle to it is not closed.</p>
+<p>The key material is guaranteed to be erased on a power reset.</p>
+</div>
+<div class="section" id="PSA_KEY_LIFETIME_PERSISTENT">
+<span id="c.PSA_KEY_LIFETIME_PERSISTENT"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_LIFETIME_PERSISTENT</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_LIFETIME_PERSISTENT ((psa_key_lifetime_t)0x00000001)</span>
+</pre></div>
+</div>
+<p>The default storage area for persistent keys.</p>
+<p>A persistent key remains in storage until it is explicitly destroyed or until the corresponding storage area is wiped. This specification does not define any mechanism to wipe a storage area, but implementations may provide their own mechanism (for example to perform a factory reset, to prepare for device refurbishment, or to uninstall an application).</p>
+<p>This lifetime value is the default storage area for the calling application. Implementations may offer other storage areas designated by other lifetime values as implementation-specific extensions.</p>
+</div>
+<div class="section" id="PSA_KEY_ID_USER_MIN">
+<span id="c.PSA_KEY_ID_USER_MIN"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_ID_USER_MIN</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_ID_USER_MIN ((psa_key_id_t)0x00000001)</span>
+</pre></div>
+</div>
+<p>The minimum value for a key identifier chosen by the application.</p>
+</div>
+<div class="section" id="PSA_KEY_ID_USER_MAX">
+<span id="c.PSA_KEY_ID_USER_MAX"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_ID_USER_MAX</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_ID_USER_MAX ((psa_key_id_t)0x3fffffff)</span>
+</pre></div>
+</div>
+<p>The maximum value for a key identifier chosen by the application.</p>
+</div>
+<div class="section" id="PSA_KEY_ID_VENDOR_MIN">
+<span id="c.PSA_KEY_ID_VENDOR_MIN"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_ID_VENDOR_MIN</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_ID_VENDOR_MIN ((psa_key_id_t)0x40000000)</span>
+</pre></div>
+</div>
+<p>The minimum value for a key identifier chosen by the implementation.</p>
+</div>
+<div class="section" id="PSA_KEY_ID_VENDOR_MAX">
+<span id="c.PSA_KEY_ID_VENDOR_MAX"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_ID_VENDOR_MAX</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_ID_VENDOR_MAX ((psa_key_id_t)0x7fffffff)</span>
+</pre></div>
+</div>
+<p>The maximum value for a key identifier chosen by the implementation.</p>
+</div>
+</div>
+<div class="section" id="key-policies">
+<h1>Key policies</h1>
+<div class="section" id="psa_key_usage_t">
+<span id="c.psa_key_usage_t"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_key_usage_t</span></code> (type)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="k">typedef</span> <span class="kt">uint32_t</span> <span class="n">psa_key_usage_t</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>Encoding of permitted usage on a key.</p>
+</div>
+<div class="section" id="PSA_KEY_USAGE_EXPORT">
+<span id="c.PSA_KEY_USAGE_EXPORT"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_EXPORT</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_USAGE_EXPORT ((psa_key_usage_t)0x00000001)</span>
+</pre></div>
+</div>
+<p>Whether the key may be exported.</p>
+<p>A public key or the public part of a key pair may always be exported regardless of the value of this permission flag.</p>
+<p>If a key does not have export permission, implementations shall not allow the key to be exported in plain form from the cryptoprocessor, whether through <a class="reference internal" href="#c.psa_export_key" title="psa_export_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_export_key()</span></code></a> or through a proprietary interface. The key may however be exportable in a wrapped form, i.e. in a form where it is encrypted by another key.</p>
+</div>
+<div class="section" id="PSA_KEY_USAGE_COPY">
+<span id="c.PSA_KEY_USAGE_COPY"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_COPY</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_USAGE_COPY ((psa_key_usage_t)0x00000002)</span>
+</pre></div>
+</div>
+<p>Whether the key may be copied.</p>
+<p>This flag allows the use of <a class="reference internal" href="#c.psa_copy_key" title="psa_copy_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_copy_key()</span></code></a> to make a copy of the key with the same policy or a more restrictive policy.</p>
+<p>For lifetimes for which the key is located in a secure element which enforce the non-exportability of keys, copying a key outside the secure element also requires the usage flag <a class="reference internal" href="#c.PSA_KEY_USAGE_EXPORT" title="PSA_KEY_USAGE_EXPORT"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_EXPORT</span></code></a>. Copying the key inside the secure element is permitted with just <a class="reference internal" href="#c.PSA_KEY_USAGE_COPY" title="PSA_KEY_USAGE_COPY"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_COPY</span></code></a> if the secure element supports it. For keys with the lifetime <a class="reference internal" href="#c.PSA_KEY_LIFETIME_VOLATILE" title="PSA_KEY_LIFETIME_VOLATILE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_LIFETIME_VOLATILE</span></code></a> or <a class="reference internal" href="#c.PSA_KEY_LIFETIME_PERSISTENT" title="PSA_KEY_LIFETIME_PERSISTENT"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_LIFETIME_PERSISTENT</span></code></a>, the usage flag <a class="reference internal" href="#c.PSA_KEY_USAGE_COPY" title="PSA_KEY_USAGE_COPY"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_COPY</span></code></a> is sufficient to permit the copy.</p>
+</div>
+<div class="section" id="PSA_KEY_USAGE_ENCRYPT">
+<span id="c.PSA_KEY_USAGE_ENCRYPT"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_ENCRYPT</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_USAGE_ENCRYPT ((psa_key_usage_t)0x00000100)</span>
+</pre></div>
+</div>
+<p>Whether the key may be used to encrypt a message.</p>
+<p>This flag allows the key to be used for a symmetric encryption operation, for an AEAD encryption-and-authentication operation, or for an asymmetric encryption operation, if otherwise permitted by the key’s type and policy.</p>
+<p>For a key pair, this concerns the public key.</p>
+</div>
+<div class="section" id="PSA_KEY_USAGE_DECRYPT">
+<span id="c.PSA_KEY_USAGE_DECRYPT"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_DECRYPT</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_USAGE_DECRYPT ((psa_key_usage_t)0x00000200)</span>
+</pre></div>
+</div>
+<p>Whether the key may be used to decrypt a message.</p>
+<p>This flag allows the key to be used for a symmetric decryption operation, for an AEAD decryption-and-verification operation, or for an asymmetric decryption operation, if otherwise permitted by the key’s type and policy.</p>
+<p>For a key pair, this concerns the private key.</p>
+</div>
+<div class="section" id="PSA_KEY_USAGE_SIGN">
+<span id="c.PSA_KEY_USAGE_SIGN"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_SIGN</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_USAGE_SIGN ((psa_key_usage_t)0x00000400)</span>
+</pre></div>
+</div>
+<p>Whether the key may be used to sign a message.</p>
+<p>This flag allows the key to be used for a MAC calculation operation or for an asymmetric signature operation, if otherwise permitted by the key’s type and policy.</p>
+<p>For a key pair, this concerns the private key.</p>
+</div>
+<div class="section" id="PSA_KEY_USAGE_VERIFY">
+<span id="c.PSA_KEY_USAGE_VERIFY"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_VERIFY</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_USAGE_VERIFY ((psa_key_usage_t)0x00000800)</span>
+</pre></div>
+</div>
+<p>Whether the key may be used to verify a message signature.</p>
+<p>This flag allows the key to be used for a MAC verification operation or for an asymmetric signature verification operation, if otherwise permitted by by the key’s type and policy.</p>
+<p>For a key pair, this concerns the public key.</p>
+</div>
+<div class="section" id="PSA_KEY_USAGE_DERIVE">
+<span id="c.PSA_KEY_USAGE_DERIVE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_DERIVE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_USAGE_DERIVE ((psa_key_usage_t)0x00001000)</span>
+</pre></div>
+</div>
+<p>Whether the key may be used to derive other keys.</p>
+</div>
+</div>
+<div class="section" id="key-derivation">
+<h1>Key derivation</h1>
+<div class="section" id="psa_key_derivation_step_t">
+<span id="c.psa_key_derivation_step_t"></span><h2><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_step_t</span></code> (type)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="k">typedef</span> <span class="kt">uint16_t</span> <span class="n">psa_key_derivation_step_t</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>Encoding of the step of a key derivation.</p>
+</div>
+<div class="section" id="PSA_KEY_DERIVATION_INPUT_SECRET">
+<span id="c.PSA_KEY_DERIVATION_INPUT_SECRET"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_SECRET</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_DERIVATION_INPUT_SECRET ((psa_key_derivation_step_t)0x0101)</span>
+</pre></div>
+</div>
+<p>A secret input for key derivation.</p>
+<p>This must be a key of type <a class="reference internal" href="#c.PSA_KEY_TYPE_DERIVE" title="PSA_KEY_TYPE_DERIVE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_DERIVE</span></code></a>.</p>
+</div>
+<div class="section" id="PSA_KEY_DERIVATION_INPUT_LABEL">
+<span id="c.PSA_KEY_DERIVATION_INPUT_LABEL"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_LABEL</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_DERIVATION_INPUT_LABEL ((psa_key_derivation_step_t)0x0201)</span>
+</pre></div>
+</div>
+<p>A label for key derivation.</p>
+<p>This must be a direct input.</p>
+</div>
+<div class="section" id="PSA_KEY_DERIVATION_INPUT_SALT">
+<span id="c.PSA_KEY_DERIVATION_INPUT_SALT"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_SALT</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_DERIVATION_INPUT_SALT ((psa_key_derivation_step_t)0x0202)</span>
+</pre></div>
+</div>
+<p>A salt for key derivation.</p>
+<p>This must be a direct input.</p>
+</div>
+<div class="section" id="PSA_KEY_DERIVATION_INPUT_INFO">
+<span id="c.PSA_KEY_DERIVATION_INPUT_INFO"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_INFO</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_DERIVATION_INPUT_INFO ((psa_key_derivation_step_t)0x0203)</span>
+</pre></div>
+</div>
+<p>An information string for key derivation.</p>
+<p>This must be a direct input.</p>
+</div>
+<div class="section" id="PSA_KEY_DERIVATION_INPUT_SEED">
+<span id="c.PSA_KEY_DERIVATION_INPUT_SEED"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_SEED</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_DERIVATION_INPUT_SEED ((psa_key_derivation_step_t)0x0204)</span>
+</pre></div>
+</div>
+<p>A seed for key derivation.</p>
+<p>This must be a direct input.</p>
+</div>
+</div>
+<div class="section" id="other-definitions">
+<h1>Other definitions</h1>
+<div class="section" id="PSA_BITS_TO_BYTES">
+<span id="c.PSA_BITS_TO_BYTES"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_BITS_TO_BYTES</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_BITS_TO_BYTES(bits) (((bits) + 7) / 8)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">bits</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+</div>
+<div class="section" id="PSA_BYTES_TO_BITS">
+<span id="c.PSA_BYTES_TO_BITS"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_BYTES_TO_BITS</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_BYTES_TO_BITS(bytes) ((bytes) * 8)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">bytes</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+</div>
+<div class="section" id="PSA_ROUND_UP_TO_MULTIPLE">
+<span id="c.PSA_ROUND_UP_TO_MULTIPLE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ROUND_UP_TO_MULTIPLE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ROUND_UP_TO_MULTIPLE(block_size, length) \</span>
+<span class="cp"> (((length) + (block_size) - 1) / (block_size) * (block_size))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">block_size</span></code></dt>
+<dd></dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">length</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+</div>
+<div class="section" id="PSA_HASH_SIZE">
+<span id="c.PSA_HASH_SIZE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_HASH_SIZE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_HASH_SIZE(alg) \</span>
+<span class="cp"> ( PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_MD2 ? 16 : PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_MD4 ? 16 : PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_MD5 ? 16 : PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_RIPEMD160 ? 20 : PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_1 ? 20 : PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_224 ? 28 : PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_256 ? 32 : PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_384 ? 48 : PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_512 ? 64 : PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_512_224 ? 28 : PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_512_256 ? 32 : PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA3_224 ? 28 : PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA3_256 ? 32 : PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA3_384 ? 48 : PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA3_512 ? 64 : 0)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>A hash algorithm (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_HASH" title="PSA_ALG_IS_HASH"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_HASH</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true), or an HMAC algorithm (<a class="reference internal" href="#c.PSA_ALG_HMAC" title="PSA_ALG_HMAC"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_HMAC</span></code></a>(<code class="docutils literal notranslate"><span class="pre">hash_alg</span></code>) where <code class="docutils literal notranslate"><span class="pre">hash_alg</span></code> is a hash algorithm).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>The hash size for the specified hash algorithm. If the hash algorithm is not recognized, return 0. An implementation may return either 0 or the correct size for a hash algorithm that it recognizes, but does not support.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>The size of the output of <a class="reference internal" href="#c.psa_hash_finish" title="psa_hash_finish"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_finish()</span></code></a>, in bytes.</p>
+<p>This is also the hash size that <a class="reference internal" href="#c.psa_hash_verify" title="psa_hash_verify"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_hash_verify()</span></code></a> expects.</p>
+</div>
+<div class="section" id="PSA_HASH_MAX_SIZE">
+<span id="c.PSA_HASH_MAX_SIZE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_HASH_MAX_SIZE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_HASH_MAX_SIZE 64</span>
+</pre></div>
+</div>
+<p>Maximum size of a hash.</p>
+<p>This macro must expand to a compile-time constant integer. This value should be the maximum size of a hash supported by the implementation, in bytes, and must be no smaller than this maximum.</p>
+</div>
+<div class="section" id="PSA_HMAC_MAX_HASH_BLOCK_SIZE">
+<span id="c.PSA_HMAC_MAX_HASH_BLOCK_SIZE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_HMAC_MAX_HASH_BLOCK_SIZE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_HMAC_MAX_HASH_BLOCK_SIZE 128</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_MAC_MAX_SIZE">
+<span id="c.PSA_MAC_MAX_SIZE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_MAC_MAX_SIZE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_MAC_MAX_SIZE PSA_HASH_MAX_SIZE</span>
+</pre></div>
+</div>
+<p>Maximum size of a MAC.</p>
+<p>This macro must expand to a compile-time constant integer. This value should be the maximum size of a MAC supported by the implementation, in bytes, and must be no smaller than this maximum.</p>
+</div>
+<div class="section" id="PSA_AEAD_TAG_LENGTH">
+<span id="c.PSA_AEAD_TAG_LENGTH"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_AEAD_TAG_LENGTH</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_AEAD_TAG_LENGTH(alg) \</span>
+<span class="cp"> (PSA_ALG_IS_AEAD(alg) ? (((alg) & PSA_ALG_AEAD_TAG_LENGTH_MASK) >> PSA_AEAD_TAG_LENGTH_OFFSET) : 0)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>An AEAD algorithm (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_AEAD" title="PSA_ALG_IS_AEAD"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_AEAD</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>The tag size for the specified algorithm. If the AEAD algorithm does not have an identified tag that can be distinguished from the rest of the ciphertext, return 0. If the AEAD algorithm is not recognized, return 0. An implementation may return either 0 or a correct size for an AEAD algorithm that it recognizes, but does not support.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>The tag size for an AEAD algorithm, in bytes.</p>
+</div>
+<div class="section" id="PSA_VENDOR_RSA_MAX_KEY_BITS">
+<span id="c.PSA_VENDOR_RSA_MAX_KEY_BITS"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_VENDOR_RSA_MAX_KEY_BITS</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_VENDOR_RSA_MAX_KEY_BITS 4096</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_VENDOR_ECC_MAX_CURVE_BITS">
+<span id="c.PSA_VENDOR_ECC_MAX_CURVE_BITS"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_VENDOR_ECC_MAX_CURVE_BITS</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_VENDOR_ECC_MAX_CURVE_BITS 521</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="PSA_ECC_CURVE_BITS">
+<span id="c.PSA_ECC_CURVE_BITS"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_BITS</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECC_CURVE_BITS(curve) </span><span class="cm">/*...*/</span><span class="cp"></span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">curve</span></code></dt>
+<dd>An elliptic curve (value of type <a class="reference internal" href="#c.psa_ecc_curve_t" title="psa_ecc_curve_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_ecc_curve_t</span></code></a>).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>The size associated with <code class="docutils literal notranslate"><span class="pre">curve</span></code>, in bits. This may be 0 if the implementation does not support the specified curve.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Bit size associated with an elliptic curve.</p>
+</div>
+<div class="section" id="PSA_ALG_TLS12_PSK_TO_MS_MAX_PSK_LEN">
+<span id="c.PSA_ALG_TLS12_PSK_TO_MS_MAX_PSK_LEN"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ALG_TLS12_PSK_TO_MS_MAX_PSK_LEN</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ALG_TLS12_PSK_TO_MS_MAX_PSK_LEN 128</span>
+</pre></div>
+</div>
+<p>This macro returns the maximum length of the PSK supported by the TLS-1.2 PSK-to-MS key derivation.</p>
+<p>Quoting RFC 4279, Sect 5.3: TLS implementations supporting these ciphersuites MUST support arbitrary PSK identities up to 128 octets in length, and arbitrary PSKs up to 64 octets in length. Supporting longer identities and keys is RECOMMENDED.</p>
+<p>Therefore, no implementation should define a value smaller than 64 for <a class="reference internal" href="#c.PSA_ALG_TLS12_PSK_TO_MS_MAX_PSK_LEN" title="PSA_ALG_TLS12_PSK_TO_MS_MAX_PSK_LEN"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_TLS12_PSK_TO_MS_MAX_PSK_LEN</span></code></a>.</p>
+</div>
+<div class="section" id="PSA_ASYMMETRIC_SIGNATURE_MAX_SIZE">
+<span id="c.PSA_ASYMMETRIC_SIGNATURE_MAX_SIZE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ASYMMETRIC_SIGNATURE_MAX_SIZE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ASYMMETRIC_SIGNATURE_MAX_SIZE \</span>
+<span class="cp"> PSA_BITS_TO_BYTES( PSA_VENDOR_RSA_MAX_KEY_BITS > PSA_VENDOR_ECC_MAX_CURVE_BITS ? PSA_VENDOR_RSA_MAX_KEY_BITS : PSA_VENDOR_ECC_MAX_CURVE_BITS )</span>
+</pre></div>
+</div>
+<p>Maximum size of an asymmetric signature.</p>
+<p>This macro must expand to a compile-time constant integer. This value should be the maximum size of a MAC supported by the implementation, in bytes, and must be no smaller than this maximum.</p>
+</div>
+<div class="section" id="PSA_MAX_BLOCK_CIPHER_BLOCK_SIZE">
+<span id="c.PSA_MAX_BLOCK_CIPHER_BLOCK_SIZE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_MAX_BLOCK_CIPHER_BLOCK_SIZE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_MAX_BLOCK_CIPHER_BLOCK_SIZE 16</span>
+</pre></div>
+</div>
+<p>The maximum size of a block cipher supported by the implementation.</p>
+</div>
+<div class="section" id="PSA_MAC_FINAL_SIZE">
+<span id="c.PSA_MAC_FINAL_SIZE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_MAC_FINAL_SIZE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_MAC_FINAL_SIZE(key_type, key_bits, alg) \</span>
+<span class="cp"> ((alg) & PSA_ALG_MAC_TRUNCATION_MASK ? PSA_MAC_TRUNCATED_LENGTH(alg) : PSA_ALG_IS_HMAC(alg) ? PSA_HASH_SIZE(PSA_ALG_HMAC_GET_HASH(alg)) : PSA_ALG_IS_BLOCK_CIPHER_MAC(alg) ? PSA_BLOCK_CIPHER_BLOCK_SIZE(key_type) : ((void)(key_type), (void)(key_bits), 0))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">key_type</span></code></dt>
+<dd>The type of the MAC key.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">key_bits</span></code></dt>
+<dd>The size of the MAC key in bits.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>A MAC algorithm (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_MAC" title="PSA_ALG_IS_MAC"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_MAC</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>The MAC size for the specified algorithm with the specified key parameters.</p>
+<p>0 if the MAC algorithm is not recognized.</p>
+<p>Either 0 or the correct size for a MAC algorithm that the implementation recognizes, but does not support.</p>
+<p>Unspecified if the key parameters are not consistent with the algorithm.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>The size of the output of <a class="reference internal" href="#c.psa_mac_sign_finish" title="psa_mac_sign_finish"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_sign_finish()</span></code></a>, in bytes.</p>
+<p>This is also the MAC size that <a class="reference internal" href="#c.psa_mac_verify_finish" title="psa_mac_verify_finish"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_mac_verify_finish()</span></code></a> expects.</p>
+</div>
+<div class="section" id="PSA_AEAD_ENCRYPT_OUTPUT_SIZE">
+<span id="c.PSA_AEAD_ENCRYPT_OUTPUT_SIZE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_AEAD_ENCRYPT_OUTPUT_SIZE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_AEAD_ENCRYPT_OUTPUT_SIZE(alg, plaintext_length) \</span>
+<span class="cp"> (PSA_AEAD_TAG_LENGTH(alg) != 0 ? (plaintext_length) + PSA_AEAD_TAG_LENGTH(alg) : 0)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>An AEAD algorithm (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_AEAD" title="PSA_ALG_IS_AEAD"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_AEAD</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true).</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">plaintext_length</span></code></dt>
+<dd>Size of the plaintext in bytes.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>The AEAD ciphertext size for the specified algorithm. If the AEAD algorithm is not recognized, return 0. An implementation may return either 0 or a correct size for an AEAD algorithm that it recognizes, but does not support.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>The maximum size of the output of <a class="reference internal" href="#c.psa_aead_encrypt" title="psa_aead_encrypt"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_encrypt()</span></code></a>, in bytes.</p>
+<p>If the size of the ciphertext buffer is at least this large, it is guaranteed that <a class="reference internal" href="#c.psa_aead_encrypt" title="psa_aead_encrypt"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_encrypt()</span></code></a> will not fail due to an insufficient buffer size. Depending on the algorithm, the actual size of the ciphertext may be smaller.</p>
+</div>
+<div class="section" id="PSA_AEAD_DECRYPT_OUTPUT_SIZE">
+<span id="c.PSA_AEAD_DECRYPT_OUTPUT_SIZE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_AEAD_DECRYPT_OUTPUT_SIZE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_AEAD_DECRYPT_OUTPUT_SIZE(alg, ciphertext_length) \</span>
+<span class="cp"> (PSA_AEAD_TAG_LENGTH(alg) != 0 ? (ciphertext_length) - PSA_AEAD_TAG_LENGTH(alg) : 0)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>An AEAD algorithm (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_AEAD" title="PSA_ALG_IS_AEAD"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_AEAD</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true).</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">ciphertext_length</span></code></dt>
+<dd>Size of the plaintext in bytes.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>The AEAD ciphertext size for the specified algorithm. If the AEAD algorithm is not recognized, return 0. An implementation may return either 0 or a correct size for an AEAD algorithm that it recognizes, but does not support.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>The maximum size of the output of <a class="reference internal" href="#c.psa_aead_decrypt" title="psa_aead_decrypt"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_decrypt()</span></code></a>, in bytes.</p>
+<p>If the size of the plaintext buffer is at least this large, it is guaranteed that <a class="reference internal" href="#c.psa_aead_decrypt" title="psa_aead_decrypt"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_decrypt()</span></code></a> will not fail due to an insufficient buffer size. Depending on the algorithm, the actual size of the plaintext may be smaller.</p>
+</div>
+<div class="section" id="PSA_AEAD_UPDATE_OUTPUT_SIZE">
+<span id="c.PSA_AEAD_UPDATE_OUTPUT_SIZE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_AEAD_UPDATE_OUTPUT_SIZE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_AEAD_UPDATE_OUTPUT_SIZE(alg, input_length) \</span>
+<span class="cp"> (PSA_ALG_IS_AEAD_ON_BLOCK_CIPHER(alg) ? PSA_ROUND_UP_TO_MULTIPLE(PSA_MAX_BLOCK_CIPHER_BLOCK_SIZE, (input_length)) : (input_length))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>An AEAD algorithm (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_AEAD" title="PSA_ALG_IS_AEAD"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_AEAD</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true).</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">input_length</span></code></dt>
+<dd>Size of the input in bytes.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>A sufficient output buffer size for the specified algorithm. If the AEAD algorithm is not recognized, return 0. An implementation may return either 0 or a correct size for an AEAD algorithm that it recognizes, but does not support.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>A sufficient output buffer size for <a class="reference internal" href="#c.psa_aead_update" title="psa_aead_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update()</span></code></a>.</p>
+<p>If the size of the output buffer is at least this large, it is guaranteed that <a class="reference internal" href="#c.psa_aead_update" title="psa_aead_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update()</span></code></a> will not fail due to an insufficient buffer size. The actual size of the output may be smaller in any given call.</p>
+</div>
+<div class="section" id="PSA_AEAD_FINISH_OUTPUT_SIZE">
+<span id="c.PSA_AEAD_FINISH_OUTPUT_SIZE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_AEAD_FINISH_OUTPUT_SIZE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_AEAD_FINISH_OUTPUT_SIZE(alg) \</span>
+<span class="cp"> (PSA_ALG_IS_AEAD_ON_BLOCK_CIPHER(alg) ? PSA_MAX_BLOCK_CIPHER_BLOCK_SIZE : 0)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>An AEAD algorithm (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_AEAD" title="PSA_ALG_IS_AEAD"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_AEAD</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>A sufficient ciphertext buffer size for the specified algorithm. If the AEAD algorithm is not recognized, return 0. An implementation may return either 0 or a correct size for an AEAD algorithm that it recognizes, but does not support.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>A sufficient ciphertext buffer size for <a class="reference internal" href="#c.psa_aead_finish" title="psa_aead_finish"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_finish()</span></code></a>.</p>
+<p>If the size of the ciphertext buffer is at least this large, it is guaranteed that <a class="reference internal" href="#c.psa_aead_finish" title="psa_aead_finish"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_finish()</span></code></a> will not fail due to an insufficient ciphertext buffer size. The actual size of the output may be smaller in any given call.</p>
+</div>
+<div class="section" id="PSA_AEAD_VERIFY_OUTPUT_SIZE">
+<span id="c.PSA_AEAD_VERIFY_OUTPUT_SIZE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_AEAD_VERIFY_OUTPUT_SIZE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_AEAD_VERIFY_OUTPUT_SIZE(alg) \</span>
+<span class="cp"> (PSA_ALG_IS_AEAD_ON_BLOCK_CIPHER(alg) ? PSA_MAX_BLOCK_CIPHER_BLOCK_SIZE : 0)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>An AEAD algorithm (<code class="docutils literal notranslate"><span class="pre">PSA_ALG_XXX</span></code> value such that <a class="reference internal" href="#c.PSA_ALG_IS_AEAD" title="PSA_ALG_IS_AEAD"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ALG_IS_AEAD</span></code></a>(<code class="docutils literal notranslate"><span class="pre">alg</span></code>) is true).</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>A sufficient plaintext buffer size for the specified algorithm. If the AEAD algorithm is not recognized, return 0. An implementation may return either 0 or a correct size for an AEAD algorithm that it recognizes, but does not support.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>A sufficient plaintext buffer size for <a class="reference internal" href="#c.psa_aead_verify" title="psa_aead_verify"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_verify()</span></code></a>.</p>
+<p>If the size of the plaintext buffer is at least this large, it is guaranteed that <a class="reference internal" href="#c.psa_aead_verify" title="psa_aead_verify"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_verify()</span></code></a> will not fail due to an insufficient plaintext buffer size. The actual size of the output may be smaller in any given call.</p>
+</div>
+<div class="section" id="PSA_RSA_MINIMUM_PADDING_SIZE">
+<span id="c.PSA_RSA_MINIMUM_PADDING_SIZE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_RSA_MINIMUM_PADDING_SIZE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_RSA_MINIMUM_PADDING_SIZE(alg) \</span>
+<span class="cp"> (PSA_ALG_IS_RSA_OAEP(alg) ? 2 * PSA_HASH_SIZE(PSA_ALG_RSA_OAEP_GET_HASH(alg)) + 1 : 11 </span><span class="cm">/*PKCS#1v1.5*/</span><span class="cp">)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+</div>
+<div class="section" id="PSA_ECDSA_SIGNATURE_SIZE">
+<span id="c.PSA_ECDSA_SIGNATURE_SIZE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ECDSA_SIGNATURE_SIZE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ECDSA_SIGNATURE_SIZE(curve_bits) \</span>
+<span class="cp"> (PSA_BITS_TO_BYTES(curve_bits) * 2)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">curve_bits</span></code></dt>
+<dd>Curve size in bits.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>Signature size in bytes.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>ECDSA signature size for a given curve bit size.</p>
+<div class="admonition note">
+<p class="first admonition-title">Note</p>
+<p class="last">This macro returns a compile-time constant if its argument is one.</p>
+</div>
+</div>
+<div class="section" id="PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE">
+<span id="c.PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE(key_type, key_bits, alg) \</span>
+<span class="cp"> (PSA_KEY_TYPE_IS_RSA(key_type) ? ((void)alg, PSA_BITS_TO_BYTES(key_bits)) : PSA_KEY_TYPE_IS_ECC(key_type) ? PSA_ECDSA_SIGNATURE_SIZE(key_bits) : ((void)alg, 0))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">key_type</span></code></dt>
+<dd>An asymmetric key type (this may indifferently be a key pair type or a public key type).</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">key_bits</span></code></dt>
+<dd>The size of the key in bits.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>The signature algorithm.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>If the parameters are valid and supported, return a buffer size in bytes that guarantees that <a class="reference internal" href="#c.psa_asymmetric_sign" title="psa_asymmetric_sign"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_asymmetric_sign()</span></code></a> will not fail with <a class="reference internal" href="#c.PSA_ERROR_BUFFER_TOO_SMALL" title="PSA_ERROR_BUFFER_TOO_SMALL"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ERROR_BUFFER_TOO_SMALL</span></code></a>. If the parameters are a valid combination that is not supported by the implementation, this macro shall return either a sensible size or 0. If the parameters are not valid, the return value is unspecified.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Sufficient signature buffer size for <a class="reference internal" href="#c.psa_asymmetric_sign" title="psa_asymmetric_sign"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_asymmetric_sign()</span></code></a>.</p>
+<p>This macro returns a sufficient buffer size for a signature using a key of the specified type and size, with the specified algorithm. Note that the actual size of the signature may be smaller (some algorithms produce a variable-size signature).</p>
+<div class="admonition warning">
+<p class="first admonition-title">Warning</p>
+<p class="last">This function may call its arguments multiple times or zero times, so you should not pass arguments that contain side effects.</p>
+</div>
+</div>
+<div class="section" id="PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE">
+<span id="c.PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE(key_type, key_bits, alg) \</span>
+<span class="cp"> (PSA_KEY_TYPE_IS_RSA(key_type) ? ((void)alg, PSA_BITS_TO_BYTES(key_bits)) : 0)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">key_type</span></code></dt>
+<dd>An asymmetric key type (this may indifferently be a key pair type or a public key type).</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">key_bits</span></code></dt>
+<dd>The size of the key in bits.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>The signature algorithm.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>If the parameters are valid and supported, return a buffer size in bytes that guarantees that <a class="reference internal" href="#c.psa_asymmetric_encrypt" title="psa_asymmetric_encrypt"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_asymmetric_encrypt()</span></code></a> will not fail with <a class="reference internal" href="#c.PSA_ERROR_BUFFER_TOO_SMALL" title="PSA_ERROR_BUFFER_TOO_SMALL"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ERROR_BUFFER_TOO_SMALL</span></code></a>. If the parameters are a valid combination that is not supported by the implementation, this macro shall return either a sensible size or 0. If the parameters are not valid, the return value is unspecified.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Sufficient output buffer size for <a class="reference internal" href="#c.psa_asymmetric_encrypt" title="psa_asymmetric_encrypt"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_asymmetric_encrypt()</span></code></a>.</p>
+<p>This macro returns a sufficient buffer size for a ciphertext produced using a key of the specified type and size, with the specified algorithm. Note that the actual size of the ciphertext may be smaller, depending on the algorithm.</p>
+<div class="admonition warning">
+<p class="first admonition-title">Warning</p>
+<p class="last">This function may call its arguments multiple times or zero times, so you should not pass arguments that contain side effects.</p>
+</div>
+</div>
+<div class="section" id="PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE">
+<span id="c.PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE(key_type, key_bits, alg) \</span>
+<span class="cp"> (PSA_KEY_TYPE_IS_RSA(key_type) ? PSA_BITS_TO_BYTES(key_bits) - PSA_RSA_MINIMUM_PADDING_SIZE(alg) : 0)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">key_type</span></code></dt>
+<dd>An asymmetric key type (this may indifferently be a key pair type or a public key type).</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">key_bits</span></code></dt>
+<dd>The size of the key in bits.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">alg</span></code></dt>
+<dd>The signature algorithm.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>If the parameters are valid and supported, return a buffer size in bytes that guarantees that <a class="reference internal" href="#c.psa_asymmetric_decrypt" title="psa_asymmetric_decrypt"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_asymmetric_decrypt()</span></code></a> will not fail with <a class="reference internal" href="#c.PSA_ERROR_BUFFER_TOO_SMALL" title="PSA_ERROR_BUFFER_TOO_SMALL"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ERROR_BUFFER_TOO_SMALL</span></code></a>. If the parameters are a valid combination that is not supported by the implementation, this macro shall return either a sensible size or 0. If the parameters are not valid, the return value is unspecified.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Sufficient output buffer size for <a class="reference internal" href="#c.psa_asymmetric_decrypt" title="psa_asymmetric_decrypt"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_asymmetric_decrypt()</span></code></a>.</p>
+<p>This macro returns a sufficient buffer size for a ciphertext produced using a key of the specified type and size, with the specified algorithm. Note that the actual size of the ciphertext may be smaller, depending on the algorithm.</p>
+<div class="admonition warning">
+<p class="first admonition-title">Warning</p>
+<p class="last">This function may call its arguments multiple times or zero times, so you should not pass arguments that contain side effects.</p>
+</div>
+</div>
+<div class="section" id="PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE">
+<span id="c.PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE(bits) ((bits) / 8 + 5)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">bits</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+</div>
+<div class="section" id="PSA_KEY_EXPORT_RSA_PUBLIC_KEY_MAX_SIZE">
+<span id="c.PSA_KEY_EXPORT_RSA_PUBLIC_KEY_MAX_SIZE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_EXPORT_RSA_PUBLIC_KEY_MAX_SIZE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_EXPORT_RSA_PUBLIC_KEY_MAX_SIZE(key_bits) \</span>
+<span class="cp"> (PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE(key_bits) + 11)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">key_bits</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+</div>
+<div class="section" id="PSA_KEY_EXPORT_RSA_KEY_PAIR_MAX_SIZE">
+<span id="c.PSA_KEY_EXPORT_RSA_KEY_PAIR_MAX_SIZE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_EXPORT_RSA_KEY_PAIR_MAX_SIZE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_EXPORT_RSA_KEY_PAIR_MAX_SIZE(key_bits) \</span>
+<span class="cp"> (9 * PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE((key_bits) / 2 + 1) + 14)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">key_bits</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+</div>
+<div class="section" id="PSA_KEY_EXPORT_DSA_PUBLIC_KEY_MAX_SIZE">
+<span id="c.PSA_KEY_EXPORT_DSA_PUBLIC_KEY_MAX_SIZE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_EXPORT_DSA_PUBLIC_KEY_MAX_SIZE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_EXPORT_DSA_PUBLIC_KEY_MAX_SIZE(key_bits) \</span>
+<span class="cp"> (PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE(key_bits) * 3 + 59)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">key_bits</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+</div>
+<div class="section" id="PSA_KEY_EXPORT_DSA_KEY_PAIR_MAX_SIZE">
+<span id="c.PSA_KEY_EXPORT_DSA_KEY_PAIR_MAX_SIZE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_EXPORT_DSA_KEY_PAIR_MAX_SIZE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_EXPORT_DSA_KEY_PAIR_MAX_SIZE(key_bits) \</span>
+<span class="cp"> (PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE(key_bits) * 3 + 75)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">key_bits</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+</div>
+<div class="section" id="PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE">
+<span id="c.PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE(key_bits) \</span>
+<span class="cp"> (2 * PSA_BITS_TO_BYTES(key_bits) + 1)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">key_bits</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+</div>
+<div class="section" id="PSA_KEY_EXPORT_ECC_KEY_PAIR_MAX_SIZE">
+<span id="c.PSA_KEY_EXPORT_ECC_KEY_PAIR_MAX_SIZE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_EXPORT_ECC_KEY_PAIR_MAX_SIZE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_EXPORT_ECC_KEY_PAIR_MAX_SIZE(key_bits) \</span>
+<span class="cp"> (PSA_BITS_TO_BYTES(key_bits))</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">key_bits</span></code></dt>
+<dd></dd>
+</dl>
+<p class="subitem-title"><strong>Description:</strong></p>
+</div>
+<div class="section" id="PSA_KEY_EXPORT_MAX_SIZE">
+<span id="c.PSA_KEY_EXPORT_MAX_SIZE"></span><h2><code class="docutils literal notranslate"><span class="pre">PSA_KEY_EXPORT_MAX_SIZE</span></code> (macro)</h2>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#define PSA_KEY_EXPORT_MAX_SIZE(key_type, key_bits) \</span>
+<span class="cp"> (PSA_KEY_TYPE_IS_UNSTRUCTURED(key_type) ? PSA_BITS_TO_BYTES(key_bits) : (key_type) == PSA_KEY_TYPE_RSA_KEY_PAIR ? PSA_KEY_EXPORT_RSA_KEY_PAIR_MAX_SIZE(key_bits) : (key_type) == PSA_KEY_TYPE_RSA_PUBLIC_KEY ? PSA_KEY_EXPORT_RSA_PUBLIC_KEY_MAX_SIZE(key_bits) : (key_type) == PSA_KEY_TYPE_DSA_KEY_PAIR ? PSA_KEY_EXPORT_DSA_KEY_PAIR_MAX_SIZE(key_bits) : (key_type) == PSA_KEY_TYPE_DSA_PUBLIC_KEY ? PSA_KEY_EXPORT_DSA_PUBLIC_KEY_MAX_SIZE(key_bits) : PSA_KEY_TYPE_IS_ECC_KEY_PAIR(key_type) ? PSA_KEY_EXPORT_ECC_KEY_PAIR_MAX_SIZE(key_bits) : PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY(key_type) ? PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE(key_bits) : 0)</span>
+</pre></div>
+</div>
+<p class="subitem-title"><strong>Parameters:</strong> </p>
+<dl class="docutils">
+<dt> <code class="docutils literal notranslate"><span class="pre">key_type</span></code></dt>
+<dd>A supported key type.</dd>
+<dt> <code class="docutils literal notranslate"><span class="pre">key_bits</span></code></dt>
+<dd>The size of the key in bits.</dd>
+</dl>
+<p class="subitem-title"><strong>Returns:</strong> </p>
+<p>If the parameters are valid and supported, return a buffer size in bytes that guarantees that <a class="reference internal" href="#c.psa_asymmetric_sign" title="psa_asymmetric_sign"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_asymmetric_sign()</span></code></a> will not fail with <a class="reference internal" href="#c.PSA_ERROR_BUFFER_TOO_SMALL" title="PSA_ERROR_BUFFER_TOO_SMALL"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ERROR_BUFFER_TOO_SMALL</span></code></a>. If the parameters are a valid combination that is not supported by the implementation, this macro shall return either a sensible size or 0. If the parameters are not valid, the return value is unspecified.</p>
+<p class="subitem-title"><strong>Description:</strong></p>
+<p>Sufficient output buffer size for <a class="reference internal" href="#c.psa_export_key" title="psa_export_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_export_key()</span></code></a> or <a class="reference internal" href="#c.psa_export_public_key" title="psa_export_public_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_export_public_key()</span></code></a>.</p>
+<p>This macro returns a compile-time constant if its arguments are compile-time constants.</p>
+<div class="admonition warning">
+<p class="first admonition-title">Warning</p>
+<p class="last">This function may call its arguments multiple times or zero times, so you should not pass arguments that contain side effects.</p>
+</div>
+<p>The following code illustrates how to allocate enough memory to export a key by querying the key type and size at runtime.</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_key_attributes_t</span> <span class="n">attributes</span> <span class="o">=</span> <span class="n">PSA_KEY_ATTRIBUTES_INIT</span><span class="p">;</span>
+<span class="n">psa_status_t</span> <span class="n">status</span><span class="p">;</span>
+<span class="n">status</span> <span class="o">=</span> <span class="n">psa_get_key_attributes</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="o">&</span><span class="n">attributes</span><span class="p">);</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">status</span> <span class="o">!=</span> <span class="n">PSA_SUCCESS</span><span class="p">)</span> <span class="n">handle_error</span><span class="p">(...);</span>
+<span class="n">psa_key_type_t</span> <span class="n">key_type</span> <span class="o">=</span> <span class="n">psa_get_key_type</span><span class="p">(</span><span class="o">&</span><span class="n">attributes</span><span class="p">);</span>
+<span class="kt">size_t</span> <span class="n">key_bits</span> <span class="o">=</span> <span class="n">psa_get_key_bits</span><span class="p">(</span><span class="o">&</span><span class="n">attributes</span><span class="p">);</span>
+<span class="kt">size_t</span> <span class="n">buffer_size</span> <span class="o">=</span> <span class="n">PSA_KEY_EXPORT_MAX_SIZE</span><span class="p">(</span><span class="n">key_type</span><span class="p">,</span> <span class="n">key_bits</span><span class="p">);</span>
+<span class="n">psa_reset_key_attributes</span><span class="p">(</span><span class="o">&</span><span class="n">attributes</span><span class="p">);</span>
+<span class="kt">unsigned</span> <span class="kt">char</span> <span class="o">*</span><span class="n">buffer</span> <span class="o">=</span> <span class="n">malloc</span><span class="p">(</span><span class="n">buffer_size</span><span class="p">);</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">buffer</span> <span class="o">==</span> <span class="nb">NULL</span><span class="p">)</span> <span class="n">handle_error</span><span class="p">(...);</span>
+<span class="kt">size_t</span> <span class="n">buffer_length</span><span class="p">;</span>
+<span class="n">status</span> <span class="o">=</span> <span class="n">psa_export_key</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">buffer</span><span class="p">,</span> <span class="n">buffer_size</span><span class="p">,</span> <span class="o">&</span><span class="n">buffer_length</span><span class="p">);</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">status</span> <span class="o">!=</span> <span class="n">PSA_SUCCESS</span><span class="p">)</span> <span class="n">handle_error</span><span class="p">(...);</span>
+</pre></div>
+</div>
+<p>For <a class="reference internal" href="#c.psa_export_public_key" title="psa_export_public_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_export_public_key()</span></code></a>, calculate the buffer size from the public key type. You can use the macro <a class="reference internal" href="#c.PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR" title="PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR</span></code></a> to convert a key pair type to the corresponding public key type.</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">psa_key_attributes_t</span> <span class="n">attributes</span> <span class="o">=</span> <span class="n">PSA_KEY_ATTRIBUTES_INIT</span><span class="p">;</span>
+<span class="n">psa_status_t</span> <span class="n">status</span><span class="p">;</span>
+<span class="n">status</span> <span class="o">=</span> <span class="n">psa_get_key_attributes</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="o">&</span><span class="n">attributes</span><span class="p">);</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">status</span> <span class="o">!=</span> <span class="n">PSA_SUCCESS</span><span class="p">)</span> <span class="n">handle_error</span><span class="p">(...);</span>
+<span class="n">psa_key_type_t</span> <span class="n">key_type</span> <span class="o">=</span> <span class="n">psa_get_key_type</span><span class="p">(</span><span class="o">&</span><span class="n">attributes</span><span class="p">);</span>
+<span class="n">psa_key_type_t</span> <span class="n">public_key_type</span> <span class="o">=</span> <span class="n">PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR</span><span class="p">(</span><span class="n">key_type</span><span class="p">);</span>
+<span class="kt">size_t</span> <span class="n">key_bits</span> <span class="o">=</span> <span class="n">psa_get_key_bits</span><span class="p">(</span><span class="o">&</span><span class="n">attributes</span><span class="p">);</span>
+<span class="kt">size_t</span> <span class="n">buffer_size</span> <span class="o">=</span> <span class="n">PSA_KEY_EXPORT_MAX_SIZE</span><span class="p">(</span><span class="n">public_key_type</span><span class="p">,</span> <span class="n">key_bits</span><span class="p">);</span>
+<span class="n">psa_reset_key_attributes</span><span class="p">(</span><span class="o">&</span><span class="n">attributes</span><span class="p">);</span>
+<span class="kt">unsigned</span> <span class="kt">char</span> <span class="o">*</span><span class="n">buffer</span> <span class="o">=</span> <span class="n">malloc</span><span class="p">(</span><span class="n">buffer_size</span><span class="p">);</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">buffer</span> <span class="o">==</span> <span class="nb">NULL</span><span class="p">)</span> <span class="n">handle_error</span><span class="p">(...);</span>
+<span class="kt">size_t</span> <span class="n">buffer_length</span><span class="p">;</span>
+<span class="n">status</span> <span class="o">=</span> <span class="n">psa_export_public_key</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">buffer</span><span class="p">,</span> <span class="n">buffer_size</span><span class="p">,</span> <span class="o">&</span><span class="n">buffer_length</span><span class="p">);</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">status</span> <span class="o">!=</span> <span class="n">PSA_SUCCESS</span><span class="p">)</span> <span class="n">handle_error</span><span class="p">(...);</span>
+</pre></div>
+</div>
+</div>
+</div>
+
+
+ </div>
+
+ </div>
+ </div>
+ <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
+ <div class="sphinxsidebarwrapper">
+<h1 class="logo"><a href="index.html">psa_crypto_api</a></h1>
+
+
+
+
+
+
+
+
+<h3>Navigation</h3>
+<ul class="current">
+<li class="toctree-l1"><a class="reference internal" href="general.html">Introduction</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#design-goals">Design goals</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#functionality-overview">Functionality overview</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#sample-architectures">Sample architectures</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#library-conventions">Library conventions</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#implementation-considerations">Implementation considerations</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#usage-considerations">Usage considerations</a></li>
+<li class="toctree-l1 current"><a class="current reference internal" href="#">Implementation-specific definitions</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="#psa_key_handle_t"><code class="docutils literal notranslate"><span class="pre">psa_key_handle_t</span></code> (type)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="#library-initialization">Library initialization</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="#psa_crypto_init"><code class="docutils literal notranslate"><span class="pre">psa_crypto_init</span></code> (function)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="#key-attributes">Key attributes</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="#psa_key_attributes_t"><code class="docutils literal notranslate"><span class="pre">psa_key_attributes_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_ATTRIBUTES_INIT"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_ATTRIBUTES_INIT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_key_attributes_init"><code class="docutils literal notranslate"><span class="pre">psa_key_attributes_init</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_set_key_id"><code class="docutils literal notranslate"><span class="pre">psa_set_key_id</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_set_key_lifetime"><code class="docutils literal notranslate"><span class="pre">psa_set_key_lifetime</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_get_key_id"><code class="docutils literal notranslate"><span class="pre">psa_get_key_id</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_get_key_lifetime"><code class="docutils literal notranslate"><span class="pre">psa_get_key_lifetime</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_set_key_usage_flags"><code class="docutils literal notranslate"><span class="pre">psa_set_key_usage_flags</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_get_key_usage_flags"><code class="docutils literal notranslate"><span class="pre">psa_get_key_usage_flags</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_set_key_algorithm"><code class="docutils literal notranslate"><span class="pre">psa_set_key_algorithm</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_get_key_algorithm"><code class="docutils literal notranslate"><span class="pre">psa_get_key_algorithm</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_set_key_type"><code class="docutils literal notranslate"><span class="pre">psa_set_key_type</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_set_key_bits"><code class="docutils literal notranslate"><span class="pre">psa_set_key_bits</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_get_key_type"><code class="docutils literal notranslate"><span class="pre">psa_get_key_type</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_get_key_bits"><code class="docutils literal notranslate"><span class="pre">psa_get_key_bits</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_get_key_attributes"><code class="docutils literal notranslate"><span class="pre">psa_get_key_attributes</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_reset_key_attributes"><code class="docutils literal notranslate"><span class="pre">psa_reset_key_attributes</span></code> (function)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="#key-management">Key management</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="#psa_open_key"><code class="docutils literal notranslate"><span class="pre">psa_open_key</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_close_key"><code class="docutils literal notranslate"><span class="pre">psa_close_key</span></code> (function)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="#key-import-and-export">Key import and export</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="#psa_import_key"><code class="docutils literal notranslate"><span class="pre">psa_import_key</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_destroy_key"><code class="docutils literal notranslate"><span class="pre">psa_destroy_key</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_export_key"><code class="docutils literal notranslate"><span class="pre">psa_export_key</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_export_public_key"><code class="docutils literal notranslate"><span class="pre">psa_export_public_key</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_copy_key"><code class="docutils literal notranslate"><span class="pre">psa_copy_key</span></code> (function)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="#message-digests">Message digests</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="#psa_hash_operation_t"><code class="docutils literal notranslate"><span class="pre">psa_hash_operation_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_HASH_OPERATION_INIT"><code class="docutils literal notranslate"><span class="pre">PSA_HASH_OPERATION_INIT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_hash_compute"><code class="docutils literal notranslate"><span class="pre">psa_hash_compute</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_hash_compare"><code class="docutils literal notranslate"><span class="pre">psa_hash_compare</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_hash_operation_init"><code class="docutils literal notranslate"><span class="pre">psa_hash_operation_init</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_hash_setup"><code class="docutils literal notranslate"><span class="pre">psa_hash_setup</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_hash_update"><code class="docutils literal notranslate"><span class="pre">psa_hash_update</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_hash_finish"><code class="docutils literal notranslate"><span class="pre">psa_hash_finish</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_hash_verify"><code class="docutils literal notranslate"><span class="pre">psa_hash_verify</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_hash_abort"><code class="docutils literal notranslate"><span class="pre">psa_hash_abort</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_hash_clone"><code class="docutils literal notranslate"><span class="pre">psa_hash_clone</span></code> (function)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="#message-authentication-codes">Message authentication codes</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="#psa_mac_operation_t"><code class="docutils literal notranslate"><span class="pre">psa_mac_operation_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_MAC_OPERATION_INIT"><code class="docutils literal notranslate"><span class="pre">PSA_MAC_OPERATION_INIT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_mac_compute"><code class="docutils literal notranslate"><span class="pre">psa_mac_compute</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_mac_verify"><code class="docutils literal notranslate"><span class="pre">psa_mac_verify</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_mac_operation_init"><code class="docutils literal notranslate"><span class="pre">psa_mac_operation_init</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_mac_sign_setup"><code class="docutils literal notranslate"><span class="pre">psa_mac_sign_setup</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_mac_verify_setup"><code class="docutils literal notranslate"><span class="pre">psa_mac_verify_setup</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_mac_update"><code class="docutils literal notranslate"><span class="pre">psa_mac_update</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_mac_sign_finish"><code class="docutils literal notranslate"><span class="pre">psa_mac_sign_finish</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_mac_verify_finish"><code class="docutils literal notranslate"><span class="pre">psa_mac_verify_finish</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_mac_abort"><code class="docutils literal notranslate"><span class="pre">psa_mac_abort</span></code> (function)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="#symmetric-ciphers">Symmetric ciphers</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="#psa_cipher_operation_t"><code class="docutils literal notranslate"><span class="pre">psa_cipher_operation_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_CIPHER_OPERATION_INIT"><code class="docutils literal notranslate"><span class="pre">PSA_CIPHER_OPERATION_INIT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_cipher_encrypt"><code class="docutils literal notranslate"><span class="pre">psa_cipher_encrypt</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_cipher_decrypt"><code class="docutils literal notranslate"><span class="pre">psa_cipher_decrypt</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_cipher_operation_init"><code class="docutils literal notranslate"><span class="pre">psa_cipher_operation_init</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_cipher_encrypt_setup"><code class="docutils literal notranslate"><span class="pre">psa_cipher_encrypt_setup</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_cipher_decrypt_setup"><code class="docutils literal notranslate"><span class="pre">psa_cipher_decrypt_setup</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_cipher_generate_iv"><code class="docutils literal notranslate"><span class="pre">psa_cipher_generate_iv</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_cipher_set_iv"><code class="docutils literal notranslate"><span class="pre">psa_cipher_set_iv</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_cipher_update"><code class="docutils literal notranslate"><span class="pre">psa_cipher_update</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_cipher_finish"><code class="docutils literal notranslate"><span class="pre">psa_cipher_finish</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_cipher_abort"><code class="docutils literal notranslate"><span class="pre">psa_cipher_abort</span></code> (function)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="#authenticated-encryption-with-associated-data-aead">Authenticated encryption with associated data (AEAD)</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="#psa_aead_operation_t"><code class="docutils literal notranslate"><span class="pre">psa_aead_operation_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_AEAD_OPERATION_INIT"><code class="docutils literal notranslate"><span class="pre">PSA_AEAD_OPERATION_INIT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_aead_encrypt"><code class="docutils literal notranslate"><span class="pre">psa_aead_encrypt</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_aead_decrypt"><code class="docutils literal notranslate"><span class="pre">psa_aead_decrypt</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_aead_operation_init"><code class="docutils literal notranslate"><span class="pre">psa_aead_operation_init</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_aead_encrypt_setup"><code class="docutils literal notranslate"><span class="pre">psa_aead_encrypt_setup</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_aead_decrypt_setup"><code class="docutils literal notranslate"><span class="pre">psa_aead_decrypt_setup</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_aead_generate_nonce"><code class="docutils literal notranslate"><span class="pre">psa_aead_generate_nonce</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_aead_set_nonce"><code class="docutils literal notranslate"><span class="pre">psa_aead_set_nonce</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_aead_set_lengths"><code class="docutils literal notranslate"><span class="pre">psa_aead_set_lengths</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_aead_update_ad"><code class="docutils literal notranslate"><span class="pre">psa_aead_update_ad</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_aead_update"><code class="docutils literal notranslate"><span class="pre">psa_aead_update</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_aead_finish"><code class="docutils literal notranslate"><span class="pre">psa_aead_finish</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_aead_verify"><code class="docutils literal notranslate"><span class="pre">psa_aead_verify</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_aead_abort"><code class="docutils literal notranslate"><span class="pre">psa_aead_abort</span></code> (function)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="#asymmetric-cryptography">Asymmetric cryptography</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="#psa_asymmetric_sign"><code class="docutils literal notranslate"><span class="pre">psa_asymmetric_sign</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_asymmetric_verify"><code class="docutils literal notranslate"><span class="pre">psa_asymmetric_verify</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_asymmetric_encrypt"><code class="docutils literal notranslate"><span class="pre">psa_asymmetric_encrypt</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_asymmetric_decrypt"><code class="docutils literal notranslate"><span class="pre">psa_asymmetric_decrypt</span></code> (function)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="#key-derivation-and-pseudorandom-generation">Key derivation and pseudorandom generation</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="#psa_key_derivation_operation_t"><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_operation_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_DERIVATION_OPERATION_INIT"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_OPERATION_INIT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_DERIVATION_UNLIMITED_CAPACITY"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_UNLIMITED_CAPACITY</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_key_derivation_operation_init"><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_operation_init</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_key_derivation_setup"><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_setup</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_key_derivation_get_capacity"><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_get_capacity</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_key_derivation_set_capacity"><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_set_capacity</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_key_derivation_input_bytes"><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_input_bytes</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_key_derivation_input_key"><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_input_key</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_key_derivation_key_agreement"><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_key_agreement</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_key_derivation_output_bytes"><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_output_bytes</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_key_derivation_output_key"><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_output_key</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_key_derivation_abort"><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_abort</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_raw_key_agreement"><code class="docutils literal notranslate"><span class="pre">psa_raw_key_agreement</span></code> (function)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="#random-generation">Random generation</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="#psa_generate_random"><code class="docutils literal notranslate"><span class="pre">psa_generate_random</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_generate_key"><code class="docutils literal notranslate"><span class="pre">psa_generate_key</span></code> (function)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="#error-codes">Error codes</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="#psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ERROR_GENERIC_ERROR"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_GENERIC_ERROR</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ERROR_NOT_PERMITTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_PERMITTED</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ERROR_BUFFER_TOO_SMALL"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BUFFER_TOO_SMALL</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ERROR_ALREADY_EXISTS"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_ALREADY_EXISTS</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ERROR_DOES_NOT_EXIST"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_DOES_NOT_EXIST</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ERROR_INSUFFICIENT_STORAGE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_STORAGE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ERROR_STORAGE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_STORAGE_FAILURE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ERROR_INSUFFICIENT_ENTROPY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_ENTROPY</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ERROR_INVALID_SIGNATURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_SIGNATURE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ERROR_INVALID_PADDING"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_PADDING</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ERROR_INSUFFICIENT_DATA"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_DATA</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ERROR_INVALID_HANDLE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_HANDLE</span></code> (macro)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="#key-and-algorithm-types">Key and algorithm types</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="#psa_key_type_t"><code class="docutils literal notranslate"><span class="pre">psa_key_type_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_ecc_curve_t"><code class="docutils literal notranslate"><span class="pre">psa_ecc_curve_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_dh_group_t"><code class="docutils literal notranslate"><span class="pre">psa_dh_group_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_algorithm_t"><code class="docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_NONE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_NONE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_VENDOR_FLAG"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_VENDOR_FLAG</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_CATEGORY_MASK"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_CATEGORY_MASK</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_CATEGORY_SYMMETRIC"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_CATEGORY_SYMMETRIC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_CATEGORY_RAW"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_CATEGORY_RAW</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_CATEGORY_KEY_PAIR"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_CATEGORY_KEY_PAIR</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_CATEGORY_FLAG_PAIR"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_CATEGORY_FLAG_PAIR</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_IS_VENDOR_DEFINED"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_VENDOR_DEFINED</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_IS_UNSTRUCTURED"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_UNSTRUCTURED</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_IS_ASYMMETRIC"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_ASYMMETRIC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_IS_PUBLIC_KEY"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_PUBLIC_KEY</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_IS_KEY_PAIR"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_KEY_PAIR</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_KEY_PAIR_OF_PUBLIC_KEY"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_KEY_PAIR_OF_PUBLIC_KEY</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_RAW_DATA"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_RAW_DATA</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_HMAC"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_HMAC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_DERIVE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_DERIVE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_AES"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_AES</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_DES"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_DES</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_CAMELLIA"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_CAMELLIA</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_ARC4"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_ARC4</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_CHACHA20"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_CHACHA20</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_RSA_PUBLIC_KEY"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_RSA_PUBLIC_KEY</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_RSA_KEY_PAIR"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_RSA_KEY_PAIR</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_IS_RSA"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_RSA</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_ECC_KEY_PAIR_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_ECC_KEY_PAIR_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_ECC_CURVE_MASK"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_ECC_CURVE_MASK</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_ECC_KEY_PAIR"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_ECC_KEY_PAIR</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_ECC_PUBLIC_KEY"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_ECC_PUBLIC_KEY</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_IS_ECC"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_ECC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_IS_ECC_KEY_PAIR"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_ECC_KEY_PAIR</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_GET_CURVE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_GET_CURVE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_SECT163K1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT163K1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_SECT163R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT163R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_SECT163R2"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT163R2</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_SECT193R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT193R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_SECT193R2"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT193R2</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_SECT233K1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT233K1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_SECT233R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT233R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_SECT239K1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT239K1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_SECT283K1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT283K1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_SECT283R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT283R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_SECT409K1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT409K1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_SECT409R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT409R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_SECT571K1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT571K1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_SECT571R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT571R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_SECP160K1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP160K1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_SECP160R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP160R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_SECP160R2"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP160R2</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_SECP192K1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP192K1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_SECP192R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP192R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_SECP224K1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP224K1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_SECP224R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP224R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_SECP256K1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP256K1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_SECP256R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP256R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_SECP384R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP384R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_SECP521R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP521R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_BRAINPOOL_P256R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_BRAINPOOL_P256R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_BRAINPOOL_P384R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_BRAINPOOL_P384R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_BRAINPOOL_P512R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_BRAINPOOL_P512R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_CURVE25519"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_CURVE25519</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_CURVE448"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_CURVE448</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_DH_PUBLIC_KEY_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_DH_PUBLIC_KEY_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_DH_KEY_PAIR_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_DH_KEY_PAIR_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_DH_GROUP_MASK"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_DH_GROUP_MASK</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_DH_KEY_PAIR"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_DH_KEY_PAIR</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_DH_PUBLIC_KEY"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_DH_PUBLIC_KEY</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_IS_DH"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_DH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_IS_DH_KEY_PAIR"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_DH_KEY_PAIR</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_IS_DH_PUBLIC_KEY"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_DH_PUBLIC_KEY</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_TYPE_GET_GROUP"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_GET_GROUP</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_DH_GROUP_FFDHE2048"><code class="docutils literal notranslate"><span class="pre">PSA_DH_GROUP_FFDHE2048</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_DH_GROUP_FFDHE3072"><code class="docutils literal notranslate"><span class="pre">PSA_DH_GROUP_FFDHE3072</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_DH_GROUP_FFDHE4096"><code class="docutils literal notranslate"><span class="pre">PSA_DH_GROUP_FFDHE4096</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_DH_GROUP_FFDHE6144"><code class="docutils literal notranslate"><span class="pre">PSA_DH_GROUP_FFDHE6144</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_DH_GROUP_FFDHE8192"><code class="docutils literal notranslate"><span class="pre">PSA_DH_GROUP_FFDHE8192</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_BLOCK_CIPHER_BLOCK_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_BLOCK_CIPHER_BLOCK_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_VENDOR_FLAG"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_VENDOR_FLAG</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_CATEGORY_MASK"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CATEGORY_MASK</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_CATEGORY_HASH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CATEGORY_HASH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_CATEGORY_MAC"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CATEGORY_MAC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_CATEGORY_CIPHER"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CATEGORY_CIPHER</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_CATEGORY_AEAD"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CATEGORY_AEAD</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_CATEGORY_SIGN"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CATEGORY_SIGN</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_CATEGORY_KEY_DERIVATION"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CATEGORY_KEY_DERIVATION</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_CATEGORY_KEY_AGREEMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CATEGORY_KEY_AGREEMENT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_IS_VENDOR_DEFINED"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_VENDOR_DEFINED</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_IS_HASH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_HASH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_IS_MAC"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_MAC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_IS_CIPHER"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_CIPHER</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_IS_AEAD"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_AEAD</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_IS_SIGN"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_SIGN</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_IS_ASYMMETRIC_ENCRYPTION"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_ASYMMETRIC_ENCRYPTION</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_IS_KEY_AGREEMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_KEY_AGREEMENT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_IS_KEY_DERIVATION"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_KEY_DERIVATION</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_HASH_MASK"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_HASH_MASK</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_MD2"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_MD2</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_MD4"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_MD4</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_MD5"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_MD5</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_RIPEMD160"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RIPEMD160</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_SHA_1"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA_1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_SHA_224"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA_224</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_SHA_256"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA_256</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_SHA_384"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA_384</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_SHA_512"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA_512</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_SHA_512_224"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA_512_224</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_SHA_512_256"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA_512_256</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_SHA3_224"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA3_224</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_SHA3_256"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA3_256</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_SHA3_384"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA3_384</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_SHA3_512"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA3_512</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_ANY_HASH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_ANY_HASH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_MAC_SUBCATEGORY_MASK"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_MAC_SUBCATEGORY_MASK</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_HMAC_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_HMAC_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_HMAC"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_HMAC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_HMAC_GET_HASH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_HMAC_GET_HASH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_IS_HMAC"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_HMAC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_MAC_TRUNCATION_MASK"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_MAC_TRUNCATION_MASK</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_MAC_TRUNCATION_OFFSET"><code class="docutils literal notranslate"><span class="pre">PSA_MAC_TRUNCATION_OFFSET</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_TRUNCATED_MAC"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_TRUNCATED_MAC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_FULL_LENGTH_MAC"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_FULL_LENGTH_MAC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_MAC_TRUNCATED_LENGTH"><code class="docutils literal notranslate"><span class="pre">PSA_MAC_TRUNCATED_LENGTH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_CIPHER_MAC_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CIPHER_MAC_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_CBC_MAC"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CBC_MAC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_CMAC"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CMAC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_GMAC"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_GMAC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_IS_BLOCK_CIPHER_MAC"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_BLOCK_CIPHER_MAC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_CIPHER_STREAM_FLAG"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CIPHER_STREAM_FLAG</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_CIPHER_FROM_BLOCK_FLAG"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CIPHER_FROM_BLOCK_FLAG</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_IS_STREAM_CIPHER"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_STREAM_CIPHER</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_ARC4"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_ARC4</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_CHACHA20"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CHACHA20</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_CTR"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CTR</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_CFB"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CFB</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_OFB"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_OFB</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_XTS"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_XTS</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_CBC_NO_PADDING"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CBC_NO_PADDING</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_CBC_PKCS7"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CBC_PKCS7</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_AEAD_FROM_BLOCK_FLAG"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_AEAD_FROM_BLOCK_FLAG</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_IS_AEAD_ON_BLOCK_CIPHER"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_AEAD_ON_BLOCK_CIPHER</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_CCM"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CCM</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_GCM"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_GCM</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_CHACHA20_POLY1305"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CHACHA20_POLY1305</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_AEAD_TAG_LENGTH_MASK"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_AEAD_TAG_LENGTH_MASK</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_AEAD_TAG_LENGTH_OFFSET"><code class="docutils literal notranslate"><span class="pre">PSA_AEAD_TAG_LENGTH_OFFSET</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_AEAD_WITH_TAG_LENGTH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_AEAD_WITH_TAG_LENGTH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_AEAD_WITH_DEFAULT_TAG_LENGTH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_AEAD_WITH_DEFAULT_TAG_LENGTH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE"><code class="docutils literal notranslate"><span class="pre">PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_RSA_PKCS1V15_SIGN_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RSA_PKCS1V15_SIGN_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_RSA_PKCS1V15_SIGN"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RSA_PKCS1V15_SIGN</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_RSA_PKCS1V15_SIGN_RAW"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RSA_PKCS1V15_SIGN_RAW</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_IS_RSA_PKCS1V15_SIGN"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_RSA_PKCS1V15_SIGN</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_RSA_PSS_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RSA_PSS_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_RSA_PSS"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RSA_PSS</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_IS_RSA_PSS"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_RSA_PSS</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_ECDSA_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_ECDSA_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_ECDSA"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_ECDSA</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_ECDSA_ANY"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_ECDSA_ANY</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_DETERMINISTIC_ECDSA_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_DETERMINISTIC_ECDSA_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_DETERMINISTIC_ECDSA"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_DETERMINISTIC_ECDSA</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_IS_ECDSA"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_ECDSA</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_ECDSA_IS_DETERMINISTIC"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_ECDSA_IS_DETERMINISTIC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_IS_DETERMINISTIC_ECDSA"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_DETERMINISTIC_ECDSA</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_IS_RANDOMIZED_ECDSA"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_RANDOMIZED_ECDSA</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_IS_HASH_AND_SIGN"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_HASH_AND_SIGN</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_SIGN_GET_HASH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SIGN_GET_HASH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_RSA_PKCS1V15_CRYPT"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RSA_PKCS1V15_CRYPT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_RSA_OAEP_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RSA_OAEP_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_RSA_OAEP"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RSA_OAEP</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_IS_RSA_OAEP"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_RSA_OAEP</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_RSA_OAEP_GET_HASH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RSA_OAEP_GET_HASH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_HKDF_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_HKDF_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_HKDF"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_HKDF</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_IS_HKDF"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_HKDF</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_HKDF_GET_HASH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_HKDF_GET_HASH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_TLS12_PRF_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_TLS12_PRF_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_TLS12_PRF"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_TLS12_PRF</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_IS_TLS12_PRF"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_TLS12_PRF</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_TLS12_PRF_GET_HASH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_TLS12_PRF_GET_HASH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_TLS12_PSK_TO_MS_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_TLS12_PSK_TO_MS_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_TLS12_PSK_TO_MS"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_TLS12_PSK_TO_MS</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_IS_TLS12_PSK_TO_MS"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_TLS12_PSK_TO_MS</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_TLS12_PSK_TO_MS_GET_HASH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_TLS12_PSK_TO_MS_GET_HASH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_KEY_DERIVATION_MASK"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_KEY_DERIVATION_MASK</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_KEY_AGREEMENT_MASK"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_KEY_AGREEMENT_MASK</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_KEY_AGREEMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_KEY_AGREEMENT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_KEY_AGREEMENT_GET_KDF"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_KEY_AGREEMENT_GET_KDF</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_KEY_AGREEMENT_GET_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_KEY_AGREEMENT_GET_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_IS_RAW_KEY_AGREEMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_RAW_KEY_AGREEMENT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_IS_KEY_DERIVATION_OR_AGREEMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_KEY_DERIVATION_OR_AGREEMENT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_FFDH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_FFDH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_IS_FFDH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_FFDH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_ECDH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_ECDH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_IS_ECDH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_ECDH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_IS_WILDCARD"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_WILDCARD</span></code> (macro)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="#key-lifetimes">Key lifetimes</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="#psa_key_lifetime_t"><code class="docutils literal notranslate"><span class="pre">psa_key_lifetime_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#psa_key_id_t"><code class="docutils literal notranslate"><span class="pre">psa_key_id_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_LIFETIME_VOLATILE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_LIFETIME_VOLATILE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_LIFETIME_PERSISTENT"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_LIFETIME_PERSISTENT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_ID_USER_MIN"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_ID_USER_MIN</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_ID_USER_MAX"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_ID_USER_MAX</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_ID_VENDOR_MIN"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_ID_VENDOR_MIN</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_ID_VENDOR_MAX"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_ID_VENDOR_MAX</span></code> (macro)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="#key-policies">Key policies</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="#psa_key_usage_t"><code class="docutils literal notranslate"><span class="pre">psa_key_usage_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_USAGE_EXPORT"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_EXPORT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_USAGE_COPY"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_COPY</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_USAGE_ENCRYPT"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_ENCRYPT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_USAGE_DECRYPT"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_DECRYPT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_USAGE_SIGN"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_SIGN</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_USAGE_VERIFY"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_VERIFY</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_USAGE_DERIVE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_DERIVE</span></code> (macro)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="#key-derivation">Key derivation</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="#psa_key_derivation_step_t"><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_step_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_DERIVATION_INPUT_SECRET"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_SECRET</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_DERIVATION_INPUT_LABEL"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_LABEL</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_DERIVATION_INPUT_SALT"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_SALT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_DERIVATION_INPUT_INFO"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_INFO</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_DERIVATION_INPUT_SEED"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_SEED</span></code> (macro)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="#other-definitions">Other definitions</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_BITS_TO_BYTES"><code class="docutils literal notranslate"><span class="pre">PSA_BITS_TO_BYTES</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_BYTES_TO_BITS"><code class="docutils literal notranslate"><span class="pre">PSA_BYTES_TO_BITS</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ROUND_UP_TO_MULTIPLE"><code class="docutils literal notranslate"><span class="pre">PSA_ROUND_UP_TO_MULTIPLE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_HASH_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_HASH_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_HASH_MAX_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_HASH_MAX_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_HMAC_MAX_HASH_BLOCK_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_HMAC_MAX_HASH_BLOCK_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_MAC_MAX_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_MAC_MAX_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_AEAD_TAG_LENGTH"><code class="docutils literal notranslate"><span class="pre">PSA_AEAD_TAG_LENGTH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_VENDOR_RSA_MAX_KEY_BITS"><code class="docutils literal notranslate"><span class="pre">PSA_VENDOR_RSA_MAX_KEY_BITS</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_VENDOR_ECC_MAX_CURVE_BITS"><code class="docutils literal notranslate"><span class="pre">PSA_VENDOR_ECC_MAX_CURVE_BITS</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECC_CURVE_BITS"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_BITS</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ALG_TLS12_PSK_TO_MS_MAX_PSK_LEN"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_TLS12_PSK_TO_MS_MAX_PSK_LEN</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ASYMMETRIC_SIGNATURE_MAX_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_ASYMMETRIC_SIGNATURE_MAX_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_MAX_BLOCK_CIPHER_BLOCK_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_MAX_BLOCK_CIPHER_BLOCK_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_MAC_FINAL_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_MAC_FINAL_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_AEAD_ENCRYPT_OUTPUT_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_AEAD_ENCRYPT_OUTPUT_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_AEAD_DECRYPT_OUTPUT_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_AEAD_DECRYPT_OUTPUT_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_AEAD_UPDATE_OUTPUT_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_AEAD_UPDATE_OUTPUT_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_AEAD_FINISH_OUTPUT_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_AEAD_FINISH_OUTPUT_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_AEAD_VERIFY_OUTPUT_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_AEAD_VERIFY_OUTPUT_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_RSA_MINIMUM_PADDING_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_RSA_MINIMUM_PADDING_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ECDSA_SIGNATURE_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_ECDSA_SIGNATURE_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_EXPORT_RSA_PUBLIC_KEY_MAX_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_EXPORT_RSA_PUBLIC_KEY_MAX_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_EXPORT_RSA_KEY_PAIR_MAX_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_EXPORT_RSA_KEY_PAIR_MAX_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_EXPORT_DSA_PUBLIC_KEY_MAX_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_EXPORT_DSA_PUBLIC_KEY_MAX_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_EXPORT_DSA_KEY_PAIR_MAX_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_EXPORT_DSA_KEY_PAIR_MAX_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_EXPORT_ECC_KEY_PAIR_MAX_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_EXPORT_ECC_KEY_PAIR_MAX_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#PSA_KEY_EXPORT_MAX_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_EXPORT_MAX_SIZE</span></code> (macro)</a></li>
+</ul>
+</li>
+</ul>
+
+<div class="relations">
+<h3>Related Topics</h3>
+<ul>
+ <li><a href="index.html">Documentation overview</a><ul>
+ <li>Previous: <a href="general.html" title="previous chapter">Introduction</a></li>
+ </ul></li>
+</ul>
+</div>
+<div id="searchbox" style="display: none" role="search">
+ <h3>Quick search</h3>
+ <div class="searchformwrapper">
+ <form class="search" action="search.html" method="get">
+ <input type="text" name="q" />
+ <input type="submit" value="Go" />
+ <input type="hidden" name="check_keywords" value="yes" />
+ <input type="hidden" name="area" value="default" />
+ </form>
+ </div>
+</div>
+<script type="text/javascript">$('#searchbox').show(0);</script>
+
+
+
+
+
+
+
+
+ </div>
+ </div>
+ <div class="clearer"></div>
+ </div>
+ <div class="footer">
+ ©2019, Arm.
+
+ |
+ Powered by <a href="http://sphinx-doc.org/">Sphinx 1.8.5</a>
+ & <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
+
+ |
+ <a href="_sources/from_doxygen.rst.txt"
+ rel="nofollow">Page source</a>
+ </div>
+
+
+
+
+ </body>
+</html>
\ No newline at end of file
diff --git a/docs/html/functions.html b/docs/html/functions.html
deleted file mode 100644
index d4f8c35..0000000
--- a/docs/html/functions.html
+++ /dev/null
@@ -1,105 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: Class Members</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li><a href="modules.html"><span>Modules</span></a></li>
- <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
- <li><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
- <div id="navrow2" class="tabs2">
- <ul class="tablist">
- <li><a href="annotated.html"><span>Class List</span></a></li>
- <li><a href="classes.html"><span>Class Index</span></a></li>
- <li class="current"><a href="functions.html"><span>Class Members</span></a></li>
- </ul>
- </div>
- <div id="navrow3" class="tabs2">
- <ul class="tablist">
- <li class="current"><a href="functions.html"><span>All</span></a></li>
- <li><a href="functions_vars.html"><span>Variables</span></a></li>
- </ul>
- </div>
-</div><!-- top -->
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div class="contents">
-<div class="textblock">Here is a list of all documented class members with links to the class documentation for each member:</div><ul>
-<li>e
-: <a class="el" href="structpsa__generate__key__extra__rsa.html#a53ccb9e4375f3c9af6e3ecfe111ce11d">psa_generate_key_extra_rsa</a>
-</li>
-</ul>
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/functions_vars.html b/docs/html/functions_vars.html
deleted file mode 100644
index 8f82460..0000000
--- a/docs/html/functions_vars.html
+++ /dev/null
@@ -1,105 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: Class Members - Variables</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li><a href="modules.html"><span>Modules</span></a></li>
- <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
- <li><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
- <div id="navrow2" class="tabs2">
- <ul class="tablist">
- <li><a href="annotated.html"><span>Class List</span></a></li>
- <li><a href="classes.html"><span>Class Index</span></a></li>
- <li class="current"><a href="functions.html"><span>Class Members</span></a></li>
- </ul>
- </div>
- <div id="navrow3" class="tabs2">
- <ul class="tablist">
- <li><a href="functions.html"><span>All</span></a></li>
- <li class="current"><a href="functions_vars.html"><span>Variables</span></a></li>
- </ul>
- </div>
-</div><!-- top -->
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div class="contents">
- <ul>
-<li>e
-: <a class="el" href="structpsa__generate__key__extra__rsa.html#a53ccb9e4375f3c9af6e3ecfe111ce11d">psa_generate_key_extra_rsa</a>
-</li>
-</ul>
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/general.html b/docs/html/general.html
new file mode 100644
index 0000000..0a76f6d
--- /dev/null
+++ b/docs/html/general.html
@@ -0,0 +1,1456 @@
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+ <title>Introduction — psa_crypto_api 1.0 beta3 documentation</title>
+ <link rel="stylesheet" href="_static/alabaster.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+ <script type="text/javascript" id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
+ <script type="text/javascript" src="_static/jquery.js"></script>
+ <script type="text/javascript" src="_static/underscore.js"></script>
+ <script type="text/javascript" src="_static/doctools.js"></script>
+ <script type="text/javascript" src="_static/language_data.js"></script>
+ <link rel="index" title="Index" href="genindex.html" />
+ <link rel="search" title="Search" href="search.html" />
+ <link rel="next" title="Implementation-specific definitions" href="from_doxygen.html" />
+ <link rel="prev" title="PSA Cryptography API Specification" href="index.html" />
+
+ <link rel="stylesheet" href="_static/custom.css" type="text/css" />
+
+
+ <meta name="viewport" content="width=device-width, initial-scale=0.9, maximum-scale=0.9" />
+
+ </head><body>
+
+
+ <div class="document">
+ <div class="documentwrapper">
+ <div class="bodywrapper">
+
+
+ <div class="body" role="main">
+
+ <div class="section" id="introduction">
+<h1>Introduction</h1>
+<p>Arm’s Platform Security Architecture (PSA) is a holistic set of threat
+models, security analyses, hardware and firmware architecture
+specifications, and an open source firmware reference implementation.
+PSA provides a recipe, based on industry best practice, that allows
+security to be consistently designed in, at both a hardware and firmware
+level.</p>
+<p>The PSA Cryptographic API (Crypto API) described in this document is an
+important PSA component that provides an interface to modern
+cryptographic primitives on resource-constrained devices. The interface
+is user-friendly, while still providing access to the primitives used in
+modern cryptography. It does not require that the user have access to
+the key material. Instead, it uses opaque key handles.</p>
+<p>This document is part of the PSA family of specifications. It defines an
+interface for cryptographic services, including cryptography primitives
+and a key storage functionality.</p>
+<p>This document includes:</p>
+<ul class="simple">
+<li>A <a class="reference external" href="#design-goals">rationale</a> for the design.</li>
+<li>A <a class="reference external" href="#functionality-overview">high-level overview of the
+functionality</a> provided by the interface.</li>
+<li>A <a class="reference external" href="#sample-architectures">description of typical architectures</a> of
+implementations for this specification.</li>
+<li>General considerations <a class="reference external" href="#implementation-considerations">for
+implementers</a> of this
+specification and <a class="reference external" href="#usage-considerations">for applications</a> that
+use the interface defined in this specification.</li>
+<li>A detailed definition of the API.</li>
+</ul>
+<p>Companion documents will define <em>profiles</em> for this specification. A
+profile is a minimum mandatory subset of the interface that a compliant
+implementation must provide.</p>
+</div>
+<div class="section" id="design-goals">
+<h1>Design goals</h1>
+<div class="section" id="suitable-for-constrained-devices">
+<h2>Suitable for constrained devices</h2>
+<p>The interface is suitable for a vast range of devices: from
+special-purpose cryptographic processors that process data with a
+built-in key, to constrained devices running custom application code,
+such as microcontrollers, and multi-application devices, such as
+servers. Consequentially, the interface is scalable and modular.</p>
+<ul class="simple">
+<li><em>Scalable</em>: you shouldn’t pay for functionality that you don’t need.</li>
+<li><em>Modular</em>: larger devices implement larger subsets of the same
+interface, rather than different interfaces.</li>
+</ul>
+<p>Because this specification is suitable for very constrained devices,
+including those where memory is very limited, all operations on
+unbounded amounts of data allow <em>multipart</em> processing, as long as the
+calculations on the data are performed in a streaming manner. This means
+that the application does not need to store the whole message in memory
+at one time.</p>
+<p>Memory outside the keystore boundary is managed by the application. An
+implementation of the interface is not required to retain any state
+between function calls, apart from the content of the keystore and other
+data that must be kept inside the keystore security boundary.</p>
+<p>The interface does not expose the representation of keys and
+intermediate data, except when required for interchange. This allows
+each implementation to choose optimal data representations.
+Implementations with multiple components are also free to choose which
+memory area to use for internal data.</p>
+</div>
+<div class="section" id="a-keystore-interface">
+<h2>A keystore interface</h2>
+<p>The specification allows cryptographic operations to be performed on a
+key to which the application does not have direct access. Except where
+required for interchange, applications access all keys indirectly, by a
+handle. The key material corresponding to that handle can reside inside
+a security boundary that prevents it from being extracted, except as
+permitted by a policy that is defined when the key is created.</p>
+</div>
+<div class="section" id="optional-isolation">
+<h2>Optional isolation</h2>
+<p>Implementations can isolate the cryptoprocessor from the calling
+application, and can further isolate multiple calling applications. The
+interface allows the implementation to be separated between a frontend
+and a backend. In an isolated implementation, the frontend is the part
+of the implementation that is located in the same isolation boundary as
+the application, which the application accesses by function calls. The
+backend is the part of the implementation that is located in a different
+environment, which is protected from the frontend. Various technologies
+can provide protection, for example:</p>
+<ul class="simple">
+<li>Process isolation in an operating system.</li>
+<li>Partition isolation, either with a virtual machine or a partition
+manager.</li>
+<li>Physical separation between devices.</li>
+</ul>
+<p>Communication between the frontend and backend is beyond the scope of
+this specification.</p>
+<p>In an isolated implementation, the backend can serve more than one
+implementation instance. In this case, a single backend communicates
+with multiple instances of the frontend. The backend must enforce
+<strong>caller isolation</strong>: it must ensure that assets of one frontend are not
+visible to any other frontend. How callers are identified is beyond the
+scope of this specification. An implementation that provides caller
+isolation must document how callers are identified. An implementation
+that provides isolation must document any implementation-specific
+extension of the API that enables frontend instances to share data in
+any form.</p>
+<p>In summary, there are three types of implementations:</p>
+<ul class="simple">
+<li>No isolation: there is no security boundary between the application
+and the cryptoprocessor. For example, a statically or dynamically
+linked library is an implementation with no isolation.</li>
+<li>Cryptoprocessor isolation: there is a security boundary between the
+application and the cryptoprocessor, but the cryptoprocessor does not
+communicate with other applications. For example, a cryptoprocessor
+chip that is a companion to an application processor is an
+implementation with cryptoprocessor isolation.</li>
+<li>Caller isolation: there are multiple application instances, with a
+security boundary between the application instances among themselves,
+as well as between the cryptoprocessor and the application instances.
+For example, a cryptography service in a multiprocess environment is
+an implementation with caller and cryptoprocessor isolation.</li>
+</ul>
+</div>
+<div class="section" id="choice-of-algorithms">
+<h2>Choice of algorithms</h2>
+<p>The specification defines a low-level cryptographic interface, where the
+caller explicitly chooses which algorithm and which security parameters
+they use. This is necessary to implement protocols that are inescapable
+in various use cases. The design of the interface enables applications
+to implement widely-used protocols and data exchange formats, as well as
+custom ones.</p>
+<p>As a consequence, all cryptographic functionality operates according to
+the precise algorithm specified by the caller. However, this does not
+apply to device-internal functionality, which does not involve any form
+of interoperability, such as random number generation. The specification
+does not include generic higher-level interfaces, where the
+implementation chooses the best algorithm for a purpose. However,
+higher-level libraries can be built on top of the PSA Crypto API.</p>
+<p>Another consequence is that the specification permits the use of
+algorithms, key sizes and other parameters that, while known to be
+insecure, may be necessary to support legacy protocols or legacy data.
+Where major weaknesses are known, the algorithm description give
+applicable warnings. However, the lack of a warning does not and cannot
+indicate that an algorithm is secure in all circumstances. Application
+developers should research the security of the algorithms that they plan
+to use to determine if the algorithms meet their requirements.</p>
+<p>The interface facilitates algorithm agility. As a consequence,
+cryptographic primitives are presented through generic functions with a
+parameter indicating the specific choice of algorithm. For example,
+there is a single function to calculate a message digest, which takes a
+parameter that identifies the specific hash algorithm.</p>
+</div>
+<div class="section" id="ease-of-use">
+<h2>Ease of use</h2>
+<p>The interface is designed to be as user-friendly as possible, given the
+aforementioned constraints on suitability for various types of devices
+and on the freedom to choose algorithms.</p>
+<p>In particular, the code flows are designed to reduce the chance of
+dangerous misuse. The interface makes it harder to misuse than to use
+correctly, and typical mistakes result in test failures, rather than
+subtle security issues. Implementations avoid leaking data when a
+function is called with invalid parameters, to the extent allowed by the
+C language and by implementation size constraints.</p>
+</div>
+<div class="section" id="example-use-cases">
+<h2>Example use cases</h2>
+<p>This section lists some of the use cases that were considered while
+designing this API. This list is not exhaustive, nor are all
+implementations required to support all use cases.</p>
+<div class="section" id="network-security-tls">
+<h3>Network Security (TLS)</h3>
+<p>The API provides everything needed to establish TLS connections on the
+device side: asymmetric key management inside a key store, symmetric
+ciphers, MAC, HMAC, message digests, and AEAD.</p>
+</div>
+<div class="section" id="secure-storage">
+<h3>Secure Storage</h3>
+<p>The API provides all primitives related to storage encryption, block or
+file-based, with master encryption keys stored inside a key store.</p>
+</div>
+<div class="section" id="network-credentials">
+<h3>Network Credentials</h3>
+<p>The API provides network credential management inside a key store, for
+example, for X.509-based authentication or pre-shared keys on enterprise
+networks.</p>
+</div>
+<div class="section" id="device-pairing">
+<h3>Device Pairing</h3>
+<p>The API provides support for key agreement protocols that are often used
+for secure pairing of devices over wireless channels. For example, the
+pairing of an NFC token or a Bluetooth device could make use of key
+agreement protocols upon first use.</p>
+</div>
+<div class="section" id="secure-boot">
+<h3>Secure Boot</h3>
+<p>The API provides primitives for use during firmware integrity and
+authenticity validation, during a secure or trusted boot process.</p>
+</div>
+<div class="section" id="attestation">
+<h3>Attestation</h3>
+<p>The API provides primitives used in attestation activities. Attestation
+is the ability for a device to sign an array of bytes with a device
+private key and return the result to the caller. There are several use
+cases: from attestation of the device state to the ability to generate a
+key pair and prove that it has been generated inside a secure key store.
+The API provides access to the algorithms commonly used for attestation.</p>
+</div>
+<div class="section" id="factory-provisioning">
+<h3>Factory Provisioning</h3>
+<p>Most IoT devices receive a unique identity during the factory
+provisioning process, or once deployed to the field. This API provides
+the APIs necessary for populating a device with keys that represent that
+identity.</p>
+</div>
+</div>
+</div>
+<div class="section" id="functionality-overview">
+<h1>Functionality overview</h1>
+<p>This section provides a high-level overview of the functionality
+provided by the interface defined in this specification. Refer to the
+API definition for a detailed description.</p>
+<p>Due to the modularity of the interface, almost every part of the library
+is optional. The only mandatory function is <code class="docutils literal notranslate"><span class="pre">psa_crypto_init</span></code>.</p>
+<div class="section" id="library-management">
+<h2>Library management</h2>
+<p>Before any use, applications must call <code class="docutils literal notranslate"><span class="pre">psa_crypto_init</span></code> to initialize
+the library.</p>
+</div>
+<div class="section" id="key-management">
+<h2>Key management</h2>
+<p>Applications always access keys via a handle. This allows keys to be
+non-extractable, that is, an application can perform operations using a
+key without having access to the key material. Non-extractable keys are
+bound to the device, can be rate-limited and can have their usage
+restricted by policies.</p>
+<p>Each key has a set of attributes that describe the key and the policy
+for using the key. A <code class="docutils literal notranslate"><span class="pre">psa_key_attributes_t</span></code> object contains all of the
+attributes, which is used when creating a key and when querying key
+attibutes.</p>
+<p>Each key has a <em>lifetime</em> that determines when the key material is
+destroyed. There are two types of lifetimes:
+<a class="reference external" href="#volatile-keys">volatile</a> and <a class="reference external" href="#persistent-keys">persistent</a>.</p>
+<div class="section" id="volatile-keys">
+<h3>Volatile keys</h3>
+<p>A <em>volatile</em> key is destroyed as soon as the application closes the
+handle to the key. When the application terminates, it conceptually
+closes all of its key handles. Conceptually, a volatile key is stored in
+RAM. Volatile keys have the lifetime <code class="docutils literal notranslate"><span class="pre">PSA_KEY_LIFETIME_VOLATILE</span></code>.</p>
+<p>To create a volatile key:</p>
+<ol class="arabic simple">
+<li>Populate a <code class="docutils literal notranslate"><span class="pre">psa_key_attributes_t</span></code> object with the key’s type, size,
+policy and other attributes.</li>
+<li>Create the key with <code class="docutils literal notranslate"><span class="pre">psa_import_key</span></code>, <code class="docutils literal notranslate"><span class="pre">psa_generate_key</span></code>,
+<code class="docutils literal notranslate"><span class="pre">psa_key_derivation_output_key</span></code> or <code class="docutils literal notranslate"><span class="pre">psa_copy_key</span></code>.</li>
+</ol>
+<p>To destroy a volatile key, call <code class="docutils literal notranslate"><span class="pre">psa_close_key</span></code> or <code class="docutils literal notranslate"><span class="pre">psa_destroy_key</span></code>
+(these functions are equivalent when called on a volatile key).</p>
+</div>
+<div class="section" id="persistent-keys">
+<h3>Persistent keys</h3>
+<p>A <em>persistent</em> key exists until it explicitly destroyed with
+<code class="docutils literal notranslate"><span class="pre">psa_destroy_key</span></code> or until it is wiped by the reset or destruction of
+the device.</p>
+<p>Each persistent key has a key identifier, which acts as a name for the
+key. Within an application, the key identifier corresponds to a single
+key. The application specifies the key identifier when the key is
+created, and uses the key identifier to obtain a handle to a persistent
+key that has already been created. If the implementation provides
+<a class="reference external" href="#optional-isolation">caller isolation</a>, then key identifiers are
+local to each application: the same key identifier in two applications
+corresponds to different keys.</p>
+<p>Persistent keys may be stored in different storage areas; this is
+indicated through different lifetime values. This specification defines
+a single lifetime value <code class="docutils literal notranslate"><span class="pre">PSA_KEY_LIFETIME_PERSISTENT</span></code> which
+corresponds to a default storage area. Implementations may define
+alternative lifetime values corresponding to different storage areas
+with different retention policies, or to secure elements with different
+security characteristics.</p>
+<p>To create a persistent key:</p>
+<ol class="arabic simple">
+<li>Populate a <code class="docutils literal notranslate"><span class="pre">psa_key_attributes_t</span></code> object with the key’s type, size,
+policy and other attributes.</li>
+<li>In the attributes object, set the desired lifetime and persistent
+identifier for the key.</li>
+<li>Create the key with <code class="docutils literal notranslate"><span class="pre">psa_import_key</span></code>, <code class="docutils literal notranslate"><span class="pre">psa_generate_key</span></code>,
+<code class="docutils literal notranslate"><span class="pre">psa_key_derivation_output_key</span></code> or <code class="docutils literal notranslate"><span class="pre">psa_copy_key</span></code>.</li>
+</ol>
+<p>To release memory resources associated with a key but keep the key in
+storage, call <code class="docutils literal notranslate"><span class="pre">psa_close_key</span></code>. To access an existing persistent key,
+call <code class="docutils literal notranslate"><span class="pre">psa_open_key</span></code> with the same key identifier used when creating
+the key.</p>
+<p>To destroy a persistent key, open it (if it isn’t already open) and call
+<code class="docutils literal notranslate"><span class="pre">psa_destroy_key</span></code>.</p>
+<p>The key lifetime and identifier are set when the key is created and
+cannot be changed without destroying the key first. If the original key
+permits copying, then the application can specify a different lifetime
+for the copy of the key.</p>
+</div>
+<div class="section" id="recommendations-of-minimum-standards-for-key-management">
+<h3>Recommendations of minimum standards for key management</h3>
+<p>Most implementations provide the function <code class="docutils literal notranslate"><span class="pre">psa_import_key</span></code>. The only
+exceptions are implementations that only give access to a key or keys
+that are provisioned by proprietary means, and do not allow the main
+application to use its own cryptographic material.</p>
+<p>Most implementations provide <code class="docutils literal notranslate"><span class="pre">psa_get_key_attributes</span></code> and the
+<code class="docutils literal notranslate"><span class="pre">psa_get_key_xxx</span></code> accessor functions, as they are easy to implement,
+and it is difficult to write applications and to diagnose issues without
+being able to check the metadata.</p>
+<p>Most implementations also provide <code class="docutils literal notranslate"><span class="pre">psa_export_public_key</span></code> if they
+support any asymmetric algorithm, since public-key cryptography often
+requires the delivery of a public key that is associated with a
+protected private key.</p>
+<p>Most implementations provide <code class="docutils literal notranslate"><span class="pre">psa_export_key</span></code>. However, highly
+constrained implementations that are designed to work only with
+short-term keys (no non-volatile storage), or only with long-term
+non-extractable keys, may omit this function.</p>
+</div>
+</div>
+<div class="section" id="usage-policies">
+<h2>Usage policies</h2>
+<p>All keys have an associated policy that regulates which operations are
+permitted on the key. Each key policy is a set of usage flags and a
+specific algorithm that is permitted with the key. The policy is part of
+the key attributes that are managed by a <code class="docutils literal notranslate"><span class="pre">psa_key_attributes_t</span></code>
+object.</p>
+<p>The usage flags are encoded in a bitmask, which has the type
+<code class="docutils literal notranslate"><span class="pre">psa_key_usage_t</span></code>. Three kinds of usage flag can be specified: * The
+extractable flag <code class="docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_EXPORT</span></code> determines whether the key
+material can be extracted. * The copyable flag <code class="docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_COPY</span></code>
+determines whether the key material can be copied into a new key, which
+can have a different lifetime or a more restrictive policy. * The usage
+flags <code class="docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_ENCRYPT</span></code>, <code class="docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_SIGN</span></code>, and so on
+determine whether the corresponding operation is permitted on the key.</p>
+<p>In addition to the usage bitmask, a policy specifies which algorithm is
+permitted with the key. This specification only defines policies that
+restrict keys to a single algorithm, which is in keeping with common
+practice and with security good practice.</p>
+<p>A highly constrained implementation may not be able to support all the
+policies that can be expressed through this interface. If an
+implementation cannot create a key with the required policy, it must
+return an appropriate error code when the key is created.</p>
+</div>
+<div class="section" id="symmetric-cryptography">
+<h2>Symmetric cryptography</h2>
+<p>This specification defines interfaces for message digests (hash
+functions), MAC (message authentication codes), symmetric ciphers and
+authenticated encryption with associated data (AEAD). For each type of
+primitive, the API includes two standalone functions (compute and
+verify, or encrypt and decrypt) as well as a series of functions that
+permit <a class="reference external" href="#multipart-operations">multipart operations</a>.</p>
+<p>The standalone functions are:</p>
+<ul class="simple">
+<li><code class="docutils literal notranslate"><span class="pre">psa_hash_compute</span></code> and <code class="docutils literal notranslate"><span class="pre">psa_hash_compare</span></code> to calculate the hash
+of a message or compare the hash of a message with a reference value.</li>
+<li><code class="docutils literal notranslate"><span class="pre">psa_mac_compute</span></code> and <code class="docutils literal notranslate"><span class="pre">psa_mac_verify</span></code> to calculate the MAC of a
+message of compare the MAC with a reference value.</li>
+<li><code class="docutils literal notranslate"><span class="pre">psa_cipher_encrypt</span></code> and <code class="docutils literal notranslate"><span class="pre">psa_cipher_decrypt</span></code> to encrypt or
+decrypt a message using an unauthenticated symmetric cipher. The
+encryption function generates a random IV; to use a deterministic IV
+(which is not secure in general, but can be secure in some conditions
+that depend on the algorithm), use the multipart API.</li>
+<li><code class="docutils literal notranslate"><span class="pre">psa_aead_encrypt</span></code> and <code class="docutils literal notranslate"><span class="pre">psa_aead_decrypt</span></code> to encrypt/decrypt and
+authenticate a message using an AEAD algorithm. These functions
+follow the interface recommended by RFC 5116.</li>
+</ul>
+<div class="section" id="multipart-operations">
+<h3>Multipart operations</h3>
+<p>The API provides a multipart interface to hash, MAC, symmetric cipher
+and AEAD primitives. These interfaces process messages one chunk at a
+time, with the size of chunks determined by the caller. This allows the
+processing of messages that cannot be assembled in memory. To perform a
+multipart operation:</p>
+<ol class="arabic simple">
+<li>Allocate an operation object of the appropriate type. You can use any
+allocation strategy: stack, heap, static, etc.</li>
+<li>Initialize the operation object by one of the following methods:<ul>
+<li>Set it to all-bits-zero.</li>
+<li>Initialize it to logical zero.</li>
+<li>Assign the value of the associated macro <code class="docutils literal notranslate"><span class="pre">PSA_xxx_INIT</span></code>.</li>
+<li>Assign the result of calling the associated function
+<code class="docutils literal notranslate"><span class="pre">psa_xxx_init</span></code>.</li>
+</ul>
+</li>
+<li>Specify a key for the operation using the associated setup function:
+<code class="docutils literal notranslate"><span class="pre">psa_hash_setup</span></code>, <code class="docutils literal notranslate"><span class="pre">psa_mac_sign_setup</span></code>, <code class="docutils literal notranslate"><span class="pre">psa_mac_verify_setup</span></code>,
+<code class="docutils literal notranslate"><span class="pre">psa_cipher_encrypt_setup</span></code>, <code class="docutils literal notranslate"><span class="pre">psa_cipher_decrypt_setup</span></code>,
+<code class="docutils literal notranslate"><span class="pre">psa_aead_encrypt_setup</span></code> or <code class="docutils literal notranslate"><span class="pre">psa_aead_decrypt_setup</span></code>.</li>
+<li>Provide additional parameters:<ul>
+<li>When encrypting data, generate or set an initialization vector
+(IV), nonce, or similar initial value such as an initial counter
+value.</li>
+<li>When decrypting, set the IV or nonce.</li>
+<li>For a symmetric cipher, to generate a random IV, which is
+recommended in most protocols, call <code class="docutils literal notranslate"><span class="pre">psa_cipher_generate_iv</span></code>. To
+set the IV, call <code class="docutils literal notranslate"><span class="pre">psa_cipher_set_iv</span></code>.</li>
+<li>For AEAD, call <code class="docutils literal notranslate"><span class="pre">psa_aead_generate_nonce</span></code> or
+<code class="docutils literal notranslate"><span class="pre">psa_aead_set_nonce</span></code>.</li>
+</ul>
+</li>
+<li>Call the associated update function on successive chunks of the
+message: <code class="docutils literal notranslate"><span class="pre">psa_hash_update</span></code>, <code class="docutils literal notranslate"><span class="pre">psa_mac_update</span></code>,
+<code class="docutils literal notranslate"><span class="pre">psa_cipher_update</span></code>, <code class="docutils literal notranslate"><span class="pre">psa_aead_update_ad</span></code> or <code class="docutils literal notranslate"><span class="pre">psa_aead_update</span></code>.</li>
+<li>At the end of the message, call the applicable finishing function.
+There are three kinds of finishing function, depending on what to do
+with the verification tag.<ul>
+<li>Unauthenticated encryption and decryption does not involve a
+verification tag. Call <code class="docutils literal notranslate"><span class="pre">psa_cipher_finish</span></code>.</li>
+<li>To calculate the digest or MAC or authentication tag of a message,
+call the associated function to calculate and output the
+verification tag: <code class="docutils literal notranslate"><span class="pre">psa_hash_finish</span></code>, <code class="docutils literal notranslate"><span class="pre">psa_mac_sign_finish</span></code> or
+<code class="docutils literal notranslate"><span class="pre">psa_aead_finish</span></code>.</li>
+<li>To verify the digest or MAC of a message against a reference value
+or to verify the authentication tag at the end of AEAD decryption,
+call the associated function to compare the verification tag with
+the reference value: <code class="docutils literal notranslate"><span class="pre">psa_hash_verify</span></code>,
+<code class="docutils literal notranslate"><span class="pre">psa_mac_verify_finish</span></code> or <code class="docutils literal notranslate"><span class="pre">psa_aead_verify</span></code>.</li>
+</ul>
+</li>
+</ol>
+<p>Calling the setup function allocates resources inside the
+implementation. These resources are freed when calling the associated
+finishing function. In addition, each family of functions defines a
+function <code class="docutils literal notranslate"><span class="pre">psa_xxx_abort</span></code>, which can be called at any time to free the
+resources associated with an operation.</p>
+</div>
+<div class="section" id="authenticated-encryption">
+<h3>Authenticated encryption</h3>
+<p>Having a multipart interface to authenticated encryption raises specific
+issues.</p>
+<p>Multipart authenticated decryption produces partial results that are not
+authenticated. Applications must not use or expose partial results of
+authenticated decryption until <code class="docutils literal notranslate"><span class="pre">psa_aead_verify</span></code> has returned a
+success status, and must destroy all partial results without revealing
+them if <code class="docutils literal notranslate"><span class="pre">psa_aead_verify</span></code> returns a failure status. Revealing partial
+results (directly, or indirectly through the application’s behavior) can
+compromise the confidentiality of all inputs that are encrypted with the
+same key.</p>
+<p>For encryption, some common algorithms cannot be processed in a
+streaming fashion. For SIV mode, the whole plaintext must be known
+before the encryption can start; the multipart AEAD API is not meant to
+be usable with SIV mode. For CCM mode, the length of the plaintext must
+be known before the encryption can start; the application can call the
+function <code class="docutils literal notranslate"><span class="pre">psa_aead_set_lengths</span></code> to provide these lengths before
+providing input.</p>
+</div>
+</div>
+<div class="section" id="key-derivation">
+<h2>Key derivation</h2>
+<p>The specification defines a mechanism for key derivation that allows the
+output of the derivation to be split into multiple keys, as well as
+non-key outputs.</p>
+<p>In an implementation with <a class="reference external" href="#optional-isolation">isolation</a>, the
+intermediate state of the key derivation is not visible to the caller,
+and if an output of the derivation is a non-exportable key, then this
+output cannot be recovered outside the isolation boundary.</p>
+<div class="section" id="key-derivation-operations">
+<h3>Key derivation operations</h3>
+<p>A key derivation operation encodes a deterministic method to generate a
+finite stream of bytes. This data stream is computed by the
+cryptoprocessor and extracted in chunks. If two key derivation
+operations are constructed with the same parameters, then they should
+produce the same outputs.</p>
+<p>Some example uses of key derivation operations are:</p>
+<ul class="simple">
+<li>A key derivation function: initialized with a secret, a salt and
+other parameters.</li>
+<li>A key agreement function: initialized with a public key (peer key), a
+key pair (own key) and other parameters.</li>
+</ul>
+<p>Applications use the <code class="docutils literal notranslate"><span class="pre">psa_key_derivation_operation_t</span></code> type to create
+key derivation operations.</p>
+<p>The lifecycle of a key derivation operation is as follows:</p>
+<ol class="arabic simple">
+<li>Setup: construct a <code class="docutils literal notranslate"><span class="pre">psa_key_derivation_operation_t</span></code> object, and set
+its parameters and inputs. The setup phase determines the key
+derivation operation’s capacity, which is the maximum number of bytes
+that can be output from this key derivation operation.</li>
+<li>Output: read bytes from the stream defined by the key derivation
+operation. This can be done any number of times, until the stream is
+exhausted when its capacity has been reached. Each output step can
+either be used to populate a key object
+(<code class="docutils literal notranslate"><span class="pre">psa_key_derivation_output_key</span></code>), or to read some bytes and
+extract them as cleartext (<code class="docutils literal notranslate"><span class="pre">psa_key_derivation_output_bytes</span></code>).</li>
+<li>Terminate: clear the key derivation operation and release associated
+resources (<code class="docutils literal notranslate"><span class="pre">psa_key_derivation_abort</span></code>).</li>
+</ol>
+<p>A key derivation operation cannot be rewound. Once a part of the stream
+has been output, it cannot be output again. This ensures that the same
+part of the output will not be used for different purposes.</p>
+</div>
+<div class="section" id="key-derivation-function">
+<h3>Key derivation function</h3>
+<p>This specification defines functions to set up a key derivation. A key
+derivation consists of two parts:</p>
+<ol class="arabic simple">
+<li>Input collection. This is sometimes known as <em>extraction</em>: the
+operation “extracts” information from the inputs to generate a
+pseudorandom intermediate secret value.</li>
+<li>Output generation. This is sometimes known as <em>expansion</em>: the
+operation “expands” the intermediate secret value to the desired
+output length.</li>
+</ol>
+<p>To perform a key derivation:</p>
+<ol class="arabic simple">
+<li>Initialize a <code class="docutils literal notranslate"><span class="pre">psa_key_derivation_operation_t</span></code> object to zero or to
+<code class="docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_OPERAITON_INIT</span></code>.</li>
+<li>Call <code class="docutils literal notranslate"><span class="pre">psa_key_derivation_setup</span></code> to select a key derivation
+algorithm.</li>
+<li>Call the functions <code class="docutils literal notranslate"><span class="pre">psa_key_derivation_input_bytes</span></code> and
+<code class="docutils literal notranslate"><span class="pre">psa_key_derivation_input_key</span></code>, or
+<code class="docutils literal notranslate"><span class="pre">psa_key_derivation_key_agreement</span></code> to provide the inputs to the key
+derivation algorithm. Many key derivation algorithms take multiple
+inputs; the “step” parameter to these functions indicates which input
+is being passed. The documentation for each key derivation algorithm
+describes the expected inputs for that algorithm.</li>
+<li>Call <code class="docutils literal notranslate"><span class="pre">psa_key_derivation_output_key</span></code> to create a derived key, or
+<code class="docutils literal notranslate"><span class="pre">psa_key_derivation_output_bytes</span></code> to export the derived data. These
+functions may be called multiple times to read successive output from
+the key derivation.</li>
+<li>Call <code class="docutils literal notranslate"><span class="pre">psa_key_derivation_abort</span></code> to release the key derivation
+operation memory.</li>
+</ol>
+<p>Here is an example of a use case where a master key is used to generate
+both a message encryption key and an IV for the encryption, and the
+derived key and IV are then used to encrypt a message.</p>
+<ol class="arabic simple">
+<li>Derive the message encryption material from the master key.<ol class="arabic">
+<li>Initialize a <code class="docutils literal notranslate"><span class="pre">psa_key_derivation_operation_t</span></code> object to zero or
+to <code class="docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_OPERATION_INIT</span></code>.</li>
+<li>Call <code class="docutils literal notranslate"><span class="pre">psa_key_derivation_setup</span></code> with <code class="docutils literal notranslate"><span class="pre">PSA_ALG_HKDF</span></code> as the
+algorithm.</li>
+<li>Call <code class="docutils literal notranslate"><span class="pre">psa_key_derivation_input_key</span></code> with the step
+<code class="docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_SECRET</span></code> and the master key.</li>
+<li>Call <code class="docutils literal notranslate"><span class="pre">psa_key_derivation_input_bytes</span></code> with the step
+<code class="docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_INFO</span></code> and a public value that uniquely
+identifies the message.</li>
+<li>Populate a <code class="docutils literal notranslate"><span class="pre">psa_key_attributes_t</span></code> object with the derived
+message encryption key’s attributes.</li>
+<li>Call <code class="docutils literal notranslate"><span class="pre">psa_key_derivation_output_key</span></code> to create the derived
+message key.</li>
+<li>Call <code class="docutils literal notranslate"><span class="pre">psa_key_derivation_output_bytes</span></code> to generate the derived
+IV.</li>
+<li>Call <code class="docutils literal notranslate"><span class="pre">psa_key_derivation_abort</span></code> to release the key derivation
+operation memory.</li>
+</ol>
+</li>
+<li>Encrypt the message with the derived material.<ol class="arabic">
+<li>Initialize a <code class="docutils literal notranslate"><span class="pre">psa_cipher_operation_t</span></code> object to zero or to
+<code class="docutils literal notranslate"><span class="pre">PSA_CIPHER_OPERATION_INIT</span></code>.</li>
+<li>Call <code class="docutils literal notranslate"><span class="pre">psa_cipher_encrypt_setup</span></code> with the derived message
+encryption key.</li>
+<li>Call <code class="docutils literal notranslate"><span class="pre">psa_cipher_set_iv</span></code> using the derived IV retrieved above.</li>
+<li>Call <code class="docutils literal notranslate"><span class="pre">psa_cipher_update</span></code> one or more times to encrypt the
+message.</li>
+<li>Call <code class="docutils literal notranslate"><span class="pre">psa_cipher_finish</span></code> at the end of the message.</li>
+</ol>
+</li>
+<li>Call <code class="docutils literal notranslate"><span class="pre">psa_destroy_key</span></code> to clear the generated key.</li>
+</ol>
+</div>
+</div>
+<div class="section" id="asymmetric-cryptography">
+<h2>Asymmetric cryptography</h2>
+<p>The asymmetric cryptography part of this interface defines functions for
+asymmetric encryption, asymmetric signature and two-way key agreement.</p>
+<div class="section" id="asymmetric-encryption">
+<h3>Asymmetric encryption</h3>
+<p>Asymmetric encryption is provided through the functions
+<code class="docutils literal notranslate"><span class="pre">psa_asymmetric_encrypt</span></code> and <code class="docutils literal notranslate"><span class="pre">psa_asymmetric_decrypt</span></code>.</p>
+</div>
+<div class="section" id="hash-and-sign">
+<h3>Hash-and-sign</h3>
+<p>The signature and verification functions <code class="docutils literal notranslate"><span class="pre">psa_asymmetric_sign</span></code> and
+<code class="docutils literal notranslate"><span class="pre">psa_asymmetric_verify</span></code> take a hash as one of their inputs. This hash
+should be calculated with <code class="docutils literal notranslate"><span class="pre">psa_hash_setup</span></code>, <code class="docutils literal notranslate"><span class="pre">psa_hash_update</span></code> and
+<code class="docutils literal notranslate"><span class="pre">psa_hash_finish</span></code> before calling <code class="docutils literal notranslate"><span class="pre">psa_asymmetric_sign</span></code> or
+<code class="docutils literal notranslate"><span class="pre">psa_asymmetric_verify</span></code>. To determine which hash algorithm to use,
+call the macro <code class="docutils literal notranslate"><span class="pre">PSA_ALG_SIGN_GET_HASH</span></code> on the corresponding signature
+algorithm.</p>
+</div>
+<div class="section" id="key-agreement">
+<h3>Key agreement</h3>
+<p>This specification defines two functions for a Diffie-Hellman-style key
+agreement where each party combines its own private key with the peer’s
+public key.</p>
+<p>The recommended approach is to use a <a class="reference external" href="#key-derivation">key derivation
+operation</a> with the
+<code class="docutils literal notranslate"><span class="pre">psa_key_derivation_key_agreement</span></code> input function, which calculates a
+shared secret for the key derivation function.</p>
+<p>In case an application needs direct access to the shared secret, it can
+call <code class="docutils literal notranslate"><span class="pre">psa_raw_key_agreement</span></code> instead. Note that in general the shared
+secret is not directly suitable for use as a key because it is biased.</p>
+</div>
+</div>
+<div class="section" id="randomness-and-key-generation">
+<h2>Randomness and key generation</h2>
+<p>We strongly recommended that implementations include a random generator,
+consisting of a cryptographically secure pseudo-random generator
+(CSPRNG), which is adequately seeded with a cryptographic-quality
+hardware entropy source, commonly referred to as a true random number
+generator (TRNG). Constrained implementations may omit the random
+generation functionality if they do not implement any algorithm that
+requires randomness internally, and they do not provide a key generation
+functionality. For example, a special-purpose component for signature
+verification can omit this.</p>
+<p>Applications should use <code class="docutils literal notranslate"><span class="pre">psa_generate_key</span></code>,
+<code class="docutils literal notranslate"><span class="pre">psa_encrypt_generate_iv</span></code> or <code class="docutils literal notranslate"><span class="pre">psa_aead_generate_iv</span></code> to generate
+suitably-formatted random data, as applicable. In addition, the API
+includes a function <code class="docutils literal notranslate"><span class="pre">psa_generate_random</span></code> to generate and extract
+arbitrary random data.</p>
+</div>
+<div class="section" id="future-additions">
+<h2>Future additions</h2>
+<p>We plan to cover the following features in future drafts and editions of
+this specification:</p>
+<ul class="simple">
+<li>Single-shot functions for symmetric operations.</li>
+<li>Multi-part operations for hybrid cryptography. For example, this
+includes hash-and-sign for EdDSA, and hybrid encryption for ECIES.</li>
+<li>Key exchange and a more general interface to key derivation. This
+would enable an application to derive a non-extractable session key
+from non-extractable secrets, without leaking the intermediate
+material.</li>
+<li>Key wrapping mechanisms to extract and import keys in a protected
+form (encrypted and authenticated).</li>
+<li>Key discovery mechanisms. This would enable an application to locate
+a key by its name or attributes.</li>
+<li>Implementation capability description. This would enable an
+application to determine the algorithms, key types and storage
+lifetimes that the implementation provides.</li>
+<li>An ownership and access control mechanism allowing a multi-client
+implementation to have privileged clients that are able to manage
+keys of other clients.</li>
+</ul>
+</div>
+</div>
+<div class="section" id="sample-architectures">
+<h1>Sample architectures</h1>
+<p>This section describes some example architectures that can be used for
+implementations of the interface described in this specification. This
+list is not exhaustive and the section is entirely non-normative.</p>
+<div class="section" id="single-partition-architecture">
+<h2>Single-partition architecture</h2>
+<p>In this architecture, there is no security boundary inside the system.
+The application code may access all the system memory, including the
+memory used by the cryptographic services described in this
+specification. Thus, the architecture provides <a class="reference external" href="#optional-isolation">no
+isolation</a>.</p>
+<p>This architecture does not conform to the Arm <em>Platform Security
+Architecture Security Model</em>. However, it may be useful for providing
+cryptographic services that use the same interface, even on devices that
+cannot support any security boundary. So, while this architecture is not
+the primary design goal of the API defined in the present specification,
+it is supported.</p>
+<p>The functions in this specification simply execute the underlying
+algorithmic code. Security checks can be kept to a minimum, since the
+cryptoprocessor cannot defend against a malicious application. Key
+import and export copy data inside the same memory space.</p>
+<p>This architecture also describes a subset of some larger systems, where
+the cryptographic services are implemented inside a high-security
+partition, separate from the code of the main application, though it
+shares this high-security partition with other platform security
+services.</p>
+</div>
+<div class="section" id="cryptographic-token-and-single-application-processor">
+<h2>Cryptographic token and single-application processor</h2>
+<p>This system is composed of two partitions: one is a cryptoprocessor and
+the other partition runs an application. There is a security boundary
+between the two partitions, so that the application cannot access the
+cryptoprocessor, except through its public interface. Thus, the
+architecture provides <a class="reference external" href="#optional-isolation">cryptoprocessor
+isolation</a>. The cryptoprocessor has some
+nonvolatile storage, a TRNG, and possibly, some cryptographic
+accelerators.</p>
+<p>There are a number of potential physical realizations: the
+cryptoprocessor may be a separate chip, a separate processor on the same
+chip, or a logical partition using a combination of hardware and
+software to provide the isolation. These realizations are functionally
+equivalent in terms of the offered software interface, but they would
+typically offer different levels of security guarantees.</p>
+<p>The PSA crypto API in the application processor consists of a thin layer
+of code that translates function calls to remote procedure calls in the
+cryptoprocessor. All cryptographic computations are, therefore,
+performed inside the cryptoprocessor. Non-volatile keys are stored
+inside the cryptoprocessor.</p>
+</div>
+<div class="section" id="cryptoprocessor-with-no-key-storage">
+<h2>Cryptoprocessor with no key storage</h2>
+<p>As in the <a class="reference external" href="#cryptographic-token-and-single-application-processor">previous
+example</a>, this
+system is also composed of two partitions separated by a security
+boundary. Thus, this architecture also provides <a class="reference external" href="#optional-isolation">cryptoprocessor
+isolation</a>. However, unlike the previous
+architecture, in this system, the cryptoprocessor does not have any
+secure, persistent storage that could be used to store application keys.</p>
+<p>If the cryptoprocessor is not capable of storing cryptographic material,
+then there is little use for a separate cryptoprocessor, since all data
+would have to be imported by the application.</p>
+<p>The cryptoprocessor can provide useful services if it is able to store
+at least one key. This may be a hardware unique key that is burnt to
+one-time programmable memory during the manufacturing of the device.
+This key can be used for one or more purposes:</p>
+<ul class="simple">
+<li>Encrypt and authenticate data stored in the application processor.</li>
+<li>Communicate with a paired device.</li>
+<li>Allow the application to perform operations with keys that are
+derived from the hardware unique key.</li>
+</ul>
+</div>
+<div class="section" id="multi-client-cryptoprocessor">
+<h2>Multi-client cryptoprocessor</h2>
+<p>This is an expanded variant of the <a class="reference external" href="#cryptographic-token-and-single-application-processor">cryptographic token plus application
+architecture</a>.
+In this variant, the cryptoprocessor serves multiple applications that
+are mutually untrustworthy. This architecture provides <a class="reference external" href="#optional-isolation">caller
+isolation</a>.</p>
+<p>In this architecture, API calls are translated to remote procedure
+calls, which encode the identity of the client application. The
+cryptoprocessor carefully segments its internal storage to ensure that a
+client’s data is never leaked to another client.</p>
+</div>
+<div class="section" id="multi-cryptoprocessor-architecture">
+<h2>Multi-cryptoprocessor architecture</h2>
+<p>This system includes multiple cryptoprocessors. There are several
+reasons to have multiple cryptoprocessors:</p>
+<ul class="simple">
+<li>Different compromises between security and performance for different
+keys. Typically, this means a cryptoprocessor that runs on the same
+hardware as the main application and processes short-term secrets, a
+secure element or a similar separate chip that retains long-term
+secrets.</li>
+<li>Independent provisioning of certain secrets.</li>
+<li>A combination of a non-removable cryptoprocessor and removable ones,
+for example, a smartcard or HSM.</li>
+<li>Cryptoprocessors managed by different stakeholders who do not trust
+each other.</li>
+</ul>
+<p>The keystore implementation needs to dispatch each request to the
+correct processor. For example: * All requests involving a
+non-extractable key must be processed in the cryptoprocessor that holds
+that key. * Requests involving a persistent key must be processed in
+the cryptoprocessor that corresponds to the key’s lifetime value. *
+Requests involving a volatile key may target a cryptoprocessor based on
+parameters supplied by the application, or based on considerations such
+as performance inside the implementation.</p>
+</div>
+</div>
+<div class="section" id="library-conventions">
+<h1>Library conventions</h1>
+<div class="section" id="error-handling">
+<h2>Error handling</h2>
+<div class="section" id="return-status">
+<h3>Return status</h3>
+<p>Almost all functions return a status indication of type
+<code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code>. This is an enumeration of integer values, with 0
+(<code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code>) indicating successful operation and other values
+indicating errors. The exception is data structure accessor functions,
+which cannot fail. Such functions may return <code class="docutils literal notranslate"><span class="pre">void</span></code> or a data value.</p>
+<p>Unless specified otherwise, if multiple error conditions apply, an
+implementation is free to return any of the applicable error codes. The
+choice of error code is considered an implementation quality issue.
+Different implementations may make different choices, for example to
+favor code size over ease of debugging or vice versa.</p>
+<p>Note that if the behavior is undefined (for example, if a function
+receives an invalid pointer as a parameter), this specification makes no
+guarantee that the function will return an error. Implementations are
+encouraged to return an error or halt the application in a manner that
+is appropriate for the platform if the undefined behavior condition can
+be detected. However, application programmers should be aware that
+undefined behavior conditions cannot be detected in general.</p>
+</div>
+<div class="section" id="behavior-on-error">
+<h3>Behavior on error</h3>
+<p>All function calls must be implemented atomically:</p>
+<ul class="simple">
+<li>When a function returns a type other than <code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code>, the
+requested action has been carried out.</li>
+<li>When a function returns the status <code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code>, the requested
+action has been carried out.</li>
+<li>When a function returns another status of type <code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code>, no
+action has been carried out. The content of the output parameters is
+undefined, but otherwise the state of the system has not changed,
+except as described below.</li>
+</ul>
+<p>In general, functions that modify the system state, for example,
+creating or destroying a key, must leave the system state unchanged if
+they return an error code. There are specific conditions that can result
+in different behavior:</p>
+<ul class="simple">
+<li>The status <code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code> indicates that a parameter was not
+in a valid state for the requested action. This parameter may have
+been modified by the call and is now in an undefined state. The only
+valid action on an object in an undefined state is to abort it with
+the appropriate <code class="docutils literal notranslate"><span class="pre">psa_abort_xxx</span></code> function.</li>
+<li>The status <code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_CAPACITY</span></code> indicates that a key
+derivation object has reached its maximum capacity. The key
+derivation operation may have been modified by the call. Any further
+attempt to obtain output from the key derivation operation will
+return <code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_CAPACITY</span></code>.</li>
+<li>The status <code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code> indicates that the
+communication between the application and the cryptoprocessor has
+broken down. In this case, the cryptoprocessor must either finish the
+requested action successfully, or interrupt the action and roll back
+the system to its original state. Because it is often impossible to
+report the outcome to the application after a communication failure,
+this specification does not provide a way for the application to
+determine whether the action was successful.</li>
+<li>The statuses <code class="docutils literal notranslate"><span class="pre">PSA_ERROR_STORAGE_FAILURE</span></code>,
+<code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code> and <code class="docutils literal notranslate"><span class="pre">PSA_ERROR_TAMPERING_DETECTED</span></code>
+may indicate data corruption in the system state. When a function
+returns one of these statuses, the system state may have changed from
+its previous state before the function call, even though the function
+call failed.</li>
+<li>Some system states cannot be rolled back, for example, the internal
+state of the random number generator or the content of access logs.</li>
+</ul>
+<p>Unless otherwise documented, the content of output parameters is not
+defined when a function returns a status other than <code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code>.
+Implementations should set output parameters to safe defaults to avoid
+leaking confidential data and limit risk, in case an application does
+not properly handle all errors.</p>
+</div>
+</div>
+<div class="section" id="parameter-conventions">
+<h2>Parameter conventions</h2>
+<div class="section" id="pointer-conventions">
+<h3>Pointer conventions</h3>
+<p>Unless explicitly stated in the documentation of a function, all
+pointers must be valid pointers to an object of the specified type.</p>
+<p>A parameter is considered a <strong>buffer</strong> if it points to an array of
+bytes. A buffer parameter always has the type <code class="docutils literal notranslate"><span class="pre">uint8_t</span> <span class="pre">*</span></code> or
+<code class="docutils literal notranslate"><span class="pre">const</span> <span class="pre">uint8_t</span> <span class="pre">*</span></code>, and always has an associated parameter indicating
+the size of the array. Note that a parameter of type <code class="docutils literal notranslate"><span class="pre">void</span> <span class="pre">*</span></code> is never
+considered a buffer.</p>
+<p>All parameters of pointer type must be valid non-null pointers, unless
+the pointer is to a buffer of length 0 or the function’s documentation
+explicitly describes the behavior when the pointer is null.
+Implementations where a null pointer dereference usually aborts the
+application, passing <code class="docutils literal notranslate"><span class="pre">NULL</span></code> as a function parameter where a null
+pointer is not allowed, should abort the caller in the habitual manner.</p>
+<p>Pointers to input parameters may be in read-only memory. Output
+parameters must be in writable memory. Output parameters that are not
+buffers must also be readable, and the implementation must be able to
+write to a non-buffer output parameter and read back the same value, as
+explained in the <a class="reference external" href="#stability-of-parameters">“Stability of
+parameters”</a> section.</p>
+</div>
+<div class="section" id="input-buffer-sizes">
+<h3>Input buffer sizes</h3>
+<p>For input buffers, the parameter convention is:</p>
+<ul class="simple">
+<li><code class="docutils literal notranslate"><span class="pre">const</span> <span class="pre">uint8_t</span> <span class="pre">*foo</span></code>: pointer to the first byte of the data. The
+pointer may be invalid if the buffer size is 0.</li>
+<li><code class="docutils literal notranslate"><span class="pre">size_t</span> <span class="pre">foo_length</span></code>: size of the buffer in bytes.</li>
+</ul>
+<p>The interface never uses input-output buffers.</p>
+</div>
+<div class="section" id="output-buffer-sizes">
+<h3>Output buffer sizes</h3>
+<p>For output buffers, the parameter convention is:</p>
+<ul class="simple">
+<li><code class="docutils literal notranslate"><span class="pre">uint8_t</span> <span class="pre">*foo</span></code>: pointer to the first byte of the data. The pointer
+may be invalid if the buffer size is 0.</li>
+<li><code class="docutils literal notranslate"><span class="pre">size_t</span> <span class="pre">foo_size</span></code>: the size of the buffer in bytes.</li>
+<li><code class="docutils literal notranslate"><span class="pre">size_t</span> <span class="pre">*foo_length</span></code>: on successful return, contains the length of
+the output in bytes.</li>
+</ul>
+<p>The content of the data buffer and of <code class="docutils literal notranslate"><span class="pre">*foo_length</span></code> on errors is
+unspecified, unless explicitly mentioned in the function description.
+They may be unmodified or set to a safe default. On successful
+completion, the content of the buffer between the offsets
+<code class="docutils literal notranslate"><span class="pre">*foo_length</span></code> and <code class="docutils literal notranslate"><span class="pre">foo_size</span></code> is also unspecified.</p>
+<p>Functions return <code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BUFFER_TOO_SMALL</span></code> if the buffer size is
+insufficient to carry out the requested operation. The interface defines
+macros to calculate a sufficient buffer size for each operation that has
+an output buffer. These macros return compile-time constants if their
+arguments are compile-time constants, so they are suitable for static or
+stack allocation. Refer to an individual function’s documentation for
+the associated output size macro.</p>
+<p>Some functions always return exactly as much data as the size of the
+output buffer. In this case, the parameter convention changes to:</p>
+<ul class="simple">
+<li><code class="docutils literal notranslate"><span class="pre">uint8_t</span> <span class="pre">*foo</span></code>: pointer to the first byte of the output. The
+pointer may be invalid if the buffer size is 0.</li>
+<li><code class="docutils literal notranslate"><span class="pre">size_t</span> <span class="pre">foo_length</span></code>: the number of bytes to return in <code class="docutils literal notranslate"><span class="pre">foo</span></code> if
+successful.</li>
+</ul>
+</div>
+<div class="section" id="overlap-between-parameters">
+<h3>Overlap between parameters</h3>
+<p>Output parameters that are not buffers must not overlap with any input
+buffer or with any other output parameter. Otherwise, the behavior is
+undefined.</p>
+<p>Output buffers may overlap with input buffers. If this happens, the
+implementation must return the same result, as if the buffers did not
+overlap. In other words, the implementation must behave as if it had
+copied all the inputs into temporary memory, as far as the result is
+concerned. However, application developers should note that overlap
+between parameters may affect the performance of a function call.
+Overlap may also affect memory management security if the buffer is
+located in memory that the caller shares with another security context,
+as described in the <a class="reference external" href="#stability-of-parameters">“Stability of
+parameters”</a> section.</p>
+</div>
+<div class="section" id="stability-of-parameters">
+<h3>Stability of parameters</h3>
+<p>In some environments, it is possible for the content of a parameter to
+change while a function is executing. It may also be possible for the
+content of an output parameter to be read before the function
+terminates. This can happen if the application is multithreaded. In some
+implementations, memory can be shared between security contexts, for
+example, between tasks in a multitasking operating system, between a
+user land task and the kernel, or between the non-secure world and the
+secure world of a trusted execution environment. This section describes
+what implementations need or need not guarantee in such cases.</p>
+<p>Parameters that are not buffers are assumed to be under the caller’s
+full control. In a shared memory environment, this means that the
+parameter must be in memory that is exclusively accessible by the
+application. In a multithreaded environment, this means that the
+parameter may not be modified during the execution, and the value of an
+output parameter is undetermined until the function returns. The
+implementation may read an input parameter that is not a buffer multiple
+times and expect to read the same data. The implementation may write to
+an output parameter that is not a buffer and expect to read back the
+value that it last wrote. The implementation has the same permissions on
+buffers that overlap with a buffer in the opposite direction.</p>
+<p>In an environment with multiple threads or with shared memory, the
+implementation carefully accesses non-overlapping buffer parameters in
+order to prevent any security risk resulting from the content of the
+buffer being modified or observed during the execution of the function.
+In an input buffer that does not overlap with an output buffer, the
+implementation reads each byte of the input once, at most. The
+implementation does not read from an output buffer that does not overlap
+with an input buffer. Additionally, the implementation does not write
+data to a non-overlapping output buffer if this data is potentially
+confidential and the implementation has not yet verified that outputting
+this data is authorized.</p>
+</div>
+</div>
+<div class="section" id="key-types-and-algorithms">
+<h2>Key types and algorithms</h2>
+<p>Types of cryptographic keys and cryptographic algorithms are encoded
+separately. Each is encoded by using an integral type:
+<code class="docutils literal notranslate"><span class="pre">psa_key_type_t</span></code> and <code class="docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code>, respectively.</p>
+<p>There is some overlap in the information conveyed by key types and
+algorithms. Both types contain enough information, so that the meaning
+of an algorithm type value does not depend on what type of key it is
+used with, and vice versa. However, the particular instance of an
+algorithm may depend on the key type. For example, the algorithm
+<code class="docutils literal notranslate"><span class="pre">PSA_ALG_GCM</span></code> can be instantiated as any AEAD algorithm using the GCM
+mode over a block cipher. The underlying block cipher is determined by
+the key type.</p>
+<p>Key types do not encode the key size. For example, AES-128, AES-192 and
+AES-256 share a key type <code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_AES</span></code>.</p>
+<div class="section" id="structure-of-key-and-algorithm-types">
+<h3>Structure of key and algorithm types</h3>
+<p>Both types use a partial bitmask structure, which allows the analysis
+and building of values from parts. However, the interface defines
+constants, so that applications do not need to depend on the encoding,
+and an implementation may only care about the encoding for code size
+optimization.</p>
+<p>The encodings follows a few conventions:</p>
+<ul class="simple">
+<li>The highest bit is a vendor flag. Current and future versions of this
+specification will only define values where this bit is clear.
+Implementations that wish to define additional
+implementation-specific values must use values where this bit is set,
+to avoid conflicts with future versions of this specification.</li>
+<li>The next few highest bits indicate the corresponding algorithm
+category: hash, MAC, symmetric cipher, asymmetric encryption, and so
+on.</li>
+<li>The following bits identify a family of algorithms in a
+category-dependent manner.</li>
+<li>In some categories and algorithm families, the lowest-order bits
+indicate a variant in a systematic way. For example, algorithm
+families that are parametrized around a hash function encode the hash
+in the 8 lowest bits.</li>
+</ul>
+</div>
+</div>
+<div class="section" id="concurrent-calls">
+<h2>Concurrent calls</h2>
+<p>In some environments, an application can make calls to the PSA crypto
+API in separate threads. In such an environment, concurrent calls are
+performed correctly, as if the calls were executed in sequence, provided
+that they obey the following constraints:</p>
+<ul class="simple">
+<li>There is no overlap between an output parameter of one call and an
+input or output parameter of another call. Overlap between input
+parameters is permitted.</li>
+<li>If a call modifies a key, then no other call must modify or use that
+key. <em>Using</em>, in this context, includes all functions of multipart
+operations using the key. Concurrent calls that merely use the same
+key are permitted.</li>
+<li>Concurrent calls must not use the same operation object.</li>
+</ul>
+<p>If any of these constraints are violated, the behavior is undefined.</p>
+<p>Individual implementations may provide additional guarantees.</p>
+</div>
+</div>
+<div class="section" id="implementation-considerations">
+<h1>Implementation considerations</h1>
+<div class="section" id="implementation-specific-aspects-of-the-interface">
+<h2>Implementation-specific aspects of the interface</h2>
+<div class="section" id="implementation-profile">
+<h3>Implementation profile</h3>
+<p>Implementations may implement a subset of the API and a subset of the
+available algorithms. The implemented subset is known as the
+implementation’s profile. The documentation for each implementation must
+describe the profile that it implements. This specification’s companion
+documents also define a number of standard profiles.</p>
+</div>
+<div class="section" id="implementation-specific-types">
+<h3>Implementation-specific types</h3>
+<p>This specification defines a number of platform-specific types, which
+represent data structures whose content depends on the implementation.
+These are C <code class="docutils literal notranslate"><span class="pre">struct</span></code> types. In the associated header files,
+<code class="docutils literal notranslate"><span class="pre">crypto.h</span></code> declares the <code class="docutils literal notranslate"><span class="pre">struct</span></code> tags and <code class="docutils literal notranslate"><span class="pre">crypto_struct.h</span></code>
+provides a definition for the structures.</p>
+</div>
+<div class="section" id="implementation-specific-macros">
+<h3>Implementation-specific macros</h3>
+<p>Some macros compute a result based on an algorithm or key type. This
+specification provides a sample implementation of these macros, which
+works for all standard types. If an implementation defines
+vendor-specific algorithms or key types, then it must provide an
+implementation for such macros that takes all relevant algorithms and
+types into account. Conversely, an implementation that does not support
+a certain algorithm or key type can define such macros in a simpler way
+that does not take unsupported argument values into account.</p>
+<p>Some macros define the minimum sufficient output buffer size for certain
+functions. In some cases, an implementation is allowed to require a
+buffer size that is larger than the theoretical minimum. An
+implementation must define minimum-size macros in such a way that it
+guarantees that the buffer of the resulting size is sufficient for the
+output of the corresponding function. Refer to each macro’s
+documentation for the applicable requirements.</p>
+</div>
+</div>
+<div class="section" id="porting-to-a-platform">
+<h2>Porting to a platform</h2>
+<div class="section" id="platform-assumptions">
+<h3>Platform assumptions</h3>
+<p>This specification is designed for a C89 platform. The interface is
+defined in terms of C macros, functions and objects.</p>
+<p>The specification assumes 8-bit bytes, and “byte” and “octet” are used
+synonymously.</p>
+</div>
+<div class="section" id="platform-specific-types">
+<h3>Platform-specific types</h3>
+<p>The specification makes use of some platform-specific types, which
+should be defined in <code class="docutils literal notranslate"><span class="pre">crypto_platform.h</span></code> or by a header included in
+this file. <code class="docutils literal notranslate"><span class="pre">crypto_platform.h</span></code> must define the following types:</p>
+<ul class="simple">
+<li><code class="docutils literal notranslate"><span class="pre">uint8_t</span></code>, <code class="docutils literal notranslate"><span class="pre">uint16_t</span></code>, <code class="docutils literal notranslate"><span class="pre">uint32_t</span></code>: unsigned integer types with
+8, 16 and 32 value bits respectively. These may be the types defined
+by the C99 header <code class="docutils literal notranslate"><span class="pre">stdint.h</span></code>.</li>
+<li><code class="docutils literal notranslate"><span class="pre">psa_key_handle_t</span></code>: an unsigned integer type of the
+implementation’s choice.</li>
+</ul>
+</div>
+<div class="section" id="cryptographic-hardware-support">
+<h3>Cryptographic hardware support</h3>
+<p>Implementations are encouraged to make use of hardware accelerators
+where available. A future version of this specification will define a
+function interface that calls drivers for hardware accelerators and
+external cryptographic hardware.</p>
+</div>
+</div>
+<div class="section" id="security-requirements-and-recommendations">
+<h2>Security requirements and recommendations</h2>
+<div class="section" id="error-detection">
+<h3>Error detection</h3>
+<p>Implementations that provide isolation between the caller and the
+cryptography processing environment must validate parameters to ensure
+that the cryptography processing environment is protected from attacks
+caused by passing invalid parameters.</p>
+<p>Even implementations that do not provide isolation should strive to
+detect bad parameters and fail-safe as much as possible.</p>
+</div>
+<div class="section" id="memory-cleanup">
+<h3>Memory cleanup</h3>
+<p>Implementations must wipe all sensitive data from memory when it is no
+longer used. They should wipe this sensitive data as soon as possible.
+In any case, all temporary data used during the execution of a function,
+such as stack buffers, must be wiped before the function returns. All
+data associated with an object, such as a multipart operation, must be
+wiped, at the latest, when the object becomes inactive, for example,
+when a multipart operation is aborted.</p>
+<p>The rationale for this non-functional requirement is to minimize impact
+if the system is compromised. If sensitive data is wiped immediately
+after use, only data that is currently in use can be leaked. It does not
+compromise past data.</p>
+</div>
+<div class="section" id="safe-outputs-on-error">
+<h3>Safe outputs on error</h3>
+<p>Implementations must ensure that confidential data is not written to
+output parameters before validating that the disclosure of this
+confidential data is authorized. This requirement is especially
+important for implementations where the caller may share memory with
+another security context, as described in the <a class="reference external" href="#stability-of-parameters">“Stability of
+parameters”</a> section.</p>
+<p>In most cases, the specification does not define the content of output
+parameters when an error occurs. Implementations should try to ensure
+that the content of output parameters is as safe as possible, in case an
+application flaw or a data leak causes it to be used. In particular, Arm
+recommends that implementations avoid placing partial output in output
+buffers when an action is interrupted. The meaning of “safe as possible”
+depends on the implementation, as different environments require
+different compromises between implementation complexity, overall
+robustness and performance. Some common strategies are to leave output
+parameters unchanged, in case of errors, or zeroing them out.</p>
+</div>
+<div class="section" id="attack-resistance">
+<h3>Attack resistance</h3>
+<p>Cryptographic code tends to manipulate high-value secrets, from which
+other secrets can be unlocked. As such, it is a high-value target for
+attacks. There is a vast body of literature on attack types, such as
+side channel attacks and glitch attacks. Typical side channels include
+timing, cache access patterns, branch-prediction access patterns, power
+consumption, radio emissions and more.</p>
+<p>This specification does not specify particular requirements for attack
+resistance. Therefore, implementers should consider the attack
+resistance desired in each use case and design their implementation
+accordingly. Security standards for attack resistance for particular
+targets may be applicable in certain use cases.</p>
+</div>
+</div>
+<div class="section" id="other-implementation-considerations">
+<h2>Other implementation considerations</h2>
+<div class="section" id="philosophy-of-resource-management">
+<h3>Philosophy of resource management</h3>
+<p>The specification allows most functions to return
+<code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code>. This gives implementations the
+freedom to manage memory as they please.</p>
+<p>Alternatively, the interface is also designed for conservative
+strategies of memory management. An implementation may avoid dynamic
+memory allocation altogether by obeying certain restrictions:</p>
+<ul class="simple">
+<li>Pre-allocate memory for a predefined number of keys, each with
+sufficient memory for all key types that can be stored.</li>
+<li>For multipart operations, in an implementation without isolation,
+place all the data that needs to be carried over from one step to the
+next in the operation object. The application is then fully in
+control of how memory is allocated for the operation.</li>
+<li>In an implementation with isolation, pre-allocate memory for a
+predefined number of operations inside the cryptoprocessor.</li>
+</ul>
+<!--
+#### Inclusion of algorithms
+
+Inline algorithm-generic functions into specialized functions at compile/link time
+--></div>
+</div>
+</div>
+<div class="section" id="usage-considerations">
+<h1>Usage considerations</h1>
+<div class="section" id="security-recommendations">
+<h2>Security recommendations</h2>
+<div class="section" id="always-check-for-errors">
+<h3>Always check for errors</h3>
+<p>Most functions in this API can return errors. All functions that can
+fail have the return type <code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code>. A few functions cannot fail,
+and thus, return <code class="docutils literal notranslate"><span class="pre">void</span></code> or some other type.</p>
+<p>If an error occurs, unless otherwise specified, the content of the
+output parameters is undefined and must not be used.</p>
+<p>Some common causes of errors include:</p>
+<ul class="simple">
+<li>In implementations where the keys are stored and processed in a
+separate environment from the application, all functions that need to
+access the cryptography processing environment may fail due to an
+error in the communication between the two environments.</li>
+<li>If an algorithm is implemented with a hardware accelerator, which is
+logically separate from the application processor, the accelerator
+may fail, even when the application processor keeps running normally.</li>
+<li>All functions may fail due to a lack of resources. However, some
+implementations guarantee that certain functions always have
+sufficient memory.</li>
+<li>All functions that access persistent keys may fail due to a storage
+failure.</li>
+<li>All functions that require randomness may fail due to a lack of
+entropy. Implementations are encouraged to seed the random generator
+with sufficient entropy during the execution of <code class="docutils literal notranslate"><span class="pre">psa_crypto_init</span></code>.
+However, some security standards require periodic reseeding from a
+hardware random generator, which can fail.</li>
+</ul>
+</div>
+<div class="section" id="shared-memory-and-concurrency">
+<h3>Shared memory and concurrency</h3>
+<p>Some environments allow applications to be multithreaded, while others
+do not. In some environments, applications may share memory with a
+different security context. In environments with multithreaded
+applications or shared memory, applications must be written carefully to
+avoid data corruption or leakage. This specification requires the
+application to obey certain constraints.</p>
+<p>In general, this API allows either one writer or any number of
+simultaneous readers, on any given object. In other words, if two or
+more calls access the same object concurrently, then the behavior is
+only well-defined if all the calls are only reading from the object and
+do not modify it. Read accesses include reading memory by input
+parameters and reading keystore content by using a key. For more
+details, refer to the <a class="reference external" href="#concurrent-calls">“Concurrent calls”</a>
+section.</p>
+<p>If an application shares memory with another security context, it may
+pass shared memory blocks as input buffers or output buffers, but not as
+non-buffer parameters. For more details, refer to the <a class="reference external" href="#stability-of-parameters">“Stability of
+parameters”</a> section.</p>
+</div>
+<div class="section" id="cleaning-up-after-use">
+<h3>Cleaning up after use</h3>
+<p>To minimize impact if the system is compromised, applications should
+wipe all sensitive data from memory when it is no longer used. That way,
+only data that is currently in use may be leaked, and past data is not
+compromised.</p>
+<p>Wiping sensitive data includes:</p>
+<ul class="simple">
+<li>Clearing temporary buffers in the stack or on the heap.</li>
+<li>Aborting operations if they will not be finished.</li>
+<li>Destroying keys that are no longer used.</li>
+</ul>
+</div>
+</div>
+</div>
+
+
+ </div>
+
+ </div>
+ </div>
+ <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
+ <div class="sphinxsidebarwrapper">
+<h1 class="logo"><a href="index.html">psa_crypto_api</a></h1>
+
+
+
+
+
+
+
+
+<h3>Navigation</h3>
+<ul class="current">
+<li class="toctree-l1 current"><a class="current reference internal" href="#">Introduction</a></li>
+<li class="toctree-l1"><a class="reference internal" href="#design-goals">Design goals</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="#suitable-for-constrained-devices">Suitable for constrained devices</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#a-keystore-interface">A keystore interface</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#optional-isolation">Optional isolation</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#choice-of-algorithms">Choice of algorithms</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#ease-of-use">Ease of use</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#example-use-cases">Example use cases</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="#network-security-tls">Network Security (TLS)</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#secure-storage">Secure Storage</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#network-credentials">Network Credentials</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#device-pairing">Device Pairing</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#secure-boot">Secure Boot</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#attestation">Attestation</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#factory-provisioning">Factory Provisioning</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="#functionality-overview">Functionality overview</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="#library-management">Library management</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#key-management">Key management</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="#volatile-keys">Volatile keys</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#persistent-keys">Persistent keys</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#recommendations-of-minimum-standards-for-key-management">Recommendations of minimum standards for key management</a></li>
+</ul>
+</li>
+<li class="toctree-l2"><a class="reference internal" href="#usage-policies">Usage policies</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#symmetric-cryptography">Symmetric cryptography</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="#multipart-operations">Multipart operations</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#authenticated-encryption">Authenticated encryption</a></li>
+</ul>
+</li>
+<li class="toctree-l2"><a class="reference internal" href="#key-derivation">Key derivation</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="#key-derivation-operations">Key derivation operations</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#key-derivation-function">Key derivation function</a></li>
+</ul>
+</li>
+<li class="toctree-l2"><a class="reference internal" href="#asymmetric-cryptography">Asymmetric cryptography</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="#asymmetric-encryption">Asymmetric encryption</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#hash-and-sign">Hash-and-sign</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#key-agreement">Key agreement</a></li>
+</ul>
+</li>
+<li class="toctree-l2"><a class="reference internal" href="#randomness-and-key-generation">Randomness and key generation</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#future-additions">Future additions</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="#sample-architectures">Sample architectures</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="#single-partition-architecture">Single-partition architecture</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#cryptographic-token-and-single-application-processor">Cryptographic token and single-application processor</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#cryptoprocessor-with-no-key-storage">Cryptoprocessor with no key storage</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#multi-client-cryptoprocessor">Multi-client cryptoprocessor</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#multi-cryptoprocessor-architecture">Multi-cryptoprocessor architecture</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="#library-conventions">Library conventions</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="#error-handling">Error handling</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="#return-status">Return status</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#behavior-on-error">Behavior on error</a></li>
+</ul>
+</li>
+<li class="toctree-l2"><a class="reference internal" href="#parameter-conventions">Parameter conventions</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="#pointer-conventions">Pointer conventions</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#input-buffer-sizes">Input buffer sizes</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#output-buffer-sizes">Output buffer sizes</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#overlap-between-parameters">Overlap between parameters</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#stability-of-parameters">Stability of parameters</a></li>
+</ul>
+</li>
+<li class="toctree-l2"><a class="reference internal" href="#key-types-and-algorithms">Key types and algorithms</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="#structure-of-key-and-algorithm-types">Structure of key and algorithm types</a></li>
+</ul>
+</li>
+<li class="toctree-l2"><a class="reference internal" href="#concurrent-calls">Concurrent calls</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="#implementation-considerations">Implementation considerations</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="#implementation-specific-aspects-of-the-interface">Implementation-specific aspects of the interface</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="#implementation-profile">Implementation profile</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#implementation-specific-types">Implementation-specific types</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#implementation-specific-macros">Implementation-specific macros</a></li>
+</ul>
+</li>
+<li class="toctree-l2"><a class="reference internal" href="#porting-to-a-platform">Porting to a platform</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="#platform-assumptions">Platform assumptions</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#platform-specific-types">Platform-specific types</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#cryptographic-hardware-support">Cryptographic hardware support</a></li>
+</ul>
+</li>
+<li class="toctree-l2"><a class="reference internal" href="#security-requirements-and-recommendations">Security requirements and recommendations</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="#error-detection">Error detection</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#memory-cleanup">Memory cleanup</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#safe-outputs-on-error">Safe outputs on error</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#attack-resistance">Attack resistance</a></li>
+</ul>
+</li>
+<li class="toctree-l2"><a class="reference internal" href="#other-implementation-considerations">Other implementation considerations</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="#philosophy-of-resource-management">Philosophy of resource management</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="#usage-considerations">Usage considerations</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="#security-recommendations">Security recommendations</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="#always-check-for-errors">Always check for errors</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#shared-memory-and-concurrency">Shared memory and concurrency</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#cleaning-up-after-use">Cleaning up after use</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html">Implementation-specific definitions</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#library-initialization">Library initialization</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-attributes">Key attributes</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-management">Key management</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-import-and-export">Key import and export</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#message-digests">Message digests</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#message-authentication-codes">Message authentication codes</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#symmetric-ciphers">Symmetric ciphers</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#authenticated-encryption-with-associated-data-aead">Authenticated encryption with associated data (AEAD)</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#asymmetric-cryptography">Asymmetric cryptography</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-derivation-and-pseudorandom-generation">Key derivation and pseudorandom generation</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#random-generation">Random generation</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#error-codes">Error codes</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-and-algorithm-types">Key and algorithm types</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-lifetimes">Key lifetimes</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-policies">Key policies</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-derivation">Key derivation</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#other-definitions">Other definitions</a></li>
+</ul>
+
+<div class="relations">
+<h3>Related Topics</h3>
+<ul>
+ <li><a href="index.html">Documentation overview</a><ul>
+ <li>Previous: <a href="index.html" title="previous chapter">PSA Cryptography API Specification</a></li>
+ <li>Next: <a href="from_doxygen.html" title="next chapter">Implementation-specific definitions</a></li>
+ </ul></li>
+</ul>
+</div>
+<div id="searchbox" style="display: none" role="search">
+ <h3>Quick search</h3>
+ <div class="searchformwrapper">
+ <form class="search" action="search.html" method="get">
+ <input type="text" name="q" />
+ <input type="submit" value="Go" />
+ <input type="hidden" name="check_keywords" value="yes" />
+ <input type="hidden" name="area" value="default" />
+ </form>
+ </div>
+</div>
+<script type="text/javascript">$('#searchbox').show(0);</script>
+
+
+
+
+
+
+
+
+ </div>
+ </div>
+ <div class="clearer"></div>
+ </div>
+ <div class="footer">
+ ©2019, Arm.
+
+ |
+ Powered by <a href="http://sphinx-doc.org/">Sphinx 1.8.5</a>
+ & <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
+
+ |
+ <a href="_sources/general.rst.txt"
+ rel="nofollow">Page source</a>
+ </div>
+
+
+
+
+ </body>
+</html>
\ No newline at end of file
diff --git a/docs/html/genindex.html b/docs/html/genindex.html
new file mode 100644
index 0000000..b0e55bf
--- /dev/null
+++ b/docs/html/genindex.html
@@ -0,0 +1,132 @@
+
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+ <title>Index — psa_crypto_api 1.0 beta3 documentation</title>
+ <link rel="stylesheet" href="_static/alabaster.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+ <script type="text/javascript" id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
+ <script type="text/javascript" src="_static/jquery.js"></script>
+ <script type="text/javascript" src="_static/underscore.js"></script>
+ <script type="text/javascript" src="_static/doctools.js"></script>
+ <script type="text/javascript" src="_static/language_data.js"></script>
+ <link rel="index" title="Index" href="#" />
+ <link rel="search" title="Search" href="search.html" />
+
+ <link rel="stylesheet" href="_static/custom.css" type="text/css" />
+
+
+ <meta name="viewport" content="width=device-width, initial-scale=0.9, maximum-scale=0.9" />
+
+ </head><body>
+
+
+ <div class="document">
+ <div class="documentwrapper">
+ <div class="bodywrapper">
+
+
+ <div class="body" role="main">
+
+
+<h1 id="index">Index</h1>
+
+<div class="genindex-jumpbox">
+
+</div>
+
+
+ </div>
+
+ </div>
+ </div>
+ <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
+ <div class="sphinxsidebarwrapper">
+<h1 class="logo"><a href="index.html">psa_crypto_api</a></h1>
+
+
+
+
+
+
+
+
+<h3>Navigation</h3>
+<ul>
+<li class="toctree-l1"><a class="reference internal" href="general.html">Introduction</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#design-goals">Design goals</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#functionality-overview">Functionality overview</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#sample-architectures">Sample architectures</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#library-conventions">Library conventions</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#implementation-considerations">Implementation considerations</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#usage-considerations">Usage considerations</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html">Implementation-specific definitions</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#library-initialization">Library initialization</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-attributes">Key attributes</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-management">Key management</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-import-and-export">Key import and export</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#message-digests">Message digests</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#message-authentication-codes">Message authentication codes</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#symmetric-ciphers">Symmetric ciphers</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#authenticated-encryption-with-associated-data-aead">Authenticated encryption with associated data (AEAD)</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#asymmetric-cryptography">Asymmetric cryptography</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-derivation-and-pseudorandom-generation">Key derivation and pseudorandom generation</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#random-generation">Random generation</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#error-codes">Error codes</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-and-algorithm-types">Key and algorithm types</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-lifetimes">Key lifetimes</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-policies">Key policies</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-derivation">Key derivation</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#other-definitions">Other definitions</a></li>
+</ul>
+
+<div class="relations">
+<h3>Related Topics</h3>
+<ul>
+ <li><a href="index.html">Documentation overview</a><ul>
+ </ul></li>
+</ul>
+</div>
+<div id="searchbox" style="display: none" role="search">
+ <h3>Quick search</h3>
+ <div class="searchformwrapper">
+ <form class="search" action="search.html" method="get">
+ <input type="text" name="q" />
+ <input type="submit" value="Go" />
+ <input type="hidden" name="check_keywords" value="yes" />
+ <input type="hidden" name="area" value="default" />
+ </form>
+ </div>
+</div>
+<script type="text/javascript">$('#searchbox').show(0);</script>
+
+
+
+
+
+
+
+
+ </div>
+ </div>
+ <div class="clearer"></div>
+ </div>
+ <div class="footer">
+ ©2019, Arm.
+
+ |
+ Powered by <a href="http://sphinx-doc.org/">Sphinx 1.8.5</a>
+ & <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
+
+ </div>
+
+
+
+
+ </body>
+</html>
\ No newline at end of file
diff --git a/docs/html/globals.html b/docs/html/globals.html
deleted file mode 100644
index a355aaf..0000000
--- a/docs/html/globals.html
+++ /dev/null
@@ -1,812 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: File Members</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li class="current"><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
- <div id="navrow2" class="tabs2">
- <ul class="tablist">
- <li><a href="files.html"><span>File List</span></a></li>
- <li class="current"><a href="globals.html"><span>File Members</span></a></li>
- </ul>
- </div>
- <div id="navrow3" class="tabs2">
- <ul class="tablist">
- <li class="current"><a href="globals.html"><span>All</span></a></li>
- <li><a href="globals_func.html"><span>Functions</span></a></li>
- <li><a href="globals_type.html"><span>Typedefs</span></a></li>
- <li><a href="globals_defs.html"><span>Macros</span></a></li>
- </ul>
- </div>
- <div id="navrow4" class="tabs3">
- <ul class="tablist">
- <li class="current"><a href="globals.html#index_p"><span>p</span></a></li>
- </ul>
- </div>
-</div><!-- top -->
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div class="contents">
-<div class="textblock">Here is a list of all documented file members with links to the documentation:</div>
-
-<h3><a class="anchor" id="index_p"></a>- p -</h3><ul>
-<li>psa_aead_abort()
-: <a class="el" href="group__aead.html#gae8a5f93d92318c8f592ee9fbb9d36ba0">crypto.h</a>
-</li>
-<li>psa_aead_decrypt()
-: <a class="el" href="group__aead.html#gaa8ce6527f2e227f1071fadbf2099793b">crypto.h</a>
-</li>
-<li>PSA_AEAD_DECRYPT_OUTPUT_SIZE
-: <a class="el" href="crypto__sizes_8h.html#a1d057796166c16eb673ad1997e48a60b">crypto_sizes.h</a>
-</li>
-<li>psa_aead_decrypt_setup()
-: <a class="el" href="group__aead.html#ga439896519d4a367ec86b47f201884152">crypto.h</a>
-</li>
-<li>psa_aead_encrypt()
-: <a class="el" href="group__aead.html#ga44de092cf58bb6c820c5c80a6c51610d">crypto.h</a>
-</li>
-<li>PSA_AEAD_ENCRYPT_OUTPUT_SIZE
-: <a class="el" href="crypto__sizes_8h.html#a85667d47a7aa6c7b99a80e5273671266">crypto_sizes.h</a>
-</li>
-<li>psa_aead_encrypt_setup()
-: <a class="el" href="group__aead.html#ga47265dc4852f1476f852752218fd12b2">crypto.h</a>
-</li>
-<li>psa_aead_finish()
-: <a class="el" href="group__aead.html#ga759791bbe1763b377c3b5447641f1fc8">crypto.h</a>
-</li>
-<li>PSA_AEAD_FINISH_OUTPUT_SIZE
-: <a class="el" href="crypto__sizes_8h.html#ab097f6e054f1a73e975d597ade9029a6">crypto_sizes.h</a>
-</li>
-<li>psa_aead_generate_nonce()
-: <a class="el" href="group__aead.html#ga3eadcf2a29f662129ea4fb3454969ba2">crypto.h</a>
-</li>
-<li>PSA_AEAD_OPERATION_INIT
-: <a class="el" href="group__aead.html#gaf52e036794c0dc6fbadd93a2b990f366">crypto.h</a>
-</li>
-<li>psa_aead_operation_t
-: <a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">crypto.h</a>
-</li>
-<li>psa_aead_set_lengths()
-: <a class="el" href="group__aead.html#gad3431e28d05002c2a7b0760610176050">crypto.h</a>
-</li>
-<li>psa_aead_set_nonce()
-: <a class="el" href="group__aead.html#ga40641d0721ca7fe01bbcd9ef635fbc46">crypto.h</a>
-</li>
-<li>PSA_AEAD_TAG_LENGTH
-: <a class="el" href="crypto__sizes_8h.html#a8e3079b2e624cb8d32b94843cddada49">crypto_sizes.h</a>
-</li>
-<li>psa_aead_update()
-: <a class="el" href="group__aead.html#ga3b105de2088cef7c3d9e2fd8048c841c">crypto.h</a>
-</li>
-<li>psa_aead_update_ad()
-: <a class="el" href="group__aead.html#ga6d0eed03f832e5c9c91cb8adf2882569">crypto.h</a>
-</li>
-<li>psa_aead_verify()
-: <a class="el" href="group__aead.html#gaaed211fc61977c859d6ff07f39f59219">crypto.h</a>
-</li>
-<li>PSA_ALG_AEAD_WITH_DEFAULT_TAG_LENGTH
-: <a class="el" href="group__crypto__types.html#gaddea507e062250cda8a29407a9480d2b">crypto_values.h</a>
-</li>
-<li>PSA_ALG_AEAD_WITH_TAG_LENGTH
-: <a class="el" href="group__crypto__types.html#gaa63c520b62ab001d54d28801742fc9db">crypto_values.h</a>
-</li>
-<li>PSA_ALG_ANY_HASH
-: <a class="el" href="group__crypto__types.html#gaa1288ea8bd397a8a3f5e19e94110f2e4">crypto_values.h</a>
-</li>
-<li>PSA_ALG_ARC4
-: <a class="el" href="group__crypto__types.html#gab6a5284decb0e5e1b5b8740a41ef3c5e">crypto_values.h</a>
-</li>
-<li>PSA_ALG_CBC_NO_PADDING
-: <a class="el" href="group__crypto__types.html#gacb332d72716958880ee7f97d8365ae66">crypto_values.h</a>
-</li>
-<li>PSA_ALG_CBC_PKCS7
-: <a class="el" href="group__crypto__types.html#gaef50d2e9716eb6d476046608e4e0c78c">crypto_values.h</a>
-</li>
-<li>PSA_ALG_CCM
-: <a class="el" href="group__crypto__types.html#gac2c0e7d21f1b2df5e76bcb4a8f84273c">crypto_values.h</a>
-</li>
-<li>PSA_ALG_CTR
-: <a class="el" href="group__crypto__types.html#gad318309706a769cffdc64e4c7e06b2e9">crypto_values.h</a>
-</li>
-<li>PSA_ALG_DETERMINISTIC_DSA
-: <a class="el" href="group__crypto__types.html#gab8eb98fb6d2e094e47f3b44dfe128f94">crypto_values.h</a>
-</li>
-<li>PSA_ALG_DETERMINISTIC_ECDSA
-: <a class="el" href="group__crypto__types.html#ga11da566bcd341661c8de921e2ca5ed03">crypto_values.h</a>
-</li>
-<li>PSA_ALG_DSA
-: <a class="el" href="group__crypto__types.html#ga9a68efdddff5ae95f104a1416b12742e">crypto_values.h</a>
-</li>
-<li>PSA_ALG_ECDH
-: <a class="el" href="group__crypto__types.html#gab2dbcf71b63785e7dd7b54a100edee43">crypto_values.h</a>
-</li>
-<li>PSA_ALG_ECDSA
-: <a class="el" href="group__crypto__types.html#ga7e3ce9f514a227d5ba5d8318870452e3">crypto_values.h</a>
-</li>
-<li>PSA_ALG_ECDSA_ANY
-: <a class="el" href="group__crypto__types.html#ga51d6b6044a62e33cae0cf64bfc3b22a4">crypto_values.h</a>
-</li>
-<li>PSA_ALG_FFDH
-: <a class="el" href="group__crypto__types.html#ga0ebbb6f93a05b6511e6f108ffd2d1eb4">crypto_values.h</a>
-</li>
-<li>PSA_ALG_FULL_LENGTH_MAC
-: <a class="el" href="group__crypto__types.html#gaa05a8d99634f3350597ac9284fb70cb1">crypto_values.h</a>
-</li>
-<li>PSA_ALG_GCM
-: <a class="el" href="group__crypto__types.html#ga0d7d02b15aaae490d38277d99f1c637c">crypto_values.h</a>
-</li>
-<li>PSA_ALG_HKDF
-: <a class="el" href="group__crypto__types.html#ga32a888fb360e6e25cab8a343772c4a82">crypto_values.h</a>
-</li>
-<li>PSA_ALG_HMAC
-: <a class="el" href="group__crypto__types.html#ga70f397425684b3efcde1e0e34c28261f">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_AEAD
-: <a class="el" href="group__crypto__types.html#ga1d44829d60065eaa4ac9a703e7d6abc8">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_ASYMMETRIC_ENCRYPTION
-: <a class="el" href="group__crypto__types.html#ga41d2ee937d54efd76bd54a97b2ebc08a">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_BLOCK_CIPHER_MAC
-: <a class="el" href="group__crypto__types.html#gae49d1eb601125d65a5c5b252aa45479e">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_CIPHER
-: <a class="el" href="group__crypto__types.html#ga1d1a5a402ad89a2e68f12bfb535490eb">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_ECDH
-: <a class="el" href="group__crypto__types.html#ga9d9b6533d2a6bea7bac7ae01facb820d">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_FFDH
-: <a class="el" href="group__crypto__types.html#gaa3cf76164cd9375af4fb8a291078a19e">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_HASH
-: <a class="el" href="group__crypto__types.html#gac9280662bb482590b4b33d1dcd32930f">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_HASH_AND_SIGN
-: <a class="el" href="group__crypto__types.html#gad8a8ea0536975363b66410cdeafe38b6">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_HKDF
-: <a class="el" href="group__crypto__types.html#ga1979d0a76fcee6164cf2e65960f38db2">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_HMAC
-: <a class="el" href="group__crypto__types.html#ga4a050c3c3cbc6eb96418f18847601c8a">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_KEY_AGREEMENT
-: <a class="el" href="group__crypto__types.html#ga59753742cb06553bd22751bbef472b6f">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_KEY_DERIVATION
-: <a class="el" href="group__crypto__types.html#gaf8b90c648aa53dbd06c236695e300cd0">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_MAC
-: <a class="el" href="group__crypto__types.html#gaca7aee4c9dde316b3b1a150a26eab776">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_RAW_KEY_AGREEMENT
-: <a class="el" href="group__crypto__types.html#gaa40ab362ce141ce541d69b2eb1f41438">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_SIGN
-: <a class="el" href="group__crypto__types.html#ga6d490d0904e0698f6c1268a89d72ff31">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_STREAM_CIPHER
-: <a class="el" href="group__crypto__types.html#gacfec68e0c6175e02e1b2ebc97df383c0">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_TLS12_PRF
-: <a class="el" href="group__crypto__types.html#gaa3c18890c50222e5219f40ade8927e66">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_TLS12_PSK_TO_MS
-: <a class="el" href="group__crypto__types.html#gab25ecc074a93fd11069bedfbba5a287b">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_WILDCARD
-: <a class="el" href="group__crypto__types.html#gacf83d7430e82b97cecb8b26ca6fa1426">crypto_values.h</a>
-</li>
-<li>PSA_ALG_KEY_AGREEMENT
-: <a class="el" href="group__crypto__types.html#ga78bb81cffb87a635c247725eeb2a2682">crypto_values.h</a>
-</li>
-<li>PSA_ALG_RSA_OAEP
-: <a class="el" href="group__crypto__types.html#gaa1235dc3fdd9839c6c1b1a9857344c76">crypto_values.h</a>
-</li>
-<li>PSA_ALG_RSA_PKCS1V15_CRYPT
-: <a class="el" href="group__crypto__types.html#ga4c540d3abe43fb9abcb94f2bc51acef9">crypto_values.h</a>
-</li>
-<li>PSA_ALG_RSA_PKCS1V15_SIGN
-: <a class="el" href="group__crypto__types.html#ga702ff75385a6ae7d4247033f479439af">crypto_values.h</a>
-</li>
-<li>PSA_ALG_RSA_PKCS1V15_SIGN_RAW
-: <a class="el" href="group__crypto__types.html#ga4215e2a78dcf834e9a625927faa2a817">crypto_values.h</a>
-</li>
-<li>PSA_ALG_RSA_PSS
-: <a class="el" href="group__crypto__types.html#ga62152bf4cb4bf6aace5e1be8f143564d">crypto_values.h</a>
-</li>
-<li>PSA_ALG_SHA3_224
-: <a class="el" href="group__crypto__types.html#ga16f5fe34ccce68c2fada1224c054a999">crypto_values.h</a>
-</li>
-<li>PSA_ALG_SHA3_256
-: <a class="el" href="group__crypto__types.html#gaace70d9515489bbe3c5e7ac1b7d9155b">crypto_values.h</a>
-</li>
-<li>PSA_ALG_SHA3_384
-: <a class="el" href="group__crypto__types.html#gab0f079257ea75e2acfe2fc3b38c78cd8">crypto_values.h</a>
-</li>
-<li>PSA_ALG_SHA3_512
-: <a class="el" href="group__crypto__types.html#ga37e5dbe936dddb155e76f2997de27188">crypto_values.h</a>
-</li>
-<li>PSA_ALG_SHA_224
-: <a class="el" href="group__crypto__types.html#ga25d6a3244d10a7148fe6b026d1979f7b">crypto_values.h</a>
-</li>
-<li>PSA_ALG_SHA_256
-: <a class="el" href="group__crypto__types.html#ga619471f978e13cdd0a1e37145e4bf341">crypto_values.h</a>
-</li>
-<li>PSA_ALG_SHA_384
-: <a class="el" href="group__crypto__types.html#ga58af64dd9a86a287e8da9ed7739eead4">crypto_values.h</a>
-</li>
-<li>PSA_ALG_SHA_512
-: <a class="el" href="group__crypto__types.html#gafba3ae409f46d3dd7f37a0910660c3e9">crypto_values.h</a>
-</li>
-<li>PSA_ALG_SHA_512_224
-: <a class="el" href="group__crypto__types.html#ga3fe2d7c3c80e3186ca78d16a35d5d931">crypto_values.h</a>
-</li>
-<li>PSA_ALG_SHA_512_256
-: <a class="el" href="group__crypto__types.html#ga5910b3964c14e9613e8643a45b09c2d4">crypto_values.h</a>
-</li>
-<li>PSA_ALG_SIGN_GET_HASH
-: <a class="el" href="group__crypto__types.html#ga24cf6d7bcd2b9aeeeff86f07b6c674e3">crypto_values.h</a>
-</li>
-<li>PSA_ALG_TLS12_PRF
-: <a class="el" href="group__crypto__types.html#ga6d5623c2ccda1d4a84e34351af8382d5">crypto_values.h</a>
-</li>
-<li>PSA_ALG_TLS12_PSK_TO_MS
-: <a class="el" href="group__crypto__types.html#ga039ec797f15d1635d9b2e09a611f8a68">crypto_values.h</a>
-</li>
-<li>PSA_ALG_TLS12_PSK_TO_MS_MAX_PSK_LEN
-: <a class="el" href="crypto__sizes_8h.html#ab589ea3b86f2bfa18880459299c58f8a">crypto_sizes.h</a>
-</li>
-<li>PSA_ALG_TRUNCATED_MAC
-: <a class="el" href="group__crypto__types.html#gaf36137110baf7bb13c5028fd62c64276">crypto_values.h</a>
-</li>
-<li>PSA_ALG_XTS
-: <a class="el" href="group__crypto__types.html#gaa722c0e426a797fd6d99623f59748125">crypto_values.h</a>
-</li>
-<li>psa_algorithm_t
-: <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">crypto_types.h</a>
-</li>
-<li>psa_allocate_key()
-: <a class="el" href="group__key__management.html#ga40094b77b7a42b9c8e158395113f1a35">crypto.h</a>
-</li>
-<li>psa_asymmetric_decrypt()
-: <a class="el" href="group__asymmetric.html#ga34b55fbaee23dba1a677186fc66a556e">crypto.h</a>
-</li>
-<li>PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE
-: <a class="el" href="crypto__sizes_8h.html#a61a246f3eac41989821d982e56fea6c1">crypto_sizes.h</a>
-</li>
-<li>psa_asymmetric_encrypt()
-: <a class="el" href="group__asymmetric.html#gad429293b7b0bf2a830b9540a02552004">crypto.h</a>
-</li>
-<li>PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE
-: <a class="el" href="crypto__sizes_8h.html#a66ba3bd93e5ec52870ccc3848778bad8">crypto_sizes.h</a>
-</li>
-<li>psa_asymmetric_sign()
-: <a class="el" href="group__asymmetric.html#ga1b0db9d345b5048cdd39357ac2d56c07">crypto.h</a>
-</li>
-<li>PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE
-: <a class="el" href="crypto__sizes_8h.html#a77565b9b4fe6d8730fd2120f4c8378ab">crypto_sizes.h</a>
-</li>
-<li>PSA_ASYMMETRIC_SIGNATURE_MAX_SIZE
-: <a class="el" href="crypto__sizes_8h.html#ad755101764dba14589e5919ee41be7ca">crypto_sizes.h</a>
-</li>
-<li>psa_asymmetric_verify()
-: <a class="el" href="group__asymmetric.html#ga1b8e964c8d927e3d632325d762959eb7">crypto.h</a>
-</li>
-<li>PSA_BLOCK_CIPHER_BLOCK_SIZE
-: <a class="el" href="group__crypto__types.html#gacaa366bdeb0413e63e87a667c5457b2e">crypto_values.h</a>
-</li>
-<li>psa_cipher_abort()
-: <a class="el" href="group__cipher.html#gaad482cdca2098bca0620596aaa02eaa4">crypto.h</a>
-</li>
-<li>psa_cipher_decrypt()
-: <a class="el" href="group__cipher.html#ga43d5991711ec45c98af0c1d99f6e0216">crypto.h</a>
-</li>
-<li>psa_cipher_decrypt_setup()
-: <a class="el" href="group__cipher.html#gaddf8504e5367cd0efb4415bdec004f44">crypto.h</a>
-</li>
-<li>psa_cipher_encrypt()
-: <a class="el" href="group__cipher.html#gac76dda492d9a1ba6b327bff610ec17b2">crypto.h</a>
-</li>
-<li>psa_cipher_encrypt_setup()
-: <a class="el" href="group__cipher.html#ga2a7fc79a9d150d42dba99f40ee3a185e">crypto.h</a>
-</li>
-<li>psa_cipher_finish()
-: <a class="el" href="group__cipher.html#ga1dcb58b8befe23f8a4d7a1d49c99249b">crypto.h</a>
-</li>
-<li>psa_cipher_generate_iv()
-: <a class="el" href="group__cipher.html#ga44857cf5e0c3d134a3c560f8ff5b50aa">crypto.h</a>
-</li>
-<li>PSA_CIPHER_OPERATION_INIT
-: <a class="el" href="group__cipher.html#ga2da0541aabf9a4995cf2004e36311919">crypto.h</a>
-</li>
-<li>psa_cipher_operation_t
-: <a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">crypto.h</a>
-</li>
-<li>psa_cipher_set_iv()
-: <a class="el" href="group__cipher.html#ga1359b2101f31637496ce7cc36c6e3d42">crypto.h</a>
-</li>
-<li>psa_cipher_update()
-: <a class="el" href="group__cipher.html#gafd0caea99cf1052527e4089d37f5ab91">crypto.h</a>
-</li>
-<li>psa_close_key()
-: <a class="el" href="group__key__management.html#gaa09b720d299dfe6b9f41c36e448078eb">crypto.h</a>
-</li>
-<li>psa_copy_key()
-: <a class="el" href="group__import__export.html#ga5c1c24176cfb1517a8806235b3162a9d">crypto.h</a>
-</li>
-<li>psa_create_key()
-: <a class="el" href="group__key__management.html#ga4108f255d3eaa6d23a7a14b684af8d7c">crypto.h</a>
-</li>
-<li>PSA_CRYPTO_GENERATOR_INIT
-: <a class="el" href="group__generators.html#ga4788b471385fc667876fbd8a0d3fe062">crypto.h</a>
-</li>
-<li>psa_crypto_generator_t
-: <a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">crypto.h</a>
-</li>
-<li>psa_crypto_init()
-: <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9">crypto.h</a>
-</li>
-<li>psa_destroy_key()
-: <a class="el" href="group__import__export.html#ga165085fc1bc7a78b91792fdd94ae102c">crypto.h</a>
-</li>
-<li>psa_ecc_curve_t
-: <a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">crypto_types.h</a>
-</li>
-<li>PSA_ECDSA_SIGNATURE_SIZE
-: <a class="el" href="crypto__sizes_8h.html#a10c472a35f04051add6b20cc228ffc11">crypto_sizes.h</a>
-</li>
-<li>PSA_ERROR_BAD_STATE
-: <a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_BUFFER_TOO_SMALL
-: <a class="el" href="group__error.html#ga695025f4ec11249aee7ea3d0f65e01c8">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_COMMUNICATION_FAILURE
-: <a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_EMPTY_SLOT
-: <a class="el" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_HARDWARE_FAILURE
-: <a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_INSUFFICIENT_CAPACITY
-: <a class="el" href="group__error.html#gaf1fa61f72e9e5b4a848c991bea495767">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_INSUFFICIENT_ENTROPY
-: <a class="el" href="group__error.html#ga4deb59fec02297ec5d8b42178323f675">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_INSUFFICIENT_MEMORY
-: <a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_INSUFFICIENT_STORAGE
-: <a class="el" href="group__error.html#ga897a45eb206a6f6b7be7ffbe36f0d766">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_INVALID_ARGUMENT
-: <a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_INVALID_HANDLE
-: <a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_INVALID_PADDING
-: <a class="el" href="group__error.html#gabe29594edbfb152cf153975b0597ac48">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_INVALID_SIGNATURE
-: <a class="el" href="group__error.html#ga35927f755d232c4766de600f2c49e9f2">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_NOT_PERMITTED
-: <a class="el" href="group__error.html#ga4d1b8dd8526177a15a210b7afc1accb1">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_NOT_SUPPORTED
-: <a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_OCCUPIED_SLOT
-: <a class="el" href="group__error.html#gac2fee3a51249fbea45360aaa911f3e58">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_STORAGE_FAILURE
-: <a class="el" href="group__error.html#gadd169a1af2707862b95fb9df91dfc37d">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_TAMPERING_DETECTED
-: <a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_UNKNOWN_ERROR
-: <a class="el" href="group__error.html#ga24d5fdcdd759f846f79d9e581c63a83f">crypto_values.h</a>
-</li>
-<li>psa_export_key()
-: <a class="el" href="group__import__export.html#ga902b9a7a6cf34d6111668be777b05eaf">crypto.h</a>
-</li>
-<li>psa_export_public_key()
-: <a class="el" href="group__import__export.html#gad760d1f0d4e60972c78cbb4c8a528256">crypto.h</a>
-</li>
-<li>psa_generate_key()
-: <a class="el" href="group__random.html#ga72921520494b4f007a3afb904cd9ecdd">crypto.h</a>
-</li>
-<li>psa_generate_random()
-: <a class="el" href="group__random.html#ga1985eae417dfbccedf50d5fff54ea8c5">crypto.h</a>
-</li>
-<li>psa_generator_abort()
-: <a class="el" href="group__generators.html#ga563ca64537d90368899286b36d8cf7f3">crypto.h</a>
-</li>
-<li>psa_generator_import_key()
-: <a class="el" href="group__generators.html#ga7fcdf07cd37279ca167db484053da894">crypto.h</a>
-</li>
-<li>psa_generator_read()
-: <a class="el" href="group__generators.html#gab5712ad29b78c2b170e64cc5bcfc1bce">crypto.h</a>
-</li>
-<li>PSA_GENERATOR_UNBRIDLED_CAPACITY
-: <a class="el" href="group__generators.html#gac3222df9b9ecca4d33ae56a7b8fbb1c9">crypto.h</a>
-</li>
-<li>psa_get_generator_capacity()
-: <a class="el" href="group__generators.html#ga7453491e3b440193be2c5dccc2040fd2">crypto.h</a>
-</li>
-<li>psa_get_key_domain_parameters()
-: <a class="el" href="group__import__export.html#gae260b92e32ac5d63f7dfc6ffdf6536f7">crypto.h</a>
-</li>
-<li>psa_get_key_information()
-: <a class="el" href="group__import__export.html#gae8939902d6977ea8ad13eb7b4db9a042">crypto.h</a>
-</li>
-<li>psa_get_key_lifetime()
-: <a class="el" href="group__key__management.html#ga1e4825ab59260aeb3bdbb3ff07210022">crypto.h</a>
-</li>
-<li>psa_get_key_policy()
-: <a class="el" href="group__policy.html#gaed087d1386b807edee66b2e445ba9111">crypto.h</a>
-</li>
-<li>psa_hash_abort()
-: <a class="el" href="group__hash.html#gab0b4d5f9912a615559497a467b532928">crypto.h</a>
-</li>
-<li>psa_hash_clone()
-: <a class="el" href="group__hash.html#ga39673348f3302b4646bd780034a5aeda">crypto.h</a>
-</li>
-<li>psa_hash_compare()
-: <a class="el" href="group__hash.html#ga0bb6dbd3c310648c3cf7d202413ff0bc">crypto.h</a>
-</li>
-<li>psa_hash_compute()
-: <a class="el" href="group__hash.html#gac69f7f19d96a56c28cf3799d11b12156">crypto.h</a>
-</li>
-<li>psa_hash_finish()
-: <a class="el" href="group__hash.html#ga4795fd06a0067b0adcd92e9627b8c97e">crypto.h</a>
-</li>
-<li>PSA_HASH_MAX_SIZE
-: <a class="el" href="crypto__sizes_8h.html#a6ce1014efbbc0bcca286ef7f9a72cb29">crypto_sizes.h</a>
-</li>
-<li>PSA_HASH_OPERATION_INIT
-: <a class="el" href="group__hash.html#ga6ab7fe8d3500bc2f21be840b4f4f8d1d">crypto.h</a>
-</li>
-<li>psa_hash_operation_t
-: <a class="el" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">crypto.h</a>
-</li>
-<li>psa_hash_setup()
-: <a class="el" href="group__hash.html#ga8d72896cf70fc4d514c5c6b978912515">crypto.h</a>
-</li>
-<li>PSA_HASH_SIZE
-: <a class="el" href="crypto__sizes_8h.html#aef340331ce3cba2b57e1fc5624bf1f99">crypto_sizes.h</a>
-</li>
-<li>psa_hash_update()
-: <a class="el" href="group__hash.html#ga65b16ef97d7f650899b7db4b7d1112ff">crypto.h</a>
-</li>
-<li>psa_hash_verify()
-: <a class="el" href="group__hash.html#ga7be923c5700c9c70ef77ee9b76d1a5c0">crypto.h</a>
-</li>
-<li>psa_import_key()
-: <a class="el" href="group__import__export.html#gac9f999cb4d098663d56095afe81a453a">crypto.h</a>
-</li>
-<li>PSA_KDF_STEP_INFO
-: <a class="el" href="group__derivation.html#ga836afe760bbda3dafc6c29631560b1a0">crypto_values.h</a>
-</li>
-<li>PSA_KDF_STEP_LABEL
-: <a class="el" href="group__derivation.html#ga9f4da10191bcb690b88756ed8470b03c">crypto_values.h</a>
-</li>
-<li>PSA_KDF_STEP_SALT
-: <a class="el" href="group__derivation.html#ga384777dac55791d8f3a1af72c847b327">crypto_values.h</a>
-</li>
-<li>PSA_KDF_STEP_SECRET
-: <a class="el" href="group__derivation.html#ga90a1995a41e26ed5ca30d2d4641d1168">crypto_values.h</a>
-</li>
-<li>psa_key_agreement()
-: <a class="el" href="group__derivation.html#ga2c7fe304cacc141ffb91553548abc5d2">crypto.h</a>
-</li>
-<li>psa_key_agreement_raw_shared_secret()
-: <a class="el" href="group__derivation.html#gaf1b12eff66a1a0020b5bdc8d0e910006">crypto.h</a>
-</li>
-<li>psa_key_derivation_input_bytes()
-: <a class="el" href="group__derivation.html#ga1b30e888db65c71f5337900848e1b03f">crypto.h</a>
-</li>
-<li>psa_key_derivation_input_key()
-: <a class="el" href="group__derivation.html#ga9e5f549aa1f6f3863a07008d3d98f91a">crypto.h</a>
-</li>
-<li>psa_key_derivation_setup()
-: <a class="el" href="group__derivation.html#ga1825696be813dfac2b8d3d02717e71c5">crypto.h</a>
-</li>
-<li>psa_key_derivation_step_t
-: <a class="el" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">crypto_types.h</a>
-</li>
-<li>PSA_KEY_EXPORT_MAX_SIZE
-: <a class="el" href="crypto__sizes_8h.html#a0aae885cc8ff92e00fb5248420b939c3">crypto_sizes.h</a>
-</li>
-<li>psa_key_handle_t
-: <a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">crypto.h</a>
-</li>
-<li>psa_key_id_t
-: <a class="el" href="group__key__lifetimes.html#ga11e986351c65bd3dc3c0fe2cd9926e4b">crypto_types.h</a>
-</li>
-<li>PSA_KEY_LIFETIME_PERSISTENT
-: <a class="el" href="group__key__lifetimes.html#ga3713a01c5fcd5f7eae46ff22ceaf6d02">crypto_values.h</a>
-</li>
-<li>psa_key_lifetime_t
-: <a class="el" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">crypto_types.h</a>
-</li>
-<li>PSA_KEY_LIFETIME_VOLATILE
-: <a class="el" href="group__key__lifetimes.html#ga8b438870ba69489b685730d346455108">crypto_values.h</a>
-</li>
-<li>psa_key_policy_get_algorithm()
-: <a class="el" href="group__policy.html#gaadf16b89ace53e1d2cb5bcb0aef24c86">crypto.h</a>
-</li>
-<li>psa_key_policy_get_usage()
-: <a class="el" href="group__policy.html#ga7746662b7503e484774d0ecb5d8ac2ab">crypto.h</a>
-</li>
-<li>PSA_KEY_POLICY_INIT
-: <a class="el" href="group__policy.html#ga5e6bc5f550e88fdc7790f2a75e79f7c5">crypto.h</a>
-</li>
-<li>psa_key_policy_set_usage()
-: <a class="el" href="group__policy.html#gac16792fd6d375a5f76d372090df40607">crypto.h</a>
-</li>
-<li>psa_key_policy_t
-: <a class="el" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">crypto.h</a>
-</li>
-<li>PSA_KEY_TYPE_AES
-: <a class="el" href="group__crypto__types.html#ga6ee54579dcf278c677eda4bb1a29575e">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_ARC4
-: <a class="el" href="group__crypto__types.html#gae4d46e83f910dcaa126000a8ed03cde9">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_CAMELLIA
-: <a class="el" href="group__crypto__types.html#gad8e5da742343fd5519f9d8a630c2ed81">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_DERIVE
-: <a class="el" href="group__crypto__types.html#gae871b2357b8593f33bfd51abbf93ebb1">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_DES
-: <a class="el" href="group__crypto__types.html#ga577562bfbbc691c820d55ec308333138">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_DH_KEYPAIR
-: <a class="el" href="group__crypto__types.html#ga39b63c6b97a62a316c0660bf72b2fdd5">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_DH_PUBLIC_KEY
-: <a class="el" href="group__crypto__types.html#ga325a340d7c72d99d3a678eb210bf6e0a">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_DSA_KEYPAIR
-: <a class="el" href="group__crypto__types.html#ga011010ee28c20388f3d89fb27088ed62">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_DSA_PUBLIC_KEY
-: <a class="el" href="group__crypto__types.html#ga5e7439c2905136366c3a876e62e5ddfc">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_ECC_KEYPAIR
-: <a class="el" href="group__crypto__types.html#gadf3ad65d157bf5282849c954bf3f51af">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_ECC_PUBLIC_KEY
-: <a class="el" href="group__crypto__types.html#gad54c03d3b47020e571a72cd01d978cf2">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_GET_CURVE
-: <a class="el" href="group__crypto__types.html#ga0c567210e6f80aa8f2aa87efa7a3a3f9">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_HMAC
-: <a class="el" href="group__crypto__types.html#ga92d989f4ca64abd00f463defd773a6f8">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_IS_ASYMMETRIC
-: <a class="el" href="group__crypto__types.html#gab138ae2ebf2905dfbaf4154db2620939">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_IS_DH
-: <a class="el" href="group__crypto__types.html#ga248ae35c0e2becaebbf479fc1c3a3b0e">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_IS_DSA
-: <a class="el" href="group__crypto__types.html#ga273fdfcf23eb0624f8b63d2321cf95c1">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_IS_ECC
-: <a class="el" href="group__crypto__types.html#ga88e01fa06b585654689a99bcc06bbe66">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_IS_ECC_KEYPAIR
-: <a class="el" href="group__crypto__types.html#ga7bf101b671e8cf26f4cb08fcb679db4b">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY
-: <a class="el" href="group__crypto__types.html#ga5af146a173b0c84d7e737e2fb6a3c0a7">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_IS_KEYPAIR
-: <a class="el" href="group__crypto__types.html#gac14c6d6e1b2b7f4a92a7b757465cff29">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_IS_PUBLIC_KEY
-: <a class="el" href="group__crypto__types.html#gac674a0f059bc0cb72b47f0c517b4f45b">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_IS_RSA
-: <a class="el" href="group__crypto__types.html#ga0e1d8f241228e49c9cadadfb4579ef1a">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_IS_UNSTRUCTURED
-: <a class="el" href="group__crypto__types.html#gaef86ce4e810e1c2c76068ac874bfef54">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_IS_VENDOR_DEFINED
-: <a class="el" href="group__crypto__types.html#gadbe4c086a6562aefe344bc79e51bdfd3">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_KEYPAIR_OF_PUBLIC_KEY
-: <a class="el" href="group__crypto__types.html#gaf09f1ca1de6a7e7cff0fe516f3f6c91d">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_NONE
-: <a class="el" href="group__crypto__types.html#gafce7ab2b54ce97ea5bff73f13a9f3e5b">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR
-: <a class="el" href="group__crypto__types.html#gace08e46dd7cbf642d50d982a25d02bec">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_RAW_DATA
-: <a class="el" href="group__crypto__types.html#gaa97f92025533102616b32d571c940d80">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_RSA_KEYPAIR
-: <a class="el" href="group__crypto__types.html#ga581f50687f5d650456925278948f2799">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_RSA_PUBLIC_KEY
-: <a class="el" href="group__crypto__types.html#ga9ba0878f56c8bcd1995ac017a74f513b">crypto_values.h</a>
-</li>
-<li>psa_key_type_t
-: <a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">crypto_types.h</a>
-</li>
-<li>PSA_KEY_TYPE_VENDOR_FLAG
-: <a class="el" href="group__crypto__types.html#ga8dbaed2fdb1ebae8aa127ad3988516f7">crypto_values.h</a>
-</li>
-<li>PSA_KEY_USAGE_DECRYPT
-: <a class="el" href="group__policy.html#gac3f2d2e5983db1edde9f142ca9bf8e6a">crypto_values.h</a>
-</li>
-<li>PSA_KEY_USAGE_DERIVE
-: <a class="el" href="group__policy.html#gaf19022acc5ef23cf12477f632b48a0b2">crypto_values.h</a>
-</li>
-<li>PSA_KEY_USAGE_ENCRYPT
-: <a class="el" href="group__policy.html#ga75153b296d045d529d97203a6a995dad">crypto_values.h</a>
-</li>
-<li>PSA_KEY_USAGE_EXPORT
-: <a class="el" href="group__policy.html#ga7dddccdd1303176e87a4d20c87b589ed">crypto_values.h</a>
-</li>
-<li>PSA_KEY_USAGE_SIGN
-: <a class="el" href="group__policy.html#ga99b9f456cf59efc4b5579465407aef5a">crypto_values.h</a>
-</li>
-<li>psa_key_usage_t
-: <a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">crypto_types.h</a>
-</li>
-<li>PSA_KEY_USAGE_VERIFY
-: <a class="el" href="group__policy.html#ga39b54ffd5958b69634607924fa53cea6">crypto_values.h</a>
-</li>
-<li>psa_mac_abort()
-: <a class="el" href="group__MAC.html#gacd8dd54855ba1bc0a03f104f252884fd">crypto.h</a>
-</li>
-<li>psa_mac_compute()
-: <a class="el" href="group__MAC.html#gace78d9b51394f9d4f77952963665897a">crypto.h</a>
-</li>
-<li>PSA_MAC_FINAL_SIZE
-: <a class="el" href="crypto__sizes_8h.html#aa84c5fb384ac7cb1bfc52adde96588ee">crypto_sizes.h</a>
-</li>
-<li>PSA_MAC_MAX_SIZE
-: <a class="el" href="crypto__sizes_8h.html#a4681cc4f6226883a2160122c562ca682">crypto_sizes.h</a>
-</li>
-<li>PSA_MAC_OPERATION_INIT
-: <a class="el" href="group__MAC.html#ga441b6efc161a4573d06465bd22d9dc2d">crypto.h</a>
-</li>
-<li>psa_mac_operation_t
-: <a class="el" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">crypto.h</a>
-</li>
-<li>psa_mac_sign_finish()
-: <a class="el" href="group__MAC.html#gac22bc0125580c96724a09226cfbc97f2">crypto.h</a>
-</li>
-<li>psa_mac_sign_setup()
-: <a class="el" href="group__MAC.html#gad33f2b15119593571ca6b8e7c757ab0e">crypto.h</a>
-</li>
-<li>PSA_MAC_TRUNCATED_LENGTH
-: <a class="el" href="group__crypto__types.html#gab03726c4476174e019a08e2a04018ce8">crypto_values.h</a>
-</li>
-<li>psa_mac_update()
-: <a class="el" href="group__MAC.html#ga5560af371497babefe03c9da4e8a1c05">crypto.h</a>
-</li>
-<li>psa_mac_verify()
-: <a class="el" href="group__MAC.html#ga08e2e8c21bfe762a907266f3bdd1d07c">crypto.h</a>
-</li>
-<li>psa_mac_verify_finish()
-: <a class="el" href="group__MAC.html#gac92b2930d6728e1be4d011c05d485822">crypto.h</a>
-</li>
-<li>psa_mac_verify_setup()
-: <a class="el" href="group__MAC.html#gaa721a59ae6d085ec90c7dc918879a027">crypto.h</a>
-</li>
-<li>PSA_MAX_BLOCK_CIPHER_BLOCK_SIZE
-: <a class="el" href="crypto__sizes_8h.html#aa3cfcff0291d6da279fec8fe834d5dec">crypto_sizes.h</a>
-</li>
-<li>psa_open_key()
-: <a class="el" href="group__key__management.html#gaa9f1c848cf78b80fe2a7b18bb7ccec50">crypto.h</a>
-</li>
-<li>psa_set_generator_capacity()
-: <a class="el" href="group__generators.html#ga45676ec3c719622f95caaf926f44bb6e">crypto.h</a>
-</li>
-<li>psa_set_key_domain_parameters()
-: <a class="el" href="group__import__export.html#ga091da8d3d39137fd6ad59f2b10234300">crypto.h</a>
-</li>
-<li>psa_set_key_policy()
-: <a class="el" href="group__policy.html#ga1e2a6e50b621864f95d438222a3c640b">crypto.h</a>
-</li>
-<li>psa_status_t
-: <a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">crypto_types.h</a>
-</li>
-<li>PSA_SUCCESS
-: <a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">crypto_values.h</a>
-</li>
-</ul>
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/globals_defs.html b/docs/html/globals_defs.html
deleted file mode 100644
index 3f4c571..0000000
--- a/docs/html/globals_defs.html
+++ /dev/null
@@ -1,551 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: File Members</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li class="current"><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
- <div id="navrow2" class="tabs2">
- <ul class="tablist">
- <li><a href="files.html"><span>File List</span></a></li>
- <li class="current"><a href="globals.html"><span>File Members</span></a></li>
- </ul>
- </div>
- <div id="navrow3" class="tabs2">
- <ul class="tablist">
- <li><a href="globals.html"><span>All</span></a></li>
- <li><a href="globals_func.html"><span>Functions</span></a></li>
- <li><a href="globals_type.html"><span>Typedefs</span></a></li>
- <li class="current"><a href="globals_defs.html"><span>Macros</span></a></li>
- </ul>
- </div>
- <div id="navrow4" class="tabs3">
- <ul class="tablist">
- <li class="current"><a href="#index_p"><span>p</span></a></li>
- </ul>
- </div>
-</div><!-- top -->
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div class="contents">
- 
-
-<h3><a class="anchor" id="index_p"></a>- p -</h3><ul>
-<li>PSA_AEAD_DECRYPT_OUTPUT_SIZE
-: <a class="el" href="crypto__sizes_8h.html#a1d057796166c16eb673ad1997e48a60b">crypto_sizes.h</a>
-</li>
-<li>PSA_AEAD_ENCRYPT_OUTPUT_SIZE
-: <a class="el" href="crypto__sizes_8h.html#a85667d47a7aa6c7b99a80e5273671266">crypto_sizes.h</a>
-</li>
-<li>PSA_AEAD_FINISH_OUTPUT_SIZE
-: <a class="el" href="crypto__sizes_8h.html#ab097f6e054f1a73e975d597ade9029a6">crypto_sizes.h</a>
-</li>
-<li>PSA_AEAD_OPERATION_INIT
-: <a class="el" href="group__aead.html#gaf52e036794c0dc6fbadd93a2b990f366">crypto.h</a>
-</li>
-<li>PSA_AEAD_TAG_LENGTH
-: <a class="el" href="crypto__sizes_8h.html#a8e3079b2e624cb8d32b94843cddada49">crypto_sizes.h</a>
-</li>
-<li>PSA_ALG_AEAD_WITH_DEFAULT_TAG_LENGTH
-: <a class="el" href="group__crypto__types.html#gaddea507e062250cda8a29407a9480d2b">crypto_values.h</a>
-</li>
-<li>PSA_ALG_AEAD_WITH_TAG_LENGTH
-: <a class="el" href="group__crypto__types.html#gaa63c520b62ab001d54d28801742fc9db">crypto_values.h</a>
-</li>
-<li>PSA_ALG_ANY_HASH
-: <a class="el" href="group__crypto__types.html#gaa1288ea8bd397a8a3f5e19e94110f2e4">crypto_values.h</a>
-</li>
-<li>PSA_ALG_ARC4
-: <a class="el" href="group__crypto__types.html#gab6a5284decb0e5e1b5b8740a41ef3c5e">crypto_values.h</a>
-</li>
-<li>PSA_ALG_CBC_NO_PADDING
-: <a class="el" href="group__crypto__types.html#gacb332d72716958880ee7f97d8365ae66">crypto_values.h</a>
-</li>
-<li>PSA_ALG_CBC_PKCS7
-: <a class="el" href="group__crypto__types.html#gaef50d2e9716eb6d476046608e4e0c78c">crypto_values.h</a>
-</li>
-<li>PSA_ALG_CCM
-: <a class="el" href="group__crypto__types.html#gac2c0e7d21f1b2df5e76bcb4a8f84273c">crypto_values.h</a>
-</li>
-<li>PSA_ALG_CTR
-: <a class="el" href="group__crypto__types.html#gad318309706a769cffdc64e4c7e06b2e9">crypto_values.h</a>
-</li>
-<li>PSA_ALG_DETERMINISTIC_DSA
-: <a class="el" href="group__crypto__types.html#gab8eb98fb6d2e094e47f3b44dfe128f94">crypto_values.h</a>
-</li>
-<li>PSA_ALG_DETERMINISTIC_ECDSA
-: <a class="el" href="group__crypto__types.html#ga11da566bcd341661c8de921e2ca5ed03">crypto_values.h</a>
-</li>
-<li>PSA_ALG_DSA
-: <a class="el" href="group__crypto__types.html#ga9a68efdddff5ae95f104a1416b12742e">crypto_values.h</a>
-</li>
-<li>PSA_ALG_ECDH
-: <a class="el" href="group__crypto__types.html#gab2dbcf71b63785e7dd7b54a100edee43">crypto_values.h</a>
-</li>
-<li>PSA_ALG_ECDSA
-: <a class="el" href="group__crypto__types.html#ga7e3ce9f514a227d5ba5d8318870452e3">crypto_values.h</a>
-</li>
-<li>PSA_ALG_ECDSA_ANY
-: <a class="el" href="group__crypto__types.html#ga51d6b6044a62e33cae0cf64bfc3b22a4">crypto_values.h</a>
-</li>
-<li>PSA_ALG_FFDH
-: <a class="el" href="group__crypto__types.html#ga0ebbb6f93a05b6511e6f108ffd2d1eb4">crypto_values.h</a>
-</li>
-<li>PSA_ALG_FULL_LENGTH_MAC
-: <a class="el" href="group__crypto__types.html#gaa05a8d99634f3350597ac9284fb70cb1">crypto_values.h</a>
-</li>
-<li>PSA_ALG_GCM
-: <a class="el" href="group__crypto__types.html#ga0d7d02b15aaae490d38277d99f1c637c">crypto_values.h</a>
-</li>
-<li>PSA_ALG_HKDF
-: <a class="el" href="group__crypto__types.html#ga32a888fb360e6e25cab8a343772c4a82">crypto_values.h</a>
-</li>
-<li>PSA_ALG_HMAC
-: <a class="el" href="group__crypto__types.html#ga70f397425684b3efcde1e0e34c28261f">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_AEAD
-: <a class="el" href="group__crypto__types.html#ga1d44829d60065eaa4ac9a703e7d6abc8">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_ASYMMETRIC_ENCRYPTION
-: <a class="el" href="group__crypto__types.html#ga41d2ee937d54efd76bd54a97b2ebc08a">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_BLOCK_CIPHER_MAC
-: <a class="el" href="group__crypto__types.html#gae49d1eb601125d65a5c5b252aa45479e">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_CIPHER
-: <a class="el" href="group__crypto__types.html#ga1d1a5a402ad89a2e68f12bfb535490eb">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_ECDH
-: <a class="el" href="group__crypto__types.html#ga9d9b6533d2a6bea7bac7ae01facb820d">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_FFDH
-: <a class="el" href="group__crypto__types.html#gaa3cf76164cd9375af4fb8a291078a19e">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_HASH
-: <a class="el" href="group__crypto__types.html#gac9280662bb482590b4b33d1dcd32930f">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_HASH_AND_SIGN
-: <a class="el" href="group__crypto__types.html#gad8a8ea0536975363b66410cdeafe38b6">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_HKDF
-: <a class="el" href="group__crypto__types.html#ga1979d0a76fcee6164cf2e65960f38db2">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_HMAC
-: <a class="el" href="group__crypto__types.html#ga4a050c3c3cbc6eb96418f18847601c8a">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_KEY_AGREEMENT
-: <a class="el" href="group__crypto__types.html#ga59753742cb06553bd22751bbef472b6f">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_KEY_DERIVATION
-: <a class="el" href="group__crypto__types.html#gaf8b90c648aa53dbd06c236695e300cd0">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_MAC
-: <a class="el" href="group__crypto__types.html#gaca7aee4c9dde316b3b1a150a26eab776">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_RAW_KEY_AGREEMENT
-: <a class="el" href="group__crypto__types.html#gaa40ab362ce141ce541d69b2eb1f41438">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_SIGN
-: <a class="el" href="group__crypto__types.html#ga6d490d0904e0698f6c1268a89d72ff31">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_STREAM_CIPHER
-: <a class="el" href="group__crypto__types.html#gacfec68e0c6175e02e1b2ebc97df383c0">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_TLS12_PRF
-: <a class="el" href="group__crypto__types.html#gaa3c18890c50222e5219f40ade8927e66">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_TLS12_PSK_TO_MS
-: <a class="el" href="group__crypto__types.html#gab25ecc074a93fd11069bedfbba5a287b">crypto_values.h</a>
-</li>
-<li>PSA_ALG_IS_WILDCARD
-: <a class="el" href="group__crypto__types.html#gacf83d7430e82b97cecb8b26ca6fa1426">crypto_values.h</a>
-</li>
-<li>PSA_ALG_KEY_AGREEMENT
-: <a class="el" href="group__crypto__types.html#ga78bb81cffb87a635c247725eeb2a2682">crypto_values.h</a>
-</li>
-<li>PSA_ALG_RSA_OAEP
-: <a class="el" href="group__crypto__types.html#gaa1235dc3fdd9839c6c1b1a9857344c76">crypto_values.h</a>
-</li>
-<li>PSA_ALG_RSA_PKCS1V15_CRYPT
-: <a class="el" href="group__crypto__types.html#ga4c540d3abe43fb9abcb94f2bc51acef9">crypto_values.h</a>
-</li>
-<li>PSA_ALG_RSA_PKCS1V15_SIGN
-: <a class="el" href="group__crypto__types.html#ga702ff75385a6ae7d4247033f479439af">crypto_values.h</a>
-</li>
-<li>PSA_ALG_RSA_PKCS1V15_SIGN_RAW
-: <a class="el" href="group__crypto__types.html#ga4215e2a78dcf834e9a625927faa2a817">crypto_values.h</a>
-</li>
-<li>PSA_ALG_RSA_PSS
-: <a class="el" href="group__crypto__types.html#ga62152bf4cb4bf6aace5e1be8f143564d">crypto_values.h</a>
-</li>
-<li>PSA_ALG_SHA3_224
-: <a class="el" href="group__crypto__types.html#ga16f5fe34ccce68c2fada1224c054a999">crypto_values.h</a>
-</li>
-<li>PSA_ALG_SHA3_256
-: <a class="el" href="group__crypto__types.html#gaace70d9515489bbe3c5e7ac1b7d9155b">crypto_values.h</a>
-</li>
-<li>PSA_ALG_SHA3_384
-: <a class="el" href="group__crypto__types.html#gab0f079257ea75e2acfe2fc3b38c78cd8">crypto_values.h</a>
-</li>
-<li>PSA_ALG_SHA3_512
-: <a class="el" href="group__crypto__types.html#ga37e5dbe936dddb155e76f2997de27188">crypto_values.h</a>
-</li>
-<li>PSA_ALG_SHA_224
-: <a class="el" href="group__crypto__types.html#ga25d6a3244d10a7148fe6b026d1979f7b">crypto_values.h</a>
-</li>
-<li>PSA_ALG_SHA_256
-: <a class="el" href="group__crypto__types.html#ga619471f978e13cdd0a1e37145e4bf341">crypto_values.h</a>
-</li>
-<li>PSA_ALG_SHA_384
-: <a class="el" href="group__crypto__types.html#ga58af64dd9a86a287e8da9ed7739eead4">crypto_values.h</a>
-</li>
-<li>PSA_ALG_SHA_512
-: <a class="el" href="group__crypto__types.html#gafba3ae409f46d3dd7f37a0910660c3e9">crypto_values.h</a>
-</li>
-<li>PSA_ALG_SHA_512_224
-: <a class="el" href="group__crypto__types.html#ga3fe2d7c3c80e3186ca78d16a35d5d931">crypto_values.h</a>
-</li>
-<li>PSA_ALG_SHA_512_256
-: <a class="el" href="group__crypto__types.html#ga5910b3964c14e9613e8643a45b09c2d4">crypto_values.h</a>
-</li>
-<li>PSA_ALG_SIGN_GET_HASH
-: <a class="el" href="group__crypto__types.html#ga24cf6d7bcd2b9aeeeff86f07b6c674e3">crypto_values.h</a>
-</li>
-<li>PSA_ALG_TLS12_PRF
-: <a class="el" href="group__crypto__types.html#ga6d5623c2ccda1d4a84e34351af8382d5">crypto_values.h</a>
-</li>
-<li>PSA_ALG_TLS12_PSK_TO_MS
-: <a class="el" href="group__crypto__types.html#ga039ec797f15d1635d9b2e09a611f8a68">crypto_values.h</a>
-</li>
-<li>PSA_ALG_TLS12_PSK_TO_MS_MAX_PSK_LEN
-: <a class="el" href="crypto__sizes_8h.html#ab589ea3b86f2bfa18880459299c58f8a">crypto_sizes.h</a>
-</li>
-<li>PSA_ALG_TRUNCATED_MAC
-: <a class="el" href="group__crypto__types.html#gaf36137110baf7bb13c5028fd62c64276">crypto_values.h</a>
-</li>
-<li>PSA_ALG_XTS
-: <a class="el" href="group__crypto__types.html#gaa722c0e426a797fd6d99623f59748125">crypto_values.h</a>
-</li>
-<li>PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE
-: <a class="el" href="crypto__sizes_8h.html#a61a246f3eac41989821d982e56fea6c1">crypto_sizes.h</a>
-</li>
-<li>PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE
-: <a class="el" href="crypto__sizes_8h.html#a66ba3bd93e5ec52870ccc3848778bad8">crypto_sizes.h</a>
-</li>
-<li>PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE
-: <a class="el" href="crypto__sizes_8h.html#a77565b9b4fe6d8730fd2120f4c8378ab">crypto_sizes.h</a>
-</li>
-<li>PSA_ASYMMETRIC_SIGNATURE_MAX_SIZE
-: <a class="el" href="crypto__sizes_8h.html#ad755101764dba14589e5919ee41be7ca">crypto_sizes.h</a>
-</li>
-<li>PSA_BLOCK_CIPHER_BLOCK_SIZE
-: <a class="el" href="group__crypto__types.html#gacaa366bdeb0413e63e87a667c5457b2e">crypto_values.h</a>
-</li>
-<li>PSA_CIPHER_OPERATION_INIT
-: <a class="el" href="group__cipher.html#ga2da0541aabf9a4995cf2004e36311919">crypto.h</a>
-</li>
-<li>PSA_CRYPTO_GENERATOR_INIT
-: <a class="el" href="group__generators.html#ga4788b471385fc667876fbd8a0d3fe062">crypto.h</a>
-</li>
-<li>PSA_ECDSA_SIGNATURE_SIZE
-: <a class="el" href="crypto__sizes_8h.html#a10c472a35f04051add6b20cc228ffc11">crypto_sizes.h</a>
-</li>
-<li>PSA_ERROR_BAD_STATE
-: <a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_BUFFER_TOO_SMALL
-: <a class="el" href="group__error.html#ga695025f4ec11249aee7ea3d0f65e01c8">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_COMMUNICATION_FAILURE
-: <a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_EMPTY_SLOT
-: <a class="el" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_HARDWARE_FAILURE
-: <a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_INSUFFICIENT_CAPACITY
-: <a class="el" href="group__error.html#gaf1fa61f72e9e5b4a848c991bea495767">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_INSUFFICIENT_ENTROPY
-: <a class="el" href="group__error.html#ga4deb59fec02297ec5d8b42178323f675">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_INSUFFICIENT_MEMORY
-: <a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_INSUFFICIENT_STORAGE
-: <a class="el" href="group__error.html#ga897a45eb206a6f6b7be7ffbe36f0d766">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_INVALID_ARGUMENT
-: <a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_INVALID_HANDLE
-: <a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_INVALID_PADDING
-: <a class="el" href="group__error.html#gabe29594edbfb152cf153975b0597ac48">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_INVALID_SIGNATURE
-: <a class="el" href="group__error.html#ga35927f755d232c4766de600f2c49e9f2">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_NOT_PERMITTED
-: <a class="el" href="group__error.html#ga4d1b8dd8526177a15a210b7afc1accb1">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_NOT_SUPPORTED
-: <a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_OCCUPIED_SLOT
-: <a class="el" href="group__error.html#gac2fee3a51249fbea45360aaa911f3e58">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_STORAGE_FAILURE
-: <a class="el" href="group__error.html#gadd169a1af2707862b95fb9df91dfc37d">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_TAMPERING_DETECTED
-: <a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">crypto_values.h</a>
-</li>
-<li>PSA_ERROR_UNKNOWN_ERROR
-: <a class="el" href="group__error.html#ga24d5fdcdd759f846f79d9e581c63a83f">crypto_values.h</a>
-</li>
-<li>PSA_GENERATOR_UNBRIDLED_CAPACITY
-: <a class="el" href="group__generators.html#gac3222df9b9ecca4d33ae56a7b8fbb1c9">crypto.h</a>
-</li>
-<li>PSA_HASH_MAX_SIZE
-: <a class="el" href="crypto__sizes_8h.html#a6ce1014efbbc0bcca286ef7f9a72cb29">crypto_sizes.h</a>
-</li>
-<li>PSA_HASH_OPERATION_INIT
-: <a class="el" href="group__hash.html#ga6ab7fe8d3500bc2f21be840b4f4f8d1d">crypto.h</a>
-</li>
-<li>PSA_HASH_SIZE
-: <a class="el" href="crypto__sizes_8h.html#aef340331ce3cba2b57e1fc5624bf1f99">crypto_sizes.h</a>
-</li>
-<li>PSA_KDF_STEP_INFO
-: <a class="el" href="group__derivation.html#ga836afe760bbda3dafc6c29631560b1a0">crypto_values.h</a>
-</li>
-<li>PSA_KDF_STEP_LABEL
-: <a class="el" href="group__derivation.html#ga9f4da10191bcb690b88756ed8470b03c">crypto_values.h</a>
-</li>
-<li>PSA_KDF_STEP_SALT
-: <a class="el" href="group__derivation.html#ga384777dac55791d8f3a1af72c847b327">crypto_values.h</a>
-</li>
-<li>PSA_KDF_STEP_SECRET
-: <a class="el" href="group__derivation.html#ga90a1995a41e26ed5ca30d2d4641d1168">crypto_values.h</a>
-</li>
-<li>PSA_KEY_EXPORT_MAX_SIZE
-: <a class="el" href="crypto__sizes_8h.html#a0aae885cc8ff92e00fb5248420b939c3">crypto_sizes.h</a>
-</li>
-<li>PSA_KEY_LIFETIME_PERSISTENT
-: <a class="el" href="group__key__lifetimes.html#ga3713a01c5fcd5f7eae46ff22ceaf6d02">crypto_values.h</a>
-</li>
-<li>PSA_KEY_LIFETIME_VOLATILE
-: <a class="el" href="group__key__lifetimes.html#ga8b438870ba69489b685730d346455108">crypto_values.h</a>
-</li>
-<li>PSA_KEY_POLICY_INIT
-: <a class="el" href="group__policy.html#ga5e6bc5f550e88fdc7790f2a75e79f7c5">crypto.h</a>
-</li>
-<li>PSA_KEY_TYPE_AES
-: <a class="el" href="group__crypto__types.html#ga6ee54579dcf278c677eda4bb1a29575e">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_ARC4
-: <a class="el" href="group__crypto__types.html#gae4d46e83f910dcaa126000a8ed03cde9">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_CAMELLIA
-: <a class="el" href="group__crypto__types.html#gad8e5da742343fd5519f9d8a630c2ed81">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_DERIVE
-: <a class="el" href="group__crypto__types.html#gae871b2357b8593f33bfd51abbf93ebb1">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_DES
-: <a class="el" href="group__crypto__types.html#ga577562bfbbc691c820d55ec308333138">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_DH_KEYPAIR
-: <a class="el" href="group__crypto__types.html#ga39b63c6b97a62a316c0660bf72b2fdd5">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_DH_PUBLIC_KEY
-: <a class="el" href="group__crypto__types.html#ga325a340d7c72d99d3a678eb210bf6e0a">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_DSA_KEYPAIR
-: <a class="el" href="group__crypto__types.html#ga011010ee28c20388f3d89fb27088ed62">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_DSA_PUBLIC_KEY
-: <a class="el" href="group__crypto__types.html#ga5e7439c2905136366c3a876e62e5ddfc">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_ECC_KEYPAIR
-: <a class="el" href="group__crypto__types.html#gadf3ad65d157bf5282849c954bf3f51af">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_ECC_PUBLIC_KEY
-: <a class="el" href="group__crypto__types.html#gad54c03d3b47020e571a72cd01d978cf2">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_GET_CURVE
-: <a class="el" href="group__crypto__types.html#ga0c567210e6f80aa8f2aa87efa7a3a3f9">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_HMAC
-: <a class="el" href="group__crypto__types.html#ga92d989f4ca64abd00f463defd773a6f8">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_IS_ASYMMETRIC
-: <a class="el" href="group__crypto__types.html#gab138ae2ebf2905dfbaf4154db2620939">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_IS_DH
-: <a class="el" href="group__crypto__types.html#ga248ae35c0e2becaebbf479fc1c3a3b0e">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_IS_DSA
-: <a class="el" href="group__crypto__types.html#ga273fdfcf23eb0624f8b63d2321cf95c1">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_IS_ECC
-: <a class="el" href="group__crypto__types.html#ga88e01fa06b585654689a99bcc06bbe66">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_IS_ECC_KEYPAIR
-: <a class="el" href="group__crypto__types.html#ga7bf101b671e8cf26f4cb08fcb679db4b">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY
-: <a class="el" href="group__crypto__types.html#ga5af146a173b0c84d7e737e2fb6a3c0a7">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_IS_KEYPAIR
-: <a class="el" href="group__crypto__types.html#gac14c6d6e1b2b7f4a92a7b757465cff29">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_IS_PUBLIC_KEY
-: <a class="el" href="group__crypto__types.html#gac674a0f059bc0cb72b47f0c517b4f45b">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_IS_RSA
-: <a class="el" href="group__crypto__types.html#ga0e1d8f241228e49c9cadadfb4579ef1a">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_IS_UNSTRUCTURED
-: <a class="el" href="group__crypto__types.html#gaef86ce4e810e1c2c76068ac874bfef54">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_IS_VENDOR_DEFINED
-: <a class="el" href="group__crypto__types.html#gadbe4c086a6562aefe344bc79e51bdfd3">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_KEYPAIR_OF_PUBLIC_KEY
-: <a class="el" href="group__crypto__types.html#gaf09f1ca1de6a7e7cff0fe516f3f6c91d">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_NONE
-: <a class="el" href="group__crypto__types.html#gafce7ab2b54ce97ea5bff73f13a9f3e5b">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR
-: <a class="el" href="group__crypto__types.html#gace08e46dd7cbf642d50d982a25d02bec">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_RAW_DATA
-: <a class="el" href="group__crypto__types.html#gaa97f92025533102616b32d571c940d80">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_RSA_KEYPAIR
-: <a class="el" href="group__crypto__types.html#ga581f50687f5d650456925278948f2799">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_RSA_PUBLIC_KEY
-: <a class="el" href="group__crypto__types.html#ga9ba0878f56c8bcd1995ac017a74f513b">crypto_values.h</a>
-</li>
-<li>PSA_KEY_TYPE_VENDOR_FLAG
-: <a class="el" href="group__crypto__types.html#ga8dbaed2fdb1ebae8aa127ad3988516f7">crypto_values.h</a>
-</li>
-<li>PSA_KEY_USAGE_DECRYPT
-: <a class="el" href="group__policy.html#gac3f2d2e5983db1edde9f142ca9bf8e6a">crypto_values.h</a>
-</li>
-<li>PSA_KEY_USAGE_DERIVE
-: <a class="el" href="group__policy.html#gaf19022acc5ef23cf12477f632b48a0b2">crypto_values.h</a>
-</li>
-<li>PSA_KEY_USAGE_ENCRYPT
-: <a class="el" href="group__policy.html#ga75153b296d045d529d97203a6a995dad">crypto_values.h</a>
-</li>
-<li>PSA_KEY_USAGE_EXPORT
-: <a class="el" href="group__policy.html#ga7dddccdd1303176e87a4d20c87b589ed">crypto_values.h</a>
-</li>
-<li>PSA_KEY_USAGE_SIGN
-: <a class="el" href="group__policy.html#ga99b9f456cf59efc4b5579465407aef5a">crypto_values.h</a>
-</li>
-<li>PSA_KEY_USAGE_VERIFY
-: <a class="el" href="group__policy.html#ga39b54ffd5958b69634607924fa53cea6">crypto_values.h</a>
-</li>
-<li>PSA_MAC_FINAL_SIZE
-: <a class="el" href="crypto__sizes_8h.html#aa84c5fb384ac7cb1bfc52adde96588ee">crypto_sizes.h</a>
-</li>
-<li>PSA_MAC_MAX_SIZE
-: <a class="el" href="crypto__sizes_8h.html#a4681cc4f6226883a2160122c562ca682">crypto_sizes.h</a>
-</li>
-<li>PSA_MAC_OPERATION_INIT
-: <a class="el" href="group__MAC.html#ga441b6efc161a4573d06465bd22d9dc2d">crypto.h</a>
-</li>
-<li>PSA_MAC_TRUNCATED_LENGTH
-: <a class="el" href="group__crypto__types.html#gab03726c4476174e019a08e2a04018ce8">crypto_values.h</a>
-</li>
-<li>PSA_MAX_BLOCK_CIPHER_BLOCK_SIZE
-: <a class="el" href="crypto__sizes_8h.html#aa3cfcff0291d6da279fec8fe834d5dec">crypto_sizes.h</a>
-</li>
-<li>PSA_SUCCESS
-: <a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">crypto_values.h</a>
-</li>
-</ul>
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/globals_func.html b/docs/html/globals_func.html
deleted file mode 100644
index 1413d25..0000000
--- a/docs/html/globals_func.html
+++ /dev/null
@@ -1,326 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: File Members</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li class="current"><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
- <div id="navrow2" class="tabs2">
- <ul class="tablist">
- <li><a href="files.html"><span>File List</span></a></li>
- <li class="current"><a href="globals.html"><span>File Members</span></a></li>
- </ul>
- </div>
- <div id="navrow3" class="tabs2">
- <ul class="tablist">
- <li><a href="globals.html"><span>All</span></a></li>
- <li class="current"><a href="globals_func.html"><span>Functions</span></a></li>
- <li><a href="globals_type.html"><span>Typedefs</span></a></li>
- <li><a href="globals_defs.html"><span>Macros</span></a></li>
- </ul>
- </div>
- <div id="navrow4" class="tabs3">
- <ul class="tablist">
- <li class="current"><a href="#index_p"><span>p</span></a></li>
- </ul>
- </div>
-</div><!-- top -->
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div class="contents">
- 
-
-<h3><a class="anchor" id="index_p"></a>- p -</h3><ul>
-<li>psa_aead_abort()
-: <a class="el" href="group__aead.html#gae8a5f93d92318c8f592ee9fbb9d36ba0">crypto.h</a>
-</li>
-<li>psa_aead_decrypt()
-: <a class="el" href="group__aead.html#gaa8ce6527f2e227f1071fadbf2099793b">crypto.h</a>
-</li>
-<li>psa_aead_decrypt_setup()
-: <a class="el" href="group__aead.html#ga439896519d4a367ec86b47f201884152">crypto.h</a>
-</li>
-<li>psa_aead_encrypt()
-: <a class="el" href="group__aead.html#ga44de092cf58bb6c820c5c80a6c51610d">crypto.h</a>
-</li>
-<li>psa_aead_encrypt_setup()
-: <a class="el" href="group__aead.html#ga47265dc4852f1476f852752218fd12b2">crypto.h</a>
-</li>
-<li>psa_aead_finish()
-: <a class="el" href="group__aead.html#ga759791bbe1763b377c3b5447641f1fc8">crypto.h</a>
-</li>
-<li>psa_aead_generate_nonce()
-: <a class="el" href="group__aead.html#ga3eadcf2a29f662129ea4fb3454969ba2">crypto.h</a>
-</li>
-<li>psa_aead_set_lengths()
-: <a class="el" href="group__aead.html#gad3431e28d05002c2a7b0760610176050">crypto.h</a>
-</li>
-<li>psa_aead_set_nonce()
-: <a class="el" href="group__aead.html#ga40641d0721ca7fe01bbcd9ef635fbc46">crypto.h</a>
-</li>
-<li>psa_aead_update()
-: <a class="el" href="group__aead.html#ga3b105de2088cef7c3d9e2fd8048c841c">crypto.h</a>
-</li>
-<li>psa_aead_update_ad()
-: <a class="el" href="group__aead.html#ga6d0eed03f832e5c9c91cb8adf2882569">crypto.h</a>
-</li>
-<li>psa_aead_verify()
-: <a class="el" href="group__aead.html#gaaed211fc61977c859d6ff07f39f59219">crypto.h</a>
-</li>
-<li>psa_allocate_key()
-: <a class="el" href="group__key__management.html#ga40094b77b7a42b9c8e158395113f1a35">crypto.h</a>
-</li>
-<li>psa_asymmetric_decrypt()
-: <a class="el" href="group__asymmetric.html#ga34b55fbaee23dba1a677186fc66a556e">crypto.h</a>
-</li>
-<li>psa_asymmetric_encrypt()
-: <a class="el" href="group__asymmetric.html#gad429293b7b0bf2a830b9540a02552004">crypto.h</a>
-</li>
-<li>psa_asymmetric_sign()
-: <a class="el" href="group__asymmetric.html#ga1b0db9d345b5048cdd39357ac2d56c07">crypto.h</a>
-</li>
-<li>psa_asymmetric_verify()
-: <a class="el" href="group__asymmetric.html#ga1b8e964c8d927e3d632325d762959eb7">crypto.h</a>
-</li>
-<li>psa_cipher_abort()
-: <a class="el" href="group__cipher.html#gaad482cdca2098bca0620596aaa02eaa4">crypto.h</a>
-</li>
-<li>psa_cipher_decrypt()
-: <a class="el" href="group__cipher.html#ga43d5991711ec45c98af0c1d99f6e0216">crypto.h</a>
-</li>
-<li>psa_cipher_decrypt_setup()
-: <a class="el" href="group__cipher.html#gaddf8504e5367cd0efb4415bdec004f44">crypto.h</a>
-</li>
-<li>psa_cipher_encrypt()
-: <a class="el" href="group__cipher.html#gac76dda492d9a1ba6b327bff610ec17b2">crypto.h</a>
-</li>
-<li>psa_cipher_encrypt_setup()
-: <a class="el" href="group__cipher.html#ga2a7fc79a9d150d42dba99f40ee3a185e">crypto.h</a>
-</li>
-<li>psa_cipher_finish()
-: <a class="el" href="group__cipher.html#ga1dcb58b8befe23f8a4d7a1d49c99249b">crypto.h</a>
-</li>
-<li>psa_cipher_generate_iv()
-: <a class="el" href="group__cipher.html#ga44857cf5e0c3d134a3c560f8ff5b50aa">crypto.h</a>
-</li>
-<li>psa_cipher_set_iv()
-: <a class="el" href="group__cipher.html#ga1359b2101f31637496ce7cc36c6e3d42">crypto.h</a>
-</li>
-<li>psa_cipher_update()
-: <a class="el" href="group__cipher.html#gafd0caea99cf1052527e4089d37f5ab91">crypto.h</a>
-</li>
-<li>psa_close_key()
-: <a class="el" href="group__key__management.html#gaa09b720d299dfe6b9f41c36e448078eb">crypto.h</a>
-</li>
-<li>psa_copy_key()
-: <a class="el" href="group__import__export.html#ga5c1c24176cfb1517a8806235b3162a9d">crypto.h</a>
-</li>
-<li>psa_create_key()
-: <a class="el" href="group__key__management.html#ga4108f255d3eaa6d23a7a14b684af8d7c">crypto.h</a>
-</li>
-<li>psa_crypto_init()
-: <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9">crypto.h</a>
-</li>
-<li>psa_destroy_key()
-: <a class="el" href="group__import__export.html#ga165085fc1bc7a78b91792fdd94ae102c">crypto.h</a>
-</li>
-<li>psa_export_key()
-: <a class="el" href="group__import__export.html#ga902b9a7a6cf34d6111668be777b05eaf">crypto.h</a>
-</li>
-<li>psa_export_public_key()
-: <a class="el" href="group__import__export.html#gad760d1f0d4e60972c78cbb4c8a528256">crypto.h</a>
-</li>
-<li>psa_generate_key()
-: <a class="el" href="group__random.html#ga72921520494b4f007a3afb904cd9ecdd">crypto.h</a>
-</li>
-<li>psa_generate_random()
-: <a class="el" href="group__random.html#ga1985eae417dfbccedf50d5fff54ea8c5">crypto.h</a>
-</li>
-<li>psa_generator_abort()
-: <a class="el" href="group__generators.html#ga563ca64537d90368899286b36d8cf7f3">crypto.h</a>
-</li>
-<li>psa_generator_import_key()
-: <a class="el" href="group__generators.html#ga7fcdf07cd37279ca167db484053da894">crypto.h</a>
-</li>
-<li>psa_generator_read()
-: <a class="el" href="group__generators.html#gab5712ad29b78c2b170e64cc5bcfc1bce">crypto.h</a>
-</li>
-<li>psa_get_generator_capacity()
-: <a class="el" href="group__generators.html#ga7453491e3b440193be2c5dccc2040fd2">crypto.h</a>
-</li>
-<li>psa_get_key_domain_parameters()
-: <a class="el" href="group__import__export.html#gae260b92e32ac5d63f7dfc6ffdf6536f7">crypto.h</a>
-</li>
-<li>psa_get_key_information()
-: <a class="el" href="group__import__export.html#gae8939902d6977ea8ad13eb7b4db9a042">crypto.h</a>
-</li>
-<li>psa_get_key_lifetime()
-: <a class="el" href="group__key__management.html#ga1e4825ab59260aeb3bdbb3ff07210022">crypto.h</a>
-</li>
-<li>psa_get_key_policy()
-: <a class="el" href="group__policy.html#gaed087d1386b807edee66b2e445ba9111">crypto.h</a>
-</li>
-<li>psa_hash_abort()
-: <a class="el" href="group__hash.html#gab0b4d5f9912a615559497a467b532928">crypto.h</a>
-</li>
-<li>psa_hash_clone()
-: <a class="el" href="group__hash.html#ga39673348f3302b4646bd780034a5aeda">crypto.h</a>
-</li>
-<li>psa_hash_compare()
-: <a class="el" href="group__hash.html#ga0bb6dbd3c310648c3cf7d202413ff0bc">crypto.h</a>
-</li>
-<li>psa_hash_compute()
-: <a class="el" href="group__hash.html#gac69f7f19d96a56c28cf3799d11b12156">crypto.h</a>
-</li>
-<li>psa_hash_finish()
-: <a class="el" href="group__hash.html#ga4795fd06a0067b0adcd92e9627b8c97e">crypto.h</a>
-</li>
-<li>psa_hash_setup()
-: <a class="el" href="group__hash.html#ga8d72896cf70fc4d514c5c6b978912515">crypto.h</a>
-</li>
-<li>psa_hash_update()
-: <a class="el" href="group__hash.html#ga65b16ef97d7f650899b7db4b7d1112ff">crypto.h</a>
-</li>
-<li>psa_hash_verify()
-: <a class="el" href="group__hash.html#ga7be923c5700c9c70ef77ee9b76d1a5c0">crypto.h</a>
-</li>
-<li>psa_import_key()
-: <a class="el" href="group__import__export.html#gac9f999cb4d098663d56095afe81a453a">crypto.h</a>
-</li>
-<li>psa_key_agreement()
-: <a class="el" href="group__derivation.html#ga2c7fe304cacc141ffb91553548abc5d2">crypto.h</a>
-</li>
-<li>psa_key_agreement_raw_shared_secret()
-: <a class="el" href="group__derivation.html#gaf1b12eff66a1a0020b5bdc8d0e910006">crypto.h</a>
-</li>
-<li>psa_key_derivation_input_bytes()
-: <a class="el" href="group__derivation.html#ga1b30e888db65c71f5337900848e1b03f">crypto.h</a>
-</li>
-<li>psa_key_derivation_input_key()
-: <a class="el" href="group__derivation.html#ga9e5f549aa1f6f3863a07008d3d98f91a">crypto.h</a>
-</li>
-<li>psa_key_derivation_setup()
-: <a class="el" href="group__derivation.html#ga1825696be813dfac2b8d3d02717e71c5">crypto.h</a>
-</li>
-<li>psa_key_policy_get_algorithm()
-: <a class="el" href="group__policy.html#gaadf16b89ace53e1d2cb5bcb0aef24c86">crypto.h</a>
-</li>
-<li>psa_key_policy_get_usage()
-: <a class="el" href="group__policy.html#ga7746662b7503e484774d0ecb5d8ac2ab">crypto.h</a>
-</li>
-<li>psa_key_policy_set_usage()
-: <a class="el" href="group__policy.html#gac16792fd6d375a5f76d372090df40607">crypto.h</a>
-</li>
-<li>psa_mac_abort()
-: <a class="el" href="group__MAC.html#gacd8dd54855ba1bc0a03f104f252884fd">crypto.h</a>
-</li>
-<li>psa_mac_compute()
-: <a class="el" href="group__MAC.html#gace78d9b51394f9d4f77952963665897a">crypto.h</a>
-</li>
-<li>psa_mac_sign_finish()
-: <a class="el" href="group__MAC.html#gac22bc0125580c96724a09226cfbc97f2">crypto.h</a>
-</li>
-<li>psa_mac_sign_setup()
-: <a class="el" href="group__MAC.html#gad33f2b15119593571ca6b8e7c757ab0e">crypto.h</a>
-</li>
-<li>psa_mac_update()
-: <a class="el" href="group__MAC.html#ga5560af371497babefe03c9da4e8a1c05">crypto.h</a>
-</li>
-<li>psa_mac_verify()
-: <a class="el" href="group__MAC.html#ga08e2e8c21bfe762a907266f3bdd1d07c">crypto.h</a>
-</li>
-<li>psa_mac_verify_finish()
-: <a class="el" href="group__MAC.html#gac92b2930d6728e1be4d011c05d485822">crypto.h</a>
-</li>
-<li>psa_mac_verify_setup()
-: <a class="el" href="group__MAC.html#gaa721a59ae6d085ec90c7dc918879a027">crypto.h</a>
-</li>
-<li>psa_open_key()
-: <a class="el" href="group__key__management.html#gaa9f1c848cf78b80fe2a7b18bb7ccec50">crypto.h</a>
-</li>
-<li>psa_set_generator_capacity()
-: <a class="el" href="group__generators.html#ga45676ec3c719622f95caaf926f44bb6e">crypto.h</a>
-</li>
-<li>psa_set_key_domain_parameters()
-: <a class="el" href="group__import__export.html#ga091da8d3d39137fd6ad59f2b10234300">crypto.h</a>
-</li>
-<li>psa_set_key_policy()
-: <a class="el" href="group__policy.html#ga1e2a6e50b621864f95d438222a3c640b">crypto.h</a>
-</li>
-</ul>
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/globals_type.html b/docs/html/globals_type.html
deleted file mode 100644
index 83d5c82..0000000
--- a/docs/html/globals_type.html
+++ /dev/null
@@ -1,148 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: File Members</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li class="current"><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
- <div id="navrow2" class="tabs2">
- <ul class="tablist">
- <li><a href="files.html"><span>File List</span></a></li>
- <li class="current"><a href="globals.html"><span>File Members</span></a></li>
- </ul>
- </div>
- <div id="navrow3" class="tabs2">
- <ul class="tablist">
- <li><a href="globals.html"><span>All</span></a></li>
- <li><a href="globals_func.html"><span>Functions</span></a></li>
- <li class="current"><a href="globals_type.html"><span>Typedefs</span></a></li>
- <li><a href="globals_defs.html"><span>Macros</span></a></li>
- </ul>
- </div>
-</div><!-- top -->
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div class="contents">
- <ul>
-<li>psa_aead_operation_t
-: <a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">crypto.h</a>
-</li>
-<li>psa_algorithm_t
-: <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">crypto_types.h</a>
-</li>
-<li>psa_cipher_operation_t
-: <a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">crypto.h</a>
-</li>
-<li>psa_crypto_generator_t
-: <a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">crypto.h</a>
-</li>
-<li>psa_ecc_curve_t
-: <a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">crypto_types.h</a>
-</li>
-<li>psa_hash_operation_t
-: <a class="el" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">crypto.h</a>
-</li>
-<li>psa_key_derivation_step_t
-: <a class="el" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">crypto_types.h</a>
-</li>
-<li>psa_key_handle_t
-: <a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">crypto.h</a>
-</li>
-<li>psa_key_id_t
-: <a class="el" href="group__key__lifetimes.html#ga11e986351c65bd3dc3c0fe2cd9926e4b">crypto_types.h</a>
-</li>
-<li>psa_key_lifetime_t
-: <a class="el" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">crypto_types.h</a>
-</li>
-<li>psa_key_policy_t
-: <a class="el" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">crypto.h</a>
-</li>
-<li>psa_key_type_t
-: <a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">crypto_types.h</a>
-</li>
-<li>psa_key_usage_t
-: <a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">crypto_types.h</a>
-</li>
-<li>psa_mac_operation_t
-: <a class="el" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">crypto.h</a>
-</li>
-<li>psa_status_t
-: <a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">crypto_types.h</a>
-</li>
-</ul>
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/graph_legend.html b/docs/html/graph_legend.html
deleted file mode 100644
index 8e69841..0000000
--- a/docs/html/graph_legend.html
+++ /dev/null
@@ -1,120 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: Graph Legend</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
-</div><!-- top -->
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div class="header">
- <div class="headertitle">
-<div class="title">Graph Legend</div> </div>
-</div><!--header-->
-<div class="contents">
-<p>This page explains how to interpret the graphs that are generated by doxygen.</p>
-<p>Consider the following example: </p><div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> /*! Invisible class because of truncation */</div><div class="line"><a name="l00002"></a><span class="lineno"> 2</span> class Invisible { };</div><div class="line"><a name="l00003"></a><span class="lineno"> 3</span> </div><div class="line"><a name="l00004"></a><span class="lineno"> 4</span> /*! Truncated class, inheritance relation is hidden */</div><div class="line"><a name="l00005"></a><span class="lineno"> 5</span> class Truncated : public Invisible { };</div><div class="line"><a name="l00006"></a><span class="lineno"> 6</span> </div><div class="line"><a name="l00007"></a><span class="lineno"> 7</span> /* Class not documented with doxygen comments */</div><div class="line"><a name="l00008"></a><span class="lineno"> 8</span> class Undocumented { };</div><div class="line"><a name="l00009"></a><span class="lineno"> 9</span> </div><div class="line"><a name="l00010"></a><span class="lineno"> 10</span> /*! Class that is inherited using public inheritance */</div><div class="line"><a name="l00011"></a><span class="lineno"> 11</span> class PublicBase : public Truncated { };</div><div class="line"><a name="l00012"></a><span class="lineno"> 12</span> </div><div class="line"><a name="l00013"></a><span class="lineno"> 13</span> /*! A template class */</div><div class="line"><a name="l00014"></a><span class="lineno"> 14</span> template<class T> class Templ { };</div><div class="line"><a name="l00015"></a><span class="lineno"> 15</span> </div><div class="line"><a name="l00016"></a><span class="lineno"> 16</span> /*! Class that is inherited using protected inheritance */</div><div class="line"><a name="l00017"></a><span class="lineno"> 17</span> class ProtectedBase { };</div><div class="line"><a name="l00018"></a><span class="lineno"> 18</span> </div><div class="line"><a name="l00019"></a><span class="lineno"> 19</span> /*! Class that is inherited using private inheritance */</div><div class="line"><a name="l00020"></a><span class="lineno"> 20</span> class PrivateBase { };</div><div class="line"><a name="l00021"></a><span class="lineno"> 21</span> </div><div class="line"><a name="l00022"></a><span class="lineno"> 22</span> /*! Class that is used by the Inherited class */</div><div class="line"><a name="l00023"></a><span class="lineno"> 23</span> class Used { };</div><div class="line"><a name="l00024"></a><span class="lineno"> 24</span> </div><div class="line"><a name="l00025"></a><span class="lineno"> 25</span> /*! Super class that inherits a number of other classes */</div><div class="line"><a name="l00026"></a><span class="lineno"> 26</span> class Inherited : public PublicBase,</div><div class="line"><a name="l00027"></a><span class="lineno"> 27</span>  protected ProtectedBase,</div><div class="line"><a name="l00028"></a><span class="lineno"> 28</span>  private PrivateBase,</div><div class="line"><a name="l00029"></a><span class="lineno"> 29</span>  public Undocumented,</div><div class="line"><a name="l00030"></a><span class="lineno"> 30</span>  public Templ<int></div><div class="line"><a name="l00031"></a><span class="lineno"> 31</span> {</div><div class="line"><a name="l00032"></a><span class="lineno"> 32</span>  private:</div><div class="line"><a name="l00033"></a><span class="lineno"> 33</span>  Used *m_usedClass;</div><div class="line"><a name="l00034"></a><span class="lineno"> 34</span> };</div></div><!-- fragment --><p> This will result in the following graph:</p>
-<center><div class="image">
-<img src="graph_legend.png" />
-</div>
-</center><p>The boxes in the above graph have the following meaning: </p>
-<ul>
-<li>
-A filled gray box represents the struct or class for which the graph is generated. </li>
-<li>
-A box with a black border denotes a documented struct or class. </li>
-<li>
-A box with a gray border denotes an undocumented struct or class. </li>
-<li>
-A box with a red border denotes a documented struct or class forwhich not all inheritance/containment relations are shown. A graph is truncated if it does not fit within the specified boundaries. </li>
-</ul>
-<p>The arrows have the following meaning: </p>
-<ul>
-<li>
-A dark blue arrow is used to visualize a public inheritance relation between two classes. </li>
-<li>
-A dark green arrow is used for protected inheritance. </li>
-<li>
-A dark red arrow is used for private inheritance. </li>
-<li>
-A purple dashed arrow is used if a class is contained or used by another class. The arrow is labeled with the variable(s) through which the pointed class or struct is accessible. </li>
-<li>
-A yellow dashed arrow denotes a relation between a template instance and the template class it was instantiated from. The arrow is labeled with the template parameters of the instance. </li>
-</ul>
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/graph_legend.md5 b/docs/html/graph_legend.md5
deleted file mode 100644
index a06ed05..0000000
--- a/docs/html/graph_legend.md5
+++ /dev/null
@@ -1 +0,0 @@
-387ff8eb65306fa251338d3c9bd7bfff
\ No newline at end of file
diff --git a/docs/html/graph_legend.png b/docs/html/graph_legend.png
deleted file mode 100644
index 37f264e..0000000
--- a/docs/html/graph_legend.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/group__MAC.html b/docs/html/group__MAC.html
deleted file mode 100644
index be57bf1..0000000
--- a/docs/html/group__MAC.html
+++ /dev/null
@@ -1,679 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: Message authentication codes</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li class="current"><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
-</div><!-- top -->
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div class="header">
- <div class="summary">
-<a href="#define-members">Macros</a> |
-<a href="#typedef-members">Typedefs</a> |
-<a href="#func-members">Functions</a> </div>
- <div class="headertitle">
-<div class="title">Message authentication codes</div> </div>
-</div><!--header-->
-<div class="contents">
-<table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="define-members"></a>
-Macros</h2></td></tr>
-<tr class="memitem:ga441b6efc161a4573d06465bd22d9dc2d"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__MAC.html#ga441b6efc161a4573d06465bd22d9dc2d">PSA_MAC_OPERATION_INIT</a>   {0}</td></tr>
-<tr class="separator:ga441b6efc161a4573d06465bd22d9dc2d"><td class="memSeparator" colspan="2"> </td></tr>
-</table><table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="typedef-members"></a>
-Typedefs</h2></td></tr>
-<tr class="memitem:ga78f0838b0c4e3db28b26355624d4bd37"><td class="memItemLeft" align="right" valign="top">typedef struct psa_mac_operation_s </td><td class="memItemRight" valign="bottom"><a class="el" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a></td></tr>
-<tr class="separator:ga78f0838b0c4e3db28b26355624d4bd37"><td class="memSeparator" colspan="2"> </td></tr>
-</table><table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="func-members"></a>
-Functions</h2></td></tr>
-<tr class="memitem:gace78d9b51394f9d4f77952963665897a"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__MAC.html#gace78d9b51394f9d4f77952963665897a">psa_mac_compute</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg, const uint8_t *input, size_t input_length, uint8_t *mac, size_t mac_size, size_t *mac_length)</td></tr>
-<tr class="separator:gace78d9b51394f9d4f77952963665897a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga08e2e8c21bfe762a907266f3bdd1d07c"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__MAC.html#ga08e2e8c21bfe762a907266f3bdd1d07c">psa_mac_verify</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg, const uint8_t *input, size_t input_length, const uint8_t *mac, const size_t mac_length)</td></tr>
-<tr class="separator:ga08e2e8c21bfe762a907266f3bdd1d07c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gad33f2b15119593571ca6b8e7c757ab0e"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__MAC.html#gad33f2b15119593571ca6b8e7c757ab0e">psa_mac_sign_setup</a> (<a class="el" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a> *operation, <a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg)</td></tr>
-<tr class="separator:gad33f2b15119593571ca6b8e7c757ab0e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa721a59ae6d085ec90c7dc918879a027"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__MAC.html#gaa721a59ae6d085ec90c7dc918879a027">psa_mac_verify_setup</a> (<a class="el" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a> *operation, <a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg)</td></tr>
-<tr class="separator:gaa721a59ae6d085ec90c7dc918879a027"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga5560af371497babefe03c9da4e8a1c05"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__MAC.html#ga5560af371497babefe03c9da4e8a1c05">psa_mac_update</a> (<a class="el" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a> *operation, const uint8_t *input, size_t input_length)</td></tr>
-<tr class="separator:ga5560af371497babefe03c9da4e8a1c05"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac22bc0125580c96724a09226cfbc97f2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__MAC.html#gac22bc0125580c96724a09226cfbc97f2">psa_mac_sign_finish</a> (<a class="el" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a> *operation, uint8_t *mac, size_t mac_size, size_t *mac_length)</td></tr>
-<tr class="separator:gac22bc0125580c96724a09226cfbc97f2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac92b2930d6728e1be4d011c05d485822"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__MAC.html#gac92b2930d6728e1be4d011c05d485822">psa_mac_verify_finish</a> (<a class="el" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a> *operation, const uint8_t *mac, size_t mac_length)</td></tr>
-<tr class="separator:gac92b2930d6728e1be4d011c05d485822"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gacd8dd54855ba1bc0a03f104f252884fd"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__MAC.html#gacd8dd54855ba1bc0a03f104f252884fd">psa_mac_abort</a> (<a class="el" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a> *operation)</td></tr>
-<tr class="separator:gacd8dd54855ba1bc0a03f104f252884fd"><td class="memSeparator" colspan="2"> </td></tr>
-</table>
-<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
-<h2 class="groupheader">Macro Definition Documentation</h2>
-<a class="anchor" id="ga441b6efc161a4573d06465bd22d9dc2d"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_MAC_OPERATION_INIT   {0}</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>This macro returns a suitable initializer for a MAC operation object of type <a class="el" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a>. </p>
-
-</div>
-</div>
-<h2 class="groupheader">Typedef Documentation</h2>
-<a class="anchor" id="ga78f0838b0c4e3db28b26355624d4bd37"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">typedef struct psa_mac_operation_s <a class="el" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The type of the state data structure for multipart MAC operations.</p>
-<p>Before calling any function on a MAC operation object, the application must initialize it by any of the following means:</p><ul>
-<li>Set the structure to all-bits-zero, for example: <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> psa_mac_operation_t operation;</div><div class="line"><a name="l00002"></a><span class="lineno"> 2</span> memset(&operation, 0, sizeof(operation));</div></div><!-- fragment --></li>
-<li>Initialize the structure to logical zero values, for example: <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> psa_mac_operation_t operation = {0};</div></div><!-- fragment --></li>
-<li>Initialize the structure to the initializer <a class="el" href="group__MAC.html#ga441b6efc161a4573d06465bd22d9dc2d">PSA_MAC_OPERATION_INIT</a>, for example: <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> psa_mac_operation_t operation = PSA_MAC_OPERATION_INIT;</div></div><!-- fragment --></li>
-<li>Assign the result of the function psa_mac_operation_init() to the structure, for example: <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> psa_mac_operation_t operation;</div><div class="line"><a name="l00002"></a><span class="lineno"> 2</span> operation = psa_mac_operation_init();</div></div><!-- fragment --></li>
-</ul>
-<p>This is an implementation-defined <code>struct</code>. Applications should not make any assumptions about the content of this structure except as directed by the documentation of a specific implementation. </p>
-
-</div>
-</div>
-<h2 class="groupheader">Function Documentation</h2>
-<a class="anchor" id="gacd8dd54855ba1bc0a03f104f252884fd"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_mac_abort </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a> * </td>
- <td class="paramname"><em>operation</em></td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Abort a MAC operation.</p>
-<p>Aborting an operation frees all associated resources except for the <code>operation</code> structure itself. Once aborted, the operation object can be reused for another operation by calling <a class="el" href="group__MAC.html#gad33f2b15119593571ca6b8e7c757ab0e">psa_mac_sign_setup()</a> or <a class="el" href="group__MAC.html#gaa721a59ae6d085ec90c7dc918879a027">psa_mac_verify_setup()</a> again.</p>
-<p>You may call this function any time after the operation object has been initialized by any of the following methods:</p><ul>
-<li>A call to <a class="el" href="group__MAC.html#gad33f2b15119593571ca6b8e7c757ab0e">psa_mac_sign_setup()</a> or <a class="el" href="group__MAC.html#gaa721a59ae6d085ec90c7dc918879a027">psa_mac_verify_setup()</a>, whether it succeeds or not.</li>
-<li>Initializing the <code>struct</code> to all-bits-zero.</li>
-<li>Initializing the <code>struct</code> to logical zeros, e.g. <code>psa_mac_operation_t operation = {0}</code>.</li>
-</ul>
-<p>In particular, calling <a class="el" href="group__MAC.html#gacd8dd54855ba1bc0a03f104f252884fd">psa_mac_abort()</a> after the operation has been terminated by a call to <a class="el" href="group__MAC.html#gacd8dd54855ba1bc0a03f104f252884fd">psa_mac_abort()</a>, <a class="el" href="group__MAC.html#gac22bc0125580c96724a09226cfbc97f2">psa_mac_sign_finish()</a> or <a class="el" href="group__MAC.html#gac92b2930d6728e1be4d011c05d485822">psa_mac_verify_finish()</a> is safe and has no effect.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">operation</td><td>Initialized MAC operation.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td><code>operation</code> is not an active MAC operation. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="gace78d9b51394f9d4f77952963665897a"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_mac_compute </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> </td>
- <td class="paramname"><em>alg</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>input</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>input_length</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">uint8_t * </td>
- <td class="paramname"><em>mac</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>mac_size</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t * </td>
- <td class="paramname"><em>mac_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Calculate the MAC (message authentication code) of a message.</p>
-<dl class="section note"><dt>Note</dt><dd>To verify the MAC of a message against an expected value, use <a class="el" href="group__MAC.html#ga08e2e8c21bfe762a907266f3bdd1d07c">psa_mac_verify()</a> instead. Beware that comparing integrity or authenticity data such as MAC values with a function such as <code>memcmp</code> is risky because the time taken by the comparison may leak information about the MAC value which could allow an attacker to guess a valid MAC and thereby bypass security controls.</dd></dl>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir"></td><td class="paramname">handle</td><td>Handle to the key to use for the operation. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">alg</td><td>The MAC algorithm to compute (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#gaca7aee4c9dde316b3b1a150a26eab776">PSA_ALG_IS_MAC</a>(<code>alg</code>) is true). </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">input</td><td>Buffer containing the input message. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">input_length</td><td>Size of the <code>input</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">mac</td><td>Buffer where the MAC value is to be written. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">mac_size</td><td>Size of the <code>mac</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">mac_length</td><td>On success, the number of bytes that make up the MAC value.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040">PSA_ERROR_EMPTY_SLOT</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4d1b8dd8526177a15a210b7afc1accb1">PSA_ERROR_NOT_PERMITTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td><code>key</code> is not compatible with <code>alg</code>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td><code>alg</code> is not supported or is not a MAC algorithm. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The library has not been previously initialized by <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a>. It is implementation-dependent whether a failure to initialize results in this error code. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="gac22bc0125580c96724a09226cfbc97f2"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_mac_sign_finish </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a> * </td>
- <td class="paramname"><em>operation</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">uint8_t * </td>
- <td class="paramname"><em>mac</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>mac_size</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t * </td>
- <td class="paramname"><em>mac_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Finish the calculation of the MAC of a message.</p>
-<p>The application must call <a class="el" href="group__MAC.html#gad33f2b15119593571ca6b8e7c757ab0e">psa_mac_sign_setup()</a> before calling this function. This function calculates the MAC of the message formed by concatenating the inputs passed to preceding calls to <a class="el" href="group__MAC.html#ga5560af371497babefe03c9da4e8a1c05">psa_mac_update()</a>.</p>
-<p>When this function returns, the operation becomes inactive.</p>
-<dl class="section warning"><dt>Warning</dt><dd>Applications should not call this function if they expect a specific value for the MAC. Call <a class="el" href="group__MAC.html#gac92b2930d6728e1be4d011c05d485822">psa_mac_verify_finish()</a> instead. Beware that comparing integrity or authenticity data such as MAC values with a function such as <code>memcmp</code> is risky because the time taken by the comparison may leak information about the MAC value which could allow an attacker to guess a valid MAC and thereby bypass security controls.</dd></dl>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">operation</td><td>Active MAC operation. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">mac</td><td>Buffer where the MAC value is to be written. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">mac_size</td><td>Size of the <code>mac</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">mac_length</td><td>On success, the number of bytes that make up the MAC value. This is always <a class="el" href="crypto__sizes_8h.html#aa84c5fb384ac7cb1bfc52adde96588ee">PSA_MAC_FINAL_SIZE</a>(<code>key_type</code>, <code>key_bits</code>, <code>alg</code>) where <code>key_type</code> and <code>key_bits</code> are the type and bit-size respectively of the key and <code>alg</code> is the MAC algorithm that is calculated.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The operation state is not valid (not set up, or already completed). </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga695025f4ec11249aee7ea3d0f65e01c8">PSA_ERROR_BUFFER_TOO_SMALL</a></td><td>The size of the <code>mac</code> buffer is too small. You can determine a sufficient buffer size by calling <a class="el" href="crypto__sizes_8h.html#aa84c5fb384ac7cb1bfc52adde96588ee">PSA_MAC_FINAL_SIZE()</a>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="gad33f2b15119593571ca6b8e7c757ab0e"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_mac_sign_setup </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a> * </td>
- <td class="paramname"><em>operation</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> </td>
- <td class="paramname"><em>alg</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Set up a multipart MAC calculation operation.</p>
-<p>This function sets up the calculation of the MAC (message authentication code) of a byte string. To verify the MAC of a message against an expected value, use <a class="el" href="group__MAC.html#gaa721a59ae6d085ec90c7dc918879a027">psa_mac_verify_setup()</a> instead.</p>
-<p>The sequence of operations to calculate a MAC is as follows:</p><ol type="1">
-<li>Allocate an operation object which will be passed to all the functions listed here.</li>
-<li>Initialize the operation object with one of the methods described in the documentation for <a class="el" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a>, e.g. PSA_MAC_OPERATION_INIT.</li>
-<li>Call <a class="el" href="group__MAC.html#gad33f2b15119593571ca6b8e7c757ab0e">psa_mac_sign_setup()</a> to specify the algorithm and key.</li>
-<li>Call <a class="el" href="group__MAC.html#ga5560af371497babefe03c9da4e8a1c05">psa_mac_update()</a> zero, one or more times, passing a fragment of the message each time. The MAC that is calculated is the MAC of the concatenation of these messages in order.</li>
-<li>At the end of the message, call <a class="el" href="group__MAC.html#gac22bc0125580c96724a09226cfbc97f2">psa_mac_sign_finish()</a> to finish calculating the MAC value and retrieve it.</li>
-</ol>
-<p>The application may call <a class="el" href="group__MAC.html#gacd8dd54855ba1bc0a03f104f252884fd">psa_mac_abort()</a> at any time after the operation has been initialized.</p>
-<p>After a successful call to <a class="el" href="group__MAC.html#gad33f2b15119593571ca6b8e7c757ab0e">psa_mac_sign_setup()</a>, the application must eventually terminate the operation through one of the following methods:</p><ul>
-<li>A failed call to <a class="el" href="group__MAC.html#ga5560af371497babefe03c9da4e8a1c05">psa_mac_update()</a>.</li>
-<li>A call to <a class="el" href="group__MAC.html#gac22bc0125580c96724a09226cfbc97f2">psa_mac_sign_finish()</a> or <a class="el" href="group__MAC.html#gacd8dd54855ba1bc0a03f104f252884fd">psa_mac_abort()</a>.</li>
-</ul>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">operation</td><td>The operation object to set up. It must have been initialized as per the documentation for <a class="el" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a> and not yet in use. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">handle</td><td>Handle to the key to use for the operation. It must remain valid until the operation terminates. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">alg</td><td>The MAC algorithm to compute (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#gaca7aee4c9dde316b3b1a150a26eab776">PSA_ALG_IS_MAC</a>(<code>alg</code>) is true).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040">PSA_ERROR_EMPTY_SLOT</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4d1b8dd8526177a15a210b7afc1accb1">PSA_ERROR_NOT_PERMITTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td><code>key</code> is not compatible with <code>alg</code>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td><code>alg</code> is not supported or is not a MAC algorithm. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The library has not been previously initialized by <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a>. It is implementation-dependent whether a failure to initialize results in this error code. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga5560af371497babefe03c9da4e8a1c05"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_mac_update </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a> * </td>
- <td class="paramname"><em>operation</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>input</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>input_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Add a message fragment to a multipart MAC operation.</p>
-<p>The application must call <a class="el" href="group__MAC.html#gad33f2b15119593571ca6b8e7c757ab0e">psa_mac_sign_setup()</a> or <a class="el" href="group__MAC.html#gaa721a59ae6d085ec90c7dc918879a027">psa_mac_verify_setup()</a> before calling this function.</p>
-<p>If this function returns an error status, the operation becomes inactive.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">operation</td><td>Active MAC operation. </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">input</td><td>Buffer containing the message fragment to add to the MAC calculation. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">input_length</td><td>Size of the <code>input</code> buffer in bytes.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The operation state is not valid (not set up, or already completed). </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga08e2e8c21bfe762a907266f3bdd1d07c"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_mac_verify </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> </td>
- <td class="paramname"><em>alg</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>input</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>input_length</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>mac</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const size_t </td>
- <td class="paramname"><em>mac_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Calculate the MAC of a message and compare it with a reference value.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir"></td><td class="paramname">handle</td><td>Handle to the key to use for the operation. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">alg</td><td>The MAC algorithm to compute (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#gaca7aee4c9dde316b3b1a150a26eab776">PSA_ALG_IS_MAC</a>(<code>alg</code>) is true). </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">input</td><td>Buffer containing the input message. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">input_length</td><td>Size of the <code>input</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">mac</td><td>Buffer containing the expected MAC value. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">mac_length</td><td>Size of the <code>mac</code> buffer in bytes.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>The expected MAC is identical to the actual MAC of the input. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga35927f755d232c4766de600f2c49e9f2">PSA_ERROR_INVALID_SIGNATURE</a></td><td>The MAC of the message was calculated successfully, but it differs from the expected value. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040">PSA_ERROR_EMPTY_SLOT</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4d1b8dd8526177a15a210b7afc1accb1">PSA_ERROR_NOT_PERMITTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td><code>key</code> is not compatible with <code>alg</code>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td><code>alg</code> is not supported or is not a MAC algorithm. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="gac92b2930d6728e1be4d011c05d485822"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_mac_verify_finish </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a> * </td>
- <td class="paramname"><em>operation</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>mac</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>mac_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Finish the calculation of the MAC of a message and compare it with an expected value.</p>
-<p>The application must call <a class="el" href="group__MAC.html#gaa721a59ae6d085ec90c7dc918879a027">psa_mac_verify_setup()</a> before calling this function. This function calculates the MAC of the message formed by concatenating the inputs passed to preceding calls to <a class="el" href="group__MAC.html#ga5560af371497babefe03c9da4e8a1c05">psa_mac_update()</a>. It then compares the calculated MAC with the expected MAC passed as a parameter to this function.</p>
-<p>When this function returns, the operation becomes inactive.</p>
-<dl class="section note"><dt>Note</dt><dd>Implementations shall make the best effort to ensure that the comparison between the actual MAC and the expected MAC is performed in constant time.</dd></dl>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">operation</td><td>Active MAC operation. </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">mac</td><td>Buffer containing the expected MAC value. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">mac_length</td><td>Size of the <code>mac</code> buffer in bytes.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>The expected MAC is identical to the actual MAC of the message. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga35927f755d232c4766de600f2c49e9f2">PSA_ERROR_INVALID_SIGNATURE</a></td><td>The MAC of the message was calculated successfully, but it differs from the expected MAC. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The operation state is not valid (not set up, or already completed). </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="gaa721a59ae6d085ec90c7dc918879a027"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_mac_verify_setup </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a> * </td>
- <td class="paramname"><em>operation</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> </td>
- <td class="paramname"><em>alg</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Set up a multipart MAC verification operation.</p>
-<p>This function sets up the verification of the MAC (message authentication code) of a byte string against an expected value.</p>
-<p>The sequence of operations to verify a MAC is as follows:</p><ol type="1">
-<li>Allocate an operation object which will be passed to all the functions listed here.</li>
-<li>Initialize the operation object with one of the methods described in the documentation for <a class="el" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a>, e.g. PSA_MAC_OPERATION_INIT.</li>
-<li>Call <a class="el" href="group__MAC.html#gaa721a59ae6d085ec90c7dc918879a027">psa_mac_verify_setup()</a> to specify the algorithm and key.</li>
-<li>Call <a class="el" href="group__MAC.html#ga5560af371497babefe03c9da4e8a1c05">psa_mac_update()</a> zero, one or more times, passing a fragment of the message each time. The MAC that is calculated is the MAC of the concatenation of these messages in order.</li>
-<li>At the end of the message, call <a class="el" href="group__MAC.html#gac92b2930d6728e1be4d011c05d485822">psa_mac_verify_finish()</a> to finish calculating the actual MAC of the message and verify it against the expected value.</li>
-</ol>
-<p>The application may call <a class="el" href="group__MAC.html#gacd8dd54855ba1bc0a03f104f252884fd">psa_mac_abort()</a> at any time after the operation has been initialized.</p>
-<p>After a successful call to <a class="el" href="group__MAC.html#gaa721a59ae6d085ec90c7dc918879a027">psa_mac_verify_setup()</a>, the application must eventually terminate the operation through one of the following methods:</p><ul>
-<li>A failed call to <a class="el" href="group__MAC.html#ga5560af371497babefe03c9da4e8a1c05">psa_mac_update()</a>.</li>
-<li>A call to <a class="el" href="group__MAC.html#gac92b2930d6728e1be4d011c05d485822">psa_mac_verify_finish()</a> or <a class="el" href="group__MAC.html#gacd8dd54855ba1bc0a03f104f252884fd">psa_mac_abort()</a>.</li>
-</ul>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">operation</td><td>The operation object to set up. It must have been initialized as per the documentation for <a class="el" href="group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37">psa_mac_operation_t</a> and not yet in use. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">handle</td><td>Handle to the key to use for the operation. It must remain valid until the operation terminates. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">alg</td><td>The MAC algorithm to compute (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#gaca7aee4c9dde316b3b1a150a26eab776">PSA_ALG_IS_MAC</a>(<code>alg</code>) is true).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040">PSA_ERROR_EMPTY_SLOT</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4d1b8dd8526177a15a210b7afc1accb1">PSA_ERROR_NOT_PERMITTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td><code>key</code> is not compatible with <code>alg</code>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td><code>alg</code> is not supported or is not a MAC algorithm. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The library has not been previously initialized by <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a>. It is implementation-dependent whether a failure to initialize results in this error code. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/group__aead.html b/docs/html/group__aead.html
deleted file mode 100644
index 9ff9a21..0000000
--- a/docs/html/group__aead.html
+++ /dev/null
@@ -1,1057 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: Authenticated encryption with associated data (AEAD)</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li class="current"><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
-</div><!-- top -->
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div class="header">
- <div class="summary">
-<a href="#define-members">Macros</a> |
-<a href="#typedef-members">Typedefs</a> |
-<a href="#func-members">Functions</a> </div>
- <div class="headertitle">
-<div class="title">Authenticated encryption with associated data (AEAD)</div> </div>
-</div><!--header-->
-<div class="contents">
-<table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="define-members"></a>
-Macros</h2></td></tr>
-<tr class="memitem:gaf52e036794c0dc6fbadd93a2b990f366"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__aead.html#gaf52e036794c0dc6fbadd93a2b990f366">PSA_AEAD_OPERATION_INIT</a>   {0}</td></tr>
-<tr class="separator:gaf52e036794c0dc6fbadd93a2b990f366"><td class="memSeparator" colspan="2"> </td></tr>
-</table><table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="typedef-members"></a>
-Typedefs</h2></td></tr>
-<tr class="memitem:ga14f6a01afbaa8c5b3d8c5d345cbaa3ed"><td class="memItemLeft" align="right" valign="top">typedef struct psa_aead_operation_s </td><td class="memItemRight" valign="bottom"><a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a></td></tr>
-<tr class="separator:ga14f6a01afbaa8c5b3d8c5d345cbaa3ed"><td class="memSeparator" colspan="2"> </td></tr>
-</table><table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="func-members"></a>
-Functions</h2></td></tr>
-<tr class="memitem:ga44de092cf58bb6c820c5c80a6c51610d"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__aead.html#ga44de092cf58bb6c820c5c80a6c51610d">psa_aead_encrypt</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg, const uint8_t *nonce, size_t nonce_length, const uint8_t *additional_data, size_t additional_data_length, const uint8_t *plaintext, size_t plaintext_length, uint8_t *ciphertext, size_t ciphertext_size, size_t *ciphertext_length)</td></tr>
-<tr class="separator:ga44de092cf58bb6c820c5c80a6c51610d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa8ce6527f2e227f1071fadbf2099793b"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__aead.html#gaa8ce6527f2e227f1071fadbf2099793b">psa_aead_decrypt</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg, const uint8_t *nonce, size_t nonce_length, const uint8_t *additional_data, size_t additional_data_length, const uint8_t *ciphertext, size_t ciphertext_length, uint8_t *plaintext, size_t plaintext_size, size_t *plaintext_length)</td></tr>
-<tr class="separator:gaa8ce6527f2e227f1071fadbf2099793b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga47265dc4852f1476f852752218fd12b2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__aead.html#ga47265dc4852f1476f852752218fd12b2">psa_aead_encrypt_setup</a> (<a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation, <a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg)</td></tr>
-<tr class="separator:ga47265dc4852f1476f852752218fd12b2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga439896519d4a367ec86b47f201884152"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__aead.html#ga439896519d4a367ec86b47f201884152">psa_aead_decrypt_setup</a> (<a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation, <a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg)</td></tr>
-<tr class="separator:ga439896519d4a367ec86b47f201884152"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga3eadcf2a29f662129ea4fb3454969ba2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__aead.html#ga3eadcf2a29f662129ea4fb3454969ba2">psa_aead_generate_nonce</a> (<a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation, unsigned char *nonce, size_t nonce_size, size_t *nonce_length)</td></tr>
-<tr class="separator:ga3eadcf2a29f662129ea4fb3454969ba2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga40641d0721ca7fe01bbcd9ef635fbc46"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__aead.html#ga40641d0721ca7fe01bbcd9ef635fbc46">psa_aead_set_nonce</a> (<a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation, const unsigned char *nonce, size_t nonce_length)</td></tr>
-<tr class="separator:ga40641d0721ca7fe01bbcd9ef635fbc46"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gad3431e28d05002c2a7b0760610176050"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__aead.html#gad3431e28d05002c2a7b0760610176050">psa_aead_set_lengths</a> (<a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation, size_t ad_length, size_t plaintext_length)</td></tr>
-<tr class="separator:gad3431e28d05002c2a7b0760610176050"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6d0eed03f832e5c9c91cb8adf2882569"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__aead.html#ga6d0eed03f832e5c9c91cb8adf2882569">psa_aead_update_ad</a> (<a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation, const uint8_t *input, size_t input_length)</td></tr>
-<tr class="separator:ga6d0eed03f832e5c9c91cb8adf2882569"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga3b105de2088cef7c3d9e2fd8048c841c"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__aead.html#ga3b105de2088cef7c3d9e2fd8048c841c">psa_aead_update</a> (<a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation, const uint8_t *input, size_t input_length, unsigned char *output, size_t output_size, size_t *output_length)</td></tr>
-<tr class="separator:ga3b105de2088cef7c3d9e2fd8048c841c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga759791bbe1763b377c3b5447641f1fc8"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__aead.html#ga759791bbe1763b377c3b5447641f1fc8">psa_aead_finish</a> (<a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation, uint8_t *ciphertext, size_t ciphertext_size, size_t *ciphertext_length, uint8_t *tag, size_t tag_size, size_t *tag_length)</td></tr>
-<tr class="separator:ga759791bbe1763b377c3b5447641f1fc8"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaaed211fc61977c859d6ff07f39f59219"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__aead.html#gaaed211fc61977c859d6ff07f39f59219">psa_aead_verify</a> (<a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation, const uint8_t *tag, size_t tag_length)</td></tr>
-<tr class="separator:gaaed211fc61977c859d6ff07f39f59219"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae8a5f93d92318c8f592ee9fbb9d36ba0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__aead.html#gae8a5f93d92318c8f592ee9fbb9d36ba0">psa_aead_abort</a> (<a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> *operation)</td></tr>
-<tr class="separator:gae8a5f93d92318c8f592ee9fbb9d36ba0"><td class="memSeparator" colspan="2"> </td></tr>
-</table>
-<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
-<h2 class="groupheader">Macro Definition Documentation</h2>
-<a class="anchor" id="gaf52e036794c0dc6fbadd93a2b990f366"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_AEAD_OPERATION_INIT   {0}</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>This macro returns a suitable initializer for an AEAD operation object of type <a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a>. </p>
-
-</div>
-</div>
-<h2 class="groupheader">Typedef Documentation</h2>
-<a class="anchor" id="ga14f6a01afbaa8c5b3d8c5d345cbaa3ed"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">typedef struct psa_aead_operation_s <a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The type of the state data structure for multipart AEAD operations.</p>
-<p>Before calling any function on an AEAD operation object, the application must initialize it by any of the following means:</p><ul>
-<li>Set the structure to all-bits-zero, for example: <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> psa_aead_operation_t operation;</div><div class="line"><a name="l00002"></a><span class="lineno"> 2</span> memset(&operation, 0, sizeof(operation));</div></div><!-- fragment --></li>
-<li>Initialize the structure to logical zero values, for example: <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> psa_aead_operation_t operation = {0};</div></div><!-- fragment --></li>
-<li>Initialize the structure to the initializer <a class="el" href="group__aead.html#gaf52e036794c0dc6fbadd93a2b990f366">PSA_AEAD_OPERATION_INIT</a>, for example: <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> psa_aead_operation_t operation = PSA_AEAD_OPERATION_INIT;</div></div><!-- fragment --></li>
-<li>Assign the result of the function psa_aead_operation_init() to the structure, for example: <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> psa_aead_operation_t operation;</div><div class="line"><a name="l00002"></a><span class="lineno"> 2</span> operation = psa_aead_operation_init();</div></div><!-- fragment --></li>
-</ul>
-<p>This is an implementation-defined <code>struct</code>. Applications should not make any assumptions about the content of this structure except as directed by the documentation of a specific implementation. </p>
-
-</div>
-</div>
-<h2 class="groupheader">Function Documentation</h2>
-<a class="anchor" id="gae8a5f93d92318c8f592ee9fbb9d36ba0"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_aead_abort </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> * </td>
- <td class="paramname"><em>operation</em></td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Abort an AEAD operation.</p>
-<p>Aborting an operation frees all associated resources except for the <code>operation</code> structure itself. Once aborted, the operation object can be reused for another operation by calling <a class="el" href="group__aead.html#ga47265dc4852f1476f852752218fd12b2">psa_aead_encrypt_setup()</a> or <a class="el" href="group__aead.html#ga439896519d4a367ec86b47f201884152">psa_aead_decrypt_setup()</a> again.</p>
-<p>You may call this function any time after the operation object has been initialized by any of the following methods:</p><ul>
-<li>A call to <a class="el" href="group__aead.html#ga47265dc4852f1476f852752218fd12b2">psa_aead_encrypt_setup()</a> or <a class="el" href="group__aead.html#ga439896519d4a367ec86b47f201884152">psa_aead_decrypt_setup()</a>, whether it succeeds or not.</li>
-<li>Initializing the <code>struct</code> to all-bits-zero.</li>
-<li>Initializing the <code>struct</code> to logical zeros, e.g. <code>psa_aead_operation_t operation = {0}</code>.</li>
-</ul>
-<p>In particular, calling <a class="el" href="group__aead.html#gae8a5f93d92318c8f592ee9fbb9d36ba0">psa_aead_abort()</a> after the operation has been terminated by a call to <a class="el" href="group__aead.html#gae8a5f93d92318c8f592ee9fbb9d36ba0">psa_aead_abort()</a> or <a class="el" href="group__aead.html#ga759791bbe1763b377c3b5447641f1fc8">psa_aead_finish()</a> is safe and has no effect.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">operation</td><td>Initialized AEAD operation.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td><code>operation</code> is not an active AEAD operation. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="gaa8ce6527f2e227f1071fadbf2099793b"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_aead_decrypt </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> </td>
- <td class="paramname"><em>alg</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>nonce</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>nonce_length</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>additional_data</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>additional_data_length</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>ciphertext</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>ciphertext_length</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">uint8_t * </td>
- <td class="paramname"><em>plaintext</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>plaintext_size</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t * </td>
- <td class="paramname"><em>plaintext_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Process an authenticated decryption operation.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir"></td><td class="paramname">handle</td><td>Handle to the key to use for the operation. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">alg</td><td>The AEAD algorithm to compute (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#ga1d44829d60065eaa4ac9a703e7d6abc8">PSA_ALG_IS_AEAD</a>(<code>alg</code>) is true). </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">nonce</td><td>Nonce or IV to use. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">nonce_length</td><td>Size of the <code>nonce</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">additional_data</td><td>Additional data that has been authenticated but not encrypted. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">additional_data_length</td><td>Size of <code>additional_data</code> in bytes. </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">ciphertext</td><td>Data that has been authenticated and encrypted. For algorithms where the encrypted data and the authentication tag are defined as separate inputs, the buffer must contain the encrypted data followed by the authentication tag. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">ciphertext_length</td><td>Size of <code>ciphertext</code> in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">plaintext</td><td>Output buffer for the decrypted data. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">plaintext_size</td><td>Size of the <code>plaintext</code> buffer in bytes. This must be at least <a class="el" href="crypto__sizes_8h.html#a1d057796166c16eb673ad1997e48a60b">PSA_AEAD_DECRYPT_OUTPUT_SIZE</a>(<code>alg</code>, <code>ciphertext_length</code>). </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">plaintext_length</td><td>On success, the size of the output in the <code>plaintext</code> buffer.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040">PSA_ERROR_EMPTY_SLOT</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga35927f755d232c4766de600f2c49e9f2">PSA_ERROR_INVALID_SIGNATURE</a></td><td>The ciphertext is not authentic. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4d1b8dd8526177a15a210b7afc1accb1">PSA_ERROR_NOT_PERMITTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td><code>key</code> is not compatible with <code>alg</code>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td><code>alg</code> is not supported or is not an AEAD algorithm. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The library has not been previously initialized by <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a>. It is implementation-dependent whether a failure to initialize results in this error code. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga439896519d4a367ec86b47f201884152"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_aead_decrypt_setup </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> * </td>
- <td class="paramname"><em>operation</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> </td>
- <td class="paramname"><em>alg</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Set the key for a multipart authenticated decryption operation.</p>
-<p>The sequence of operations to decrypt a message with authentication is as follows:</p><ol type="1">
-<li>Allocate an operation object which will be passed to all the functions listed here.</li>
-<li>Initialize the operation object with one of the methods described in the documentation for <a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a>, e.g. PSA_AEAD_OPERATION_INIT.</li>
-<li>Call <a class="el" href="group__aead.html#ga439896519d4a367ec86b47f201884152">psa_aead_decrypt_setup()</a> to specify the algorithm and key.</li>
-<li>If needed, call <a class="el" href="group__aead.html#gad3431e28d05002c2a7b0760610176050">psa_aead_set_lengths()</a> to specify the length of the inputs to the subsequent calls to <a class="el" href="group__aead.html#ga6d0eed03f832e5c9c91cb8adf2882569">psa_aead_update_ad()</a> and <a class="el" href="group__aead.html#ga3b105de2088cef7c3d9e2fd8048c841c">psa_aead_update()</a>. See the documentation of <a class="el" href="group__aead.html#gad3431e28d05002c2a7b0760610176050">psa_aead_set_lengths()</a> for details.</li>
-<li>Call <a class="el" href="group__aead.html#ga40641d0721ca7fe01bbcd9ef635fbc46">psa_aead_set_nonce()</a> with the nonce for the decryption.</li>
-<li>Call <a class="el" href="group__aead.html#ga6d0eed03f832e5c9c91cb8adf2882569">psa_aead_update_ad()</a> zero, one or more times, passing a fragment of the non-encrypted additional authenticated data each time.</li>
-<li>Call <a class="el" href="group__aead.html#ga3b105de2088cef7c3d9e2fd8048c841c">psa_aead_update()</a> zero, one or more times, passing a fragment of the ciphertext to decrypt each time.</li>
-<li>Call <a class="el" href="group__aead.html#gaaed211fc61977c859d6ff07f39f59219">psa_aead_verify()</a>.</li>
-</ol>
-<p>The application may call <a class="el" href="group__aead.html#gae8a5f93d92318c8f592ee9fbb9d36ba0">psa_aead_abort()</a> at any time after the operation has been initialized.</p>
-<p>After a successful call to <a class="el" href="group__aead.html#ga439896519d4a367ec86b47f201884152">psa_aead_decrypt_setup()</a>, the application must eventually terminate the operation. The following events terminate an operation:</p><ul>
-<li>A failed call to any of the <code>psa_aead_xxx</code> functions.</li>
-<li>A call to <a class="el" href="group__aead.html#ga759791bbe1763b377c3b5447641f1fc8">psa_aead_finish()</a>, <a class="el" href="group__aead.html#gaaed211fc61977c859d6ff07f39f59219">psa_aead_verify()</a> or <a class="el" href="group__aead.html#gae8a5f93d92318c8f592ee9fbb9d36ba0">psa_aead_abort()</a>.</li>
-</ul>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">operation</td><td>The operation object to set up. It must have been initialized as per the documentation for <a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> and not yet in use. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">handle</td><td>Handle to the key to use for the operation. It must remain valid until the operation terminates. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">alg</td><td>The AEAD algorithm to compute (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#ga1d44829d60065eaa4ac9a703e7d6abc8">PSA_ALG_IS_AEAD</a>(<code>alg</code>) is true).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040">PSA_ERROR_EMPTY_SLOT</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4d1b8dd8526177a15a210b7afc1accb1">PSA_ERROR_NOT_PERMITTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td><code>key</code> is not compatible with <code>alg</code>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td><code>alg</code> is not supported or is not an AEAD algorithm. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The library has not been previously initialized by <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a>. It is implementation-dependent whether a failure to initialize results in this error code. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga44de092cf58bb6c820c5c80a6c51610d"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_aead_encrypt </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> </td>
- <td class="paramname"><em>alg</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>nonce</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>nonce_length</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>additional_data</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>additional_data_length</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>plaintext</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>plaintext_length</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">uint8_t * </td>
- <td class="paramname"><em>ciphertext</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>ciphertext_size</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t * </td>
- <td class="paramname"><em>ciphertext_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Process an authenticated encryption operation.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir"></td><td class="paramname">handle</td><td>Handle to the key to use for the operation. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">alg</td><td>The AEAD algorithm to compute (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#ga1d44829d60065eaa4ac9a703e7d6abc8">PSA_ALG_IS_AEAD</a>(<code>alg</code>) is true). </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">nonce</td><td>Nonce or IV to use. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">nonce_length</td><td>Size of the <code>nonce</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">additional_data</td><td>Additional data that will be authenticated but not encrypted. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">additional_data_length</td><td>Size of <code>additional_data</code> in bytes. </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">plaintext</td><td>Data that will be authenticated and encrypted. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">plaintext_length</td><td>Size of <code>plaintext</code> in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">ciphertext</td><td>Output buffer for the authenticated and encrypted data. The additional data is not part of this output. For algorithms where the encrypted data and the authentication tag are defined as separate outputs, the authentication tag is appended to the encrypted data. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">ciphertext_size</td><td>Size of the <code>ciphertext</code> buffer in bytes. This must be at least <a class="el" href="crypto__sizes_8h.html#a85667d47a7aa6c7b99a80e5273671266">PSA_AEAD_ENCRYPT_OUTPUT_SIZE</a>(<code>alg</code>, <code>plaintext_length</code>). </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">ciphertext_length</td><td>On success, the size of the output in the <code>ciphertext</code> buffer.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040">PSA_ERROR_EMPTY_SLOT</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4d1b8dd8526177a15a210b7afc1accb1">PSA_ERROR_NOT_PERMITTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td><code>key</code> is not compatible with <code>alg</code>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td><code>alg</code> is not supported or is not an AEAD algorithm. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The library has not been previously initialized by <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a>. It is implementation-dependent whether a failure to initialize results in this error code. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga47265dc4852f1476f852752218fd12b2"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_aead_encrypt_setup </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> * </td>
- <td class="paramname"><em>operation</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> </td>
- <td class="paramname"><em>alg</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Set the key for a multipart authenticated encryption operation.</p>
-<p>The sequence of operations to encrypt a message with authentication is as follows:</p><ol type="1">
-<li>Allocate an operation object which will be passed to all the functions listed here.</li>
-<li>Initialize the operation object with one of the methods described in the documentation for <a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a>, e.g. PSA_AEAD_OPERATION_INIT.</li>
-<li>Call <a class="el" href="group__aead.html#ga47265dc4852f1476f852752218fd12b2">psa_aead_encrypt_setup()</a> to specify the algorithm and key.</li>
-<li>If needed, call <a class="el" href="group__aead.html#gad3431e28d05002c2a7b0760610176050">psa_aead_set_lengths()</a> to specify the length of the inputs to the subsequent calls to <a class="el" href="group__aead.html#ga6d0eed03f832e5c9c91cb8adf2882569">psa_aead_update_ad()</a> and <a class="el" href="group__aead.html#ga3b105de2088cef7c3d9e2fd8048c841c">psa_aead_update()</a>. See the documentation of <a class="el" href="group__aead.html#gad3431e28d05002c2a7b0760610176050">psa_aead_set_lengths()</a> for details.</li>
-<li>Call either <a class="el" href="group__aead.html#ga3eadcf2a29f662129ea4fb3454969ba2">psa_aead_generate_nonce()</a> or <a class="el" href="group__aead.html#ga40641d0721ca7fe01bbcd9ef635fbc46">psa_aead_set_nonce()</a> to generate or set the nonce. You should use <a class="el" href="group__aead.html#ga3eadcf2a29f662129ea4fb3454969ba2">psa_aead_generate_nonce()</a> unless the protocol you are implementing requires a specific nonce value.</li>
-<li>Call <a class="el" href="group__aead.html#ga6d0eed03f832e5c9c91cb8adf2882569">psa_aead_update_ad()</a> zero, one or more times, passing a fragment of the non-encrypted additional authenticated data each time.</li>
-<li>Call <a class="el" href="group__aead.html#ga3b105de2088cef7c3d9e2fd8048c841c">psa_aead_update()</a> zero, one or more times, passing a fragment of the message to encrypt each time.</li>
-<li>Call <a class="el" href="group__aead.html#ga759791bbe1763b377c3b5447641f1fc8">psa_aead_finish()</a>.</li>
-</ol>
-<p>The application may call <a class="el" href="group__aead.html#gae8a5f93d92318c8f592ee9fbb9d36ba0">psa_aead_abort()</a> at any time after the operation has been initialized.</p>
-<p>After a successful call to <a class="el" href="group__aead.html#ga47265dc4852f1476f852752218fd12b2">psa_aead_encrypt_setup()</a>, the application must eventually terminate the operation. The following events terminate an operation:</p><ul>
-<li>A failed call to any of the <code>psa_aead_xxx</code> functions.</li>
-<li>A call to <a class="el" href="group__aead.html#ga759791bbe1763b377c3b5447641f1fc8">psa_aead_finish()</a>, <a class="el" href="group__aead.html#gaaed211fc61977c859d6ff07f39f59219">psa_aead_verify()</a> or <a class="el" href="group__aead.html#gae8a5f93d92318c8f592ee9fbb9d36ba0">psa_aead_abort()</a>.</li>
-</ul>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">operation</td><td>The operation object to set up. It must have been initialized as per the documentation for <a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> and not yet in use. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">handle</td><td>Handle to the key to use for the operation. It must remain valid until the operation terminates. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">alg</td><td>The AEAD algorithm to compute (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#ga1d44829d60065eaa4ac9a703e7d6abc8">PSA_ALG_IS_AEAD</a>(<code>alg</code>) is true).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040">PSA_ERROR_EMPTY_SLOT</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4d1b8dd8526177a15a210b7afc1accb1">PSA_ERROR_NOT_PERMITTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td><code>key</code> is not compatible with <code>alg</code>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td><code>alg</code> is not supported or is not an AEAD algorithm. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The library has not been previously initialized by <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a>. It is implementation-dependent whether a failure to initialize results in this error code. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga759791bbe1763b377c3b5447641f1fc8"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_aead_finish </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> * </td>
- <td class="paramname"><em>operation</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">uint8_t * </td>
- <td class="paramname"><em>ciphertext</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>ciphertext_size</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t * </td>
- <td class="paramname"><em>ciphertext_length</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">uint8_t * </td>
- <td class="paramname"><em>tag</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>tag_size</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t * </td>
- <td class="paramname"><em>tag_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Finish encrypting a message in an AEAD operation.</p>
-<p>The operation must have been set up with <a class="el" href="group__aead.html#ga47265dc4852f1476f852752218fd12b2">psa_aead_encrypt_setup()</a>.</p>
-<p>This function finishes the authentication of the additional data formed by concatenating the inputs passed to preceding calls to <a class="el" href="group__aead.html#ga6d0eed03f832e5c9c91cb8adf2882569">psa_aead_update_ad()</a> with the plaintext formed by concatenating the inputs passed to preceding calls to <a class="el" href="group__aead.html#ga3b105de2088cef7c3d9e2fd8048c841c">psa_aead_update()</a>.</p>
-<p>This function has two output buffers:</p><ul>
-<li><code>ciphertext</code> contains trailing ciphertext that was buffered from preceding calls to <a class="el" href="group__aead.html#ga3b105de2088cef7c3d9e2fd8048c841c">psa_aead_update()</a>. For all standard AEAD algorithms, <a class="el" href="group__aead.html#ga3b105de2088cef7c3d9e2fd8048c841c">psa_aead_update()</a> does not buffer any output and therefore <code>ciphertext</code> will not contain any output and can be a 0-sized buffer.</li>
-<li><code>tag</code> contains the authentication tag. Its length is always <a class="el" href="crypto__sizes_8h.html#a8e3079b2e624cb8d32b94843cddada49">PSA_AEAD_TAG_LENGTH</a>(<code>alg</code>) where <code>alg</code> is the AEAD algorithm that the operation performs.</li>
-</ul>
-<p>When this function returns, the operation becomes inactive.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">operation</td><td>Active AEAD operation. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">ciphertext</td><td>Buffer where the last part of the ciphertext is to be written. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">ciphertext_size</td><td>Size of the <code>ciphertext</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">ciphertext_length</td><td>On success, the number of bytes of returned ciphertext. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">tag</td><td>Buffer where the authentication tag is to be written. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">tag_size</td><td>Size of the <code>tag</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">tag_length</td><td>On success, the number of bytes that make up the returned tag.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The operation state is not valid (not set up, nonce not set, decryption, or already completed). </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga695025f4ec11249aee7ea3d0f65e01c8">PSA_ERROR_BUFFER_TOO_SMALL</a></td><td>The size of the <code>output</code> buffer is too small. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td>The total length of input to <a class="el" href="group__aead.html#ga6d0eed03f832e5c9c91cb8adf2882569">psa_aead_update_ad()</a> so far is less than the additional data length that was previously specified with <a class="el" href="group__aead.html#gad3431e28d05002c2a7b0760610176050">psa_aead_set_lengths()</a>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td>The total length of input to <a class="el" href="group__aead.html#ga3b105de2088cef7c3d9e2fd8048c841c">psa_aead_update()</a> so far is less than the plaintext length that was previously specified with <a class="el" href="group__aead.html#gad3431e28d05002c2a7b0760610176050">psa_aead_set_lengths()</a>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga3eadcf2a29f662129ea4fb3454969ba2"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_aead_generate_nonce </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> * </td>
- <td class="paramname"><em>operation</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">unsigned char * </td>
- <td class="paramname"><em>nonce</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>nonce_size</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t * </td>
- <td class="paramname"><em>nonce_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Generate a random nonce for an authenticated encryption operation.</p>
-<p>This function generates a random nonce for the authenticated encryption operation with an appropriate size for the chosen algorithm, key type and key size.</p>
-<p>The application must call <a class="el" href="group__aead.html#ga47265dc4852f1476f852752218fd12b2">psa_aead_encrypt_setup()</a> before calling this function.</p>
-<p>If this function returns an error status, the operation becomes inactive.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">operation</td><td>Active AEAD operation. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">nonce</td><td>Buffer where the generated nonce is to be written. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">nonce_size</td><td>Size of the <code>nonce</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">nonce_length</td><td>On success, the number of bytes of the generated nonce.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The operation state is not valid (not set up, or nonce already set). </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga695025f4ec11249aee7ea3d0f65e01c8">PSA_ERROR_BUFFER_TOO_SMALL</a></td><td>The size of the <code>nonce</code> buffer is too small. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="gad3431e28d05002c2a7b0760610176050"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_aead_set_lengths </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> * </td>
- <td class="paramname"><em>operation</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>ad_length</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>plaintext_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Declare the lengths of the message and additional data for AEAD.</p>
-<p>The application must call this function before calling <a class="el" href="group__aead.html#ga6d0eed03f832e5c9c91cb8adf2882569">psa_aead_update_ad()</a> or <a class="el" href="group__aead.html#ga3b105de2088cef7c3d9e2fd8048c841c">psa_aead_update()</a> if the algorithm for the operation requires it. If the algorithm does not require it, calling this function is optional, but if this function is called then the implementation must enforce the lengths.</p>
-<p>You may call this function before or after setting the nonce with <a class="el" href="group__aead.html#ga40641d0721ca7fe01bbcd9ef635fbc46">psa_aead_set_nonce()</a> or <a class="el" href="group__aead.html#ga3eadcf2a29f662129ea4fb3454969ba2">psa_aead_generate_nonce()</a>.</p>
-<ul>
-<li>For <a class="el" href="group__crypto__types.html#gac2c0e7d21f1b2df5e76bcb4a8f84273c">PSA_ALG_CCM</a>, calling this function is required.</li>
-<li>For the other AEAD algorithms defined in this specification, calling this function is not required.</li>
-<li>For vendor-defined algorithm, refer to the vendor documentation.</li>
-</ul>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">operation</td><td>Active AEAD operation. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">ad_length</td><td>Size of the non-encrypted additional authenticated data in bytes. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">plaintext_length</td><td>Size of the plaintext to encrypt in bytes.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The operation state is not valid (not set up, already completed, or <a class="el" href="group__aead.html#ga6d0eed03f832e5c9c91cb8adf2882569">psa_aead_update_ad()</a> or <a class="el" href="group__aead.html#ga3b105de2088cef7c3d9e2fd8048c841c">psa_aead_update()</a> already called). </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td>At least one of the lengths is not acceptable for the chosen algorithm. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga40641d0721ca7fe01bbcd9ef635fbc46"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_aead_set_nonce </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> * </td>
- <td class="paramname"><em>operation</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const unsigned char * </td>
- <td class="paramname"><em>nonce</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>nonce_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Set the nonce for an authenticated encryption or decryption operation.</p>
-<p>This function sets the nonce for the authenticated encryption or decryption operation.</p>
-<p>The application must call <a class="el" href="group__aead.html#ga47265dc4852f1476f852752218fd12b2">psa_aead_encrypt_setup()</a> before calling this function.</p>
-<p>If this function returns an error status, the operation becomes inactive.</p>
-<dl class="section note"><dt>Note</dt><dd>When encrypting, applications should use <a class="el" href="group__aead.html#ga3eadcf2a29f662129ea4fb3454969ba2">psa_aead_generate_nonce()</a> instead of this function, unless implementing a protocol that requires a non-random IV.</dd></dl>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">operation</td><td>Active AEAD operation. </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">nonce</td><td>Buffer containing the nonce to use. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">nonce_length</td><td>Size of the nonce in bytes.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The operation state is not valid (not set up, or nonce already set). </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td>The size of <code>nonce</code> is not acceptable for the chosen algorithm. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga3b105de2088cef7c3d9e2fd8048c841c"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_aead_update </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> * </td>
- <td class="paramname"><em>operation</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>input</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>input_length</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">unsigned char * </td>
- <td class="paramname"><em>output</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>output_size</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t * </td>
- <td class="paramname"><em>output_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Encrypt or decrypt a message fragment in an active AEAD operation.</p>
-<p>Before calling this function, you must:</p><ol type="1">
-<li>Call either <a class="el" href="group__aead.html#ga47265dc4852f1476f852752218fd12b2">psa_aead_encrypt_setup()</a> or <a class="el" href="group__aead.html#ga439896519d4a367ec86b47f201884152">psa_aead_decrypt_setup()</a>. The choice of setup function determines whether this function encrypts or decrypts its input.</li>
-<li>Set the nonce with <a class="el" href="group__aead.html#ga3eadcf2a29f662129ea4fb3454969ba2">psa_aead_generate_nonce()</a> or <a class="el" href="group__aead.html#ga40641d0721ca7fe01bbcd9ef635fbc46">psa_aead_set_nonce()</a>.</li>
-<li>Call <a class="el" href="group__aead.html#ga6d0eed03f832e5c9c91cb8adf2882569">psa_aead_update_ad()</a> to pass all the additional data.</li>
-</ol>
-<p>If this function returns an error status, the operation becomes inactive.</p>
-<dl class="section warning"><dt>Warning</dt><dd>When decrypting, until <a class="el" href="group__aead.html#gaaed211fc61977c859d6ff07f39f59219">psa_aead_verify()</a> has returned <a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a>, there is no guarantee that the input is valid. Therefore, until you have called <a class="el" href="group__aead.html#gaaed211fc61977c859d6ff07f39f59219">psa_aead_verify()</a> and it has returned <a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a>:<ul>
-<li>Do not use the output in any way other than storing it in a confidential location. If you take any action that depends on the tentative decrypted data, this action will need to be undone if the input turns out not to be valid. Furthermore, if an adversary can observe that this action took place (for example through timing), they may be able to use this fact as an oracle to decrypt any message encrypted with the same key.</li>
-<li>In particular, do not copy the output anywhere but to a memory or storage space that you have exclusive access to.</li>
-</ul>
-</dd></dl>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">operation</td><td>Active AEAD operation. </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">input</td><td>Buffer containing the message fragment to encrypt or decrypt. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">input_length</td><td>Size of the <code>input</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">output</td><td>Buffer where the output is to be written. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">output_size</td><td>Size of the <code>output</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">output_length</td><td>On success, the number of bytes that make up the returned output.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The operation state is not valid (not set up, nonce not set or already completed). </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga695025f4ec11249aee7ea3d0f65e01c8">PSA_ERROR_BUFFER_TOO_SMALL</a></td><td>The size of the <code>output</code> buffer is too small. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td>The total length of input to <a class="el" href="group__aead.html#ga6d0eed03f832e5c9c91cb8adf2882569">psa_aead_update_ad()</a> so far is less than the additional data length that was previously specified with <a class="el" href="group__aead.html#gad3431e28d05002c2a7b0760610176050">psa_aead_set_lengths()</a>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td>The total input length overflows the plaintext length that was previously specified with <a class="el" href="group__aead.html#gad3431e28d05002c2a7b0760610176050">psa_aead_set_lengths()</a>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga6d0eed03f832e5c9c91cb8adf2882569"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_aead_update_ad </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> * </td>
- <td class="paramname"><em>operation</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>input</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>input_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Pass additional data to an active AEAD operation.</p>
-<p>Additional data is authenticated, but not encrypted.</p>
-<p>You may call this function multiple times to pass successive fragments of the additional data. You may not call this function after passing data to encrypt or decrypt with <a class="el" href="group__aead.html#ga3b105de2088cef7c3d9e2fd8048c841c">psa_aead_update()</a>.</p>
-<p>Before calling this function, you must:</p><ol type="1">
-<li>Call either <a class="el" href="group__aead.html#ga47265dc4852f1476f852752218fd12b2">psa_aead_encrypt_setup()</a> or <a class="el" href="group__aead.html#ga439896519d4a367ec86b47f201884152">psa_aead_decrypt_setup()</a>.</li>
-<li>Set the nonce with <a class="el" href="group__aead.html#ga3eadcf2a29f662129ea4fb3454969ba2">psa_aead_generate_nonce()</a> or <a class="el" href="group__aead.html#ga40641d0721ca7fe01bbcd9ef635fbc46">psa_aead_set_nonce()</a>.</li>
-</ol>
-<p>If this function returns an error status, the operation becomes inactive.</p>
-<dl class="section warning"><dt>Warning</dt><dd>When decrypting, until <a class="el" href="group__aead.html#gaaed211fc61977c859d6ff07f39f59219">psa_aead_verify()</a> has returned <a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a>, there is no guarantee that the input is valid. Therefore, until you have called <a class="el" href="group__aead.html#gaaed211fc61977c859d6ff07f39f59219">psa_aead_verify()</a> and it has returned <a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a>, treat the input as untrusted and prepare to undo any action that depends on the input if <a class="el" href="group__aead.html#gaaed211fc61977c859d6ff07f39f59219">psa_aead_verify()</a> returns an error status.</dd></dl>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">operation</td><td>Active AEAD operation. </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">input</td><td>Buffer containing the fragment of additional data. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">input_length</td><td>Size of the <code>input</code> buffer in bytes.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The operation state is not valid (not set up, nonce not set, <a class="el" href="group__aead.html#ga3b105de2088cef7c3d9e2fd8048c841c">psa_aead_update()</a> already called, or operation already completed). </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td>The total input length overflows the additional data length that was previously specified with <a class="el" href="group__aead.html#gad3431e28d05002c2a7b0760610176050">psa_aead_set_lengths()</a>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="gaaed211fc61977c859d6ff07f39f59219"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_aead_verify </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed">psa_aead_operation_t</a> * </td>
- <td class="paramname"><em>operation</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>tag</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>tag_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Finish authenticating and decrypting a message in an AEAD operation.</p>
-<p>The operation must have been set up with <a class="el" href="group__aead.html#ga439896519d4a367ec86b47f201884152">psa_aead_decrypt_setup()</a>.</p>
-<p>This function finishes the authentication of the additional data formed by concatenating the inputs passed to preceding calls to <a class="el" href="group__aead.html#ga6d0eed03f832e5c9c91cb8adf2882569">psa_aead_update_ad()</a> with the ciphertext formed by concatenating the inputs passed to preceding calls to <a class="el" href="group__aead.html#ga3b105de2088cef7c3d9e2fd8048c841c">psa_aead_update()</a>.</p>
-<p>When this function returns, the operation becomes inactive.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">operation</td><td>Active AEAD operation. </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">tag</td><td>Buffer containing the authentication tag. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">tag_length</td><td>Size of the <code>tag</code> buffer in bytes.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The operation state is not valid (not set up, nonce not set, encryption, or already completed). </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga695025f4ec11249aee7ea3d0f65e01c8">PSA_ERROR_BUFFER_TOO_SMALL</a></td><td>The size of the <code>output</code> buffer is too small. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td>The total length of input to <a class="el" href="group__aead.html#ga6d0eed03f832e5c9c91cb8adf2882569">psa_aead_update_ad()</a> so far is less than the additional data length that was previously specified with <a class="el" href="group__aead.html#gad3431e28d05002c2a7b0760610176050">psa_aead_set_lengths()</a>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td>The total length of input to <a class="el" href="group__aead.html#ga3b105de2088cef7c3d9e2fd8048c841c">psa_aead_update()</a> so far is less than the plaintext length that was previously specified with <a class="el" href="group__aead.html#gad3431e28d05002c2a7b0760610176050">psa_aead_set_lengths()</a>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/group__asymmetric.html b/docs/html/group__asymmetric.html
deleted file mode 100644
index be442fb..0000000
--- a/docs/html/group__asymmetric.html
+++ /dev/null
@@ -1,490 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: Asymmetric cryptography</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li class="current"><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
-</div><!-- top -->
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div class="header">
- <div class="summary">
-<a href="#func-members">Functions</a> </div>
- <div class="headertitle">
-<div class="title">Asymmetric cryptography</div> </div>
-</div><!--header-->
-<div class="contents">
-<table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="func-members"></a>
-Functions</h2></td></tr>
-<tr class="memitem:ga1b0db9d345b5048cdd39357ac2d56c07"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__asymmetric.html#ga1b0db9d345b5048cdd39357ac2d56c07">psa_asymmetric_sign</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg, const uint8_t *hash, size_t hash_length, uint8_t *signature, size_t signature_size, size_t *signature_length)</td></tr>
-<tr class="memdesc:ga1b0db9d345b5048cdd39357ac2d56c07"><td class="mdescLeft"> </td><td class="mdescRight">Sign a hash or short message with a private key. <a href="#ga1b0db9d345b5048cdd39357ac2d56c07">More...</a><br /></td></tr>
-<tr class="separator:ga1b0db9d345b5048cdd39357ac2d56c07"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1b8e964c8d927e3d632325d762959eb7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__asymmetric.html#ga1b8e964c8d927e3d632325d762959eb7">psa_asymmetric_verify</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg, const uint8_t *hash, size_t hash_length, const uint8_t *signature, size_t signature_length)</td></tr>
-<tr class="memdesc:ga1b8e964c8d927e3d632325d762959eb7"><td class="mdescLeft"> </td><td class="mdescRight">Verify the signature a hash or short message using a public key. <a href="#ga1b8e964c8d927e3d632325d762959eb7">More...</a><br /></td></tr>
-<tr class="separator:ga1b8e964c8d927e3d632325d762959eb7"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gad429293b7b0bf2a830b9540a02552004"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__asymmetric.html#gad429293b7b0bf2a830b9540a02552004">psa_asymmetric_encrypt</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg, const uint8_t *input, size_t input_length, const uint8_t *salt, size_t salt_length, uint8_t *output, size_t output_size, size_t *output_length)</td></tr>
-<tr class="memdesc:gad429293b7b0bf2a830b9540a02552004"><td class="mdescLeft"> </td><td class="mdescRight">Encrypt a short message with a public key. <a href="#gad429293b7b0bf2a830b9540a02552004">More...</a><br /></td></tr>
-<tr class="separator:gad429293b7b0bf2a830b9540a02552004"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga34b55fbaee23dba1a677186fc66a556e"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__asymmetric.html#ga34b55fbaee23dba1a677186fc66a556e">psa_asymmetric_decrypt</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg, const uint8_t *input, size_t input_length, const uint8_t *salt, size_t salt_length, uint8_t *output, size_t output_size, size_t *output_length)</td></tr>
-<tr class="memdesc:ga34b55fbaee23dba1a677186fc66a556e"><td class="mdescLeft"> </td><td class="mdescRight">Decrypt a short message with a private key. <a href="#ga34b55fbaee23dba1a677186fc66a556e">More...</a><br /></td></tr>
-<tr class="separator:ga34b55fbaee23dba1a677186fc66a556e"><td class="memSeparator" colspan="2"> </td></tr>
-</table>
-<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
-<h2 class="groupheader">Function Documentation</h2>
-<a class="anchor" id="ga34b55fbaee23dba1a677186fc66a556e"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_asymmetric_decrypt </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> </td>
- <td class="paramname"><em>alg</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>input</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>input_length</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>salt</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>salt_length</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">uint8_t * </td>
- <td class="paramname"><em>output</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>output_size</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t * </td>
- <td class="paramname"><em>output_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-
-<p>Decrypt a short message with a private key. </p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir"></td><td class="paramname">handle</td><td>Handle to the key to use for the operation. It must be an asymmetric key pair. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">alg</td><td>An asymmetric encryption algorithm that is compatible with the type of <code>key</code>. </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">input</td><td>The message to decrypt. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">input_length</td><td>Size of the <code>input</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">salt</td><td>A salt or label, if supported by the encryption algorithm. If the algorithm does not support a salt, pass <code>NULL</code>. If the algorithm supports an optional salt and you do not want to pass a salt, pass <code>NULL</code>.</td></tr>
- </table>
- </dd>
-</dl>
-<ul>
-<li>For <a class="el" href="group__crypto__types.html#ga4c540d3abe43fb9abcb94f2bc51acef9">PSA_ALG_RSA_PKCS1V15_CRYPT</a>, no salt is supported. <dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir"></td><td class="paramname">salt_length</td><td>Size of the <code>salt</code> buffer in bytes. If <code>salt</code> is <code>NULL</code>, pass 0. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">output</td><td>Buffer where the decrypted message is to be written. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">output_size</td><td>Size of the <code>output</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">output_length</td><td>On success, the number of bytes that make up the returned output.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga695025f4ec11249aee7ea3d0f65e01c8">PSA_ERROR_BUFFER_TOO_SMALL</a></td><td>The size of the <code>output</code> buffer is too small. You can determine a sufficient buffer size by calling <a class="el" href="crypto__sizes_8h.html#a61a246f3eac41989821d982e56fea6c1">PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE</a>(<code>key_type</code>, <code>key_bits</code>, <code>alg</code>) where <code>key_type</code> and <code>key_bits</code> are the type and bit-size respectively of <code>key</code>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4deb59fec02297ec5d8b42178323f675">PSA_ERROR_INSUFFICIENT_ENTROPY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gabe29594edbfb152cf153975b0597ac48">PSA_ERROR_INVALID_PADDING</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The library has not been previously initialized by <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a>. It is implementation-dependent whether a failure to initialize results in this error code. </td></tr>
- </table>
- </dd>
-</dl>
-</li>
-</ul>
-
-</div>
-</div>
-<a class="anchor" id="gad429293b7b0bf2a830b9540a02552004"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_asymmetric_encrypt </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> </td>
- <td class="paramname"><em>alg</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>input</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>input_length</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>salt</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>salt_length</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">uint8_t * </td>
- <td class="paramname"><em>output</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>output_size</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t * </td>
- <td class="paramname"><em>output_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-
-<p>Encrypt a short message with a public key. </p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir"></td><td class="paramname">handle</td><td>Handle to the key to use for the operation. It must be a public key or an asymmetric key pair. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">alg</td><td>An asymmetric encryption algorithm that is compatible with the type of <code>key</code>. </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">input</td><td>The message to encrypt. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">input_length</td><td>Size of the <code>input</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">salt</td><td>A salt or label, if supported by the encryption algorithm. If the algorithm does not support a salt, pass <code>NULL</code>. If the algorithm supports an optional salt and you do not want to pass a salt, pass <code>NULL</code>.</td></tr>
- </table>
- </dd>
-</dl>
-<ul>
-<li>For <a class="el" href="group__crypto__types.html#ga4c540d3abe43fb9abcb94f2bc51acef9">PSA_ALG_RSA_PKCS1V15_CRYPT</a>, no salt is supported. <dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir"></td><td class="paramname">salt_length</td><td>Size of the <code>salt</code> buffer in bytes. If <code>salt</code> is <code>NULL</code>, pass 0. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">output</td><td>Buffer where the encrypted message is to be written. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">output_size</td><td>Size of the <code>output</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">output_length</td><td>On success, the number of bytes that make up the returned output.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga695025f4ec11249aee7ea3d0f65e01c8">PSA_ERROR_BUFFER_TOO_SMALL</a></td><td>The size of the <code>output</code> buffer is too small. You can determine a sufficient buffer size by calling <a class="el" href="crypto__sizes_8h.html#a66ba3bd93e5ec52870ccc3848778bad8">PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE</a>(<code>key_type</code>, <code>key_bits</code>, <code>alg</code>) where <code>key_type</code> and <code>key_bits</code> are the type and bit-size respectively of <code>key</code>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4deb59fec02297ec5d8b42178323f675">PSA_ERROR_INSUFFICIENT_ENTROPY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The library has not been previously initialized by <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a>. It is implementation-dependent whether a failure to initialize results in this error code. </td></tr>
- </table>
- </dd>
-</dl>
-</li>
-</ul>
-
-</div>
-</div>
-<a class="anchor" id="ga1b0db9d345b5048cdd39357ac2d56c07"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_asymmetric_sign </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> </td>
- <td class="paramname"><em>alg</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>hash</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>hash_length</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">uint8_t * </td>
- <td class="paramname"><em>signature</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>signature_size</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t * </td>
- <td class="paramname"><em>signature_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-
-<p>Sign a hash or short message with a private key. </p>
-<p>Note that to perform a hash-and-sign signature algorithm, you must first calculate the hash by calling <a class="el" href="group__hash.html#ga8d72896cf70fc4d514c5c6b978912515">psa_hash_setup()</a>, <a class="el" href="group__hash.html#ga65b16ef97d7f650899b7db4b7d1112ff">psa_hash_update()</a> and <a class="el" href="group__hash.html#ga4795fd06a0067b0adcd92e9627b8c97e">psa_hash_finish()</a>. Then pass the resulting hash as the <code>hash</code> parameter to this function. You can use <a class="el" href="group__crypto__types.html#ga24cf6d7bcd2b9aeeeff86f07b6c674e3">PSA_ALG_SIGN_GET_HASH</a>(<code>alg</code>) to determine the hash algorithm to use.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir"></td><td class="paramname">handle</td><td>Handle to the key to use for the operation. It must be an asymmetric key pair. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">alg</td><td>A signature algorithm that is compatible with the type of <code>key</code>. </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">hash</td><td>The hash or message to sign. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">hash_length</td><td>Size of the <code>hash</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">signature</td><td>Buffer where the signature is to be written. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">signature_size</td><td>Size of the <code>signature</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">signature_length</td><td>On success, the number of bytes that make up the returned signature value.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga695025f4ec11249aee7ea3d0f65e01c8">PSA_ERROR_BUFFER_TOO_SMALL</a></td><td>The size of the <code>signature</code> buffer is too small. You can determine a sufficient buffer size by calling <a class="el" href="crypto__sizes_8h.html#a77565b9b4fe6d8730fd2120f4c8378ab">PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE</a>(<code>key_type</code>, <code>key_bits</code>, <code>alg</code>) where <code>key_type</code> and <code>key_bits</code> are the type and bit-size respectively of <code>key</code>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4deb59fec02297ec5d8b42178323f675">PSA_ERROR_INSUFFICIENT_ENTROPY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The library has not been previously initialized by <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a>. It is implementation-dependent whether a failure to initialize results in this error code. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga1b8e964c8d927e3d632325d762959eb7"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_asymmetric_verify </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> </td>
- <td class="paramname"><em>alg</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>hash</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>hash_length</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>signature</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>signature_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-
-<p>Verify the signature a hash or short message using a public key. </p>
-<p>Note that to perform a hash-and-sign signature algorithm, you must first calculate the hash by calling <a class="el" href="group__hash.html#ga8d72896cf70fc4d514c5c6b978912515">psa_hash_setup()</a>, <a class="el" href="group__hash.html#ga65b16ef97d7f650899b7db4b7d1112ff">psa_hash_update()</a> and <a class="el" href="group__hash.html#ga4795fd06a0067b0adcd92e9627b8c97e">psa_hash_finish()</a>. Then pass the resulting hash as the <code>hash</code> parameter to this function. You can use <a class="el" href="group__crypto__types.html#ga24cf6d7bcd2b9aeeeff86f07b6c674e3">PSA_ALG_SIGN_GET_HASH</a>(<code>alg</code>) to determine the hash algorithm to use.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir"></td><td class="paramname">handle</td><td>Handle to the key to use for the operation. It must be a public key or an asymmetric key pair. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">alg</td><td>A signature algorithm that is compatible with the type of <code>key</code>. </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">hash</td><td>The hash or message whose signature is to be verified. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">hash_length</td><td>Size of the <code>hash</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">signature</td><td>Buffer containing the signature to verify. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">signature_length</td><td>Size of the <code>signature</code> buffer in bytes.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>The signature is valid. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga35927f755d232c4766de600f2c49e9f2">PSA_ERROR_INVALID_SIGNATURE</a></td><td>The calculation was perfomed successfully, but the passed signature is not a valid signature. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The library has not been previously initialized by <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a>. It is implementation-dependent whether a failure to initialize results in this error code. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/group__cipher.html b/docs/html/group__cipher.html
deleted file mode 100644
index 67bb06a..0000000
--- a/docs/html/group__cipher.html
+++ /dev/null
@@ -1,778 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: Symmetric ciphers</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li class="current"><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
-</div><!-- top -->
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div class="header">
- <div class="summary">
-<a href="#define-members">Macros</a> |
-<a href="#typedef-members">Typedefs</a> |
-<a href="#func-members">Functions</a> </div>
- <div class="headertitle">
-<div class="title">Symmetric ciphers</div> </div>
-</div><!--header-->
-<div class="contents">
-<table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="define-members"></a>
-Macros</h2></td></tr>
-<tr class="memitem:ga2da0541aabf9a4995cf2004e36311919"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__cipher.html#ga2da0541aabf9a4995cf2004e36311919">PSA_CIPHER_OPERATION_INIT</a>   {0}</td></tr>
-<tr class="separator:ga2da0541aabf9a4995cf2004e36311919"><td class="memSeparator" colspan="2"> </td></tr>
-</table><table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="typedef-members"></a>
-Typedefs</h2></td></tr>
-<tr class="memitem:ga1399de29db657e3737bb09927aae51fa"><td class="memItemLeft" align="right" valign="top">typedef struct psa_cipher_operation_s </td><td class="memItemRight" valign="bottom"><a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a></td></tr>
-<tr class="separator:ga1399de29db657e3737bb09927aae51fa"><td class="memSeparator" colspan="2"> </td></tr>
-</table><table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="func-members"></a>
-Functions</h2></td></tr>
-<tr class="memitem:gac76dda492d9a1ba6b327bff610ec17b2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__cipher.html#gac76dda492d9a1ba6b327bff610ec17b2">psa_cipher_encrypt</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg, const uint8_t *input, size_t input_length, uint8_t *output, size_t output_size, size_t *output_length)</td></tr>
-<tr class="separator:gac76dda492d9a1ba6b327bff610ec17b2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga43d5991711ec45c98af0c1d99f6e0216"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__cipher.html#ga43d5991711ec45c98af0c1d99f6e0216">psa_cipher_decrypt</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg, const uint8_t *input, size_t input_length, uint8_t *output, size_t output_size, size_t *output_length)</td></tr>
-<tr class="separator:ga43d5991711ec45c98af0c1d99f6e0216"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga2a7fc79a9d150d42dba99f40ee3a185e"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__cipher.html#ga2a7fc79a9d150d42dba99f40ee3a185e">psa_cipher_encrypt_setup</a> (<a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> *operation, <a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg)</td></tr>
-<tr class="separator:ga2a7fc79a9d150d42dba99f40ee3a185e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaddf8504e5367cd0efb4415bdec004f44"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__cipher.html#gaddf8504e5367cd0efb4415bdec004f44">psa_cipher_decrypt_setup</a> (<a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> *operation, <a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg)</td></tr>
-<tr class="separator:gaddf8504e5367cd0efb4415bdec004f44"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga44857cf5e0c3d134a3c560f8ff5b50aa"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__cipher.html#ga44857cf5e0c3d134a3c560f8ff5b50aa">psa_cipher_generate_iv</a> (<a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> *operation, unsigned char *iv, size_t iv_size, size_t *iv_length)</td></tr>
-<tr class="separator:ga44857cf5e0c3d134a3c560f8ff5b50aa"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1359b2101f31637496ce7cc36c6e3d42"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__cipher.html#ga1359b2101f31637496ce7cc36c6e3d42">psa_cipher_set_iv</a> (<a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> *operation, const unsigned char *iv, size_t iv_length)</td></tr>
-<tr class="separator:ga1359b2101f31637496ce7cc36c6e3d42"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gafd0caea99cf1052527e4089d37f5ab91"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__cipher.html#gafd0caea99cf1052527e4089d37f5ab91">psa_cipher_update</a> (<a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> *operation, const uint8_t *input, size_t input_length, unsigned char *output, size_t output_size, size_t *output_length)</td></tr>
-<tr class="separator:gafd0caea99cf1052527e4089d37f5ab91"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1dcb58b8befe23f8a4d7a1d49c99249b"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__cipher.html#ga1dcb58b8befe23f8a4d7a1d49c99249b">psa_cipher_finish</a> (<a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> *operation, uint8_t *output, size_t output_size, size_t *output_length)</td></tr>
-<tr class="separator:ga1dcb58b8befe23f8a4d7a1d49c99249b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaad482cdca2098bca0620596aaa02eaa4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__cipher.html#gaad482cdca2098bca0620596aaa02eaa4">psa_cipher_abort</a> (<a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> *operation)</td></tr>
-<tr class="separator:gaad482cdca2098bca0620596aaa02eaa4"><td class="memSeparator" colspan="2"> </td></tr>
-</table>
-<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
-<h2 class="groupheader">Macro Definition Documentation</h2>
-<a class="anchor" id="ga2da0541aabf9a4995cf2004e36311919"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_CIPHER_OPERATION_INIT   {0}</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>This macro returns a suitable initializer for a cipher operation object of type <a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a>. </p>
-
-</div>
-</div>
-<h2 class="groupheader">Typedef Documentation</h2>
-<a class="anchor" id="ga1399de29db657e3737bb09927aae51fa"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">typedef struct psa_cipher_operation_s <a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The type of the state data structure for multipart cipher operations.</p>
-<p>Before calling any function on a cipher operation object, the application must initialize it by any of the following means:</p><ul>
-<li>Set the structure to all-bits-zero, for example: <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> psa_cipher_operation_t operation;</div><div class="line"><a name="l00002"></a><span class="lineno"> 2</span> memset(&operation, 0, sizeof(operation));</div></div><!-- fragment --></li>
-<li>Initialize the structure to logical zero values, for example: <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> psa_cipher_operation_t operation = {0};</div></div><!-- fragment --></li>
-<li>Initialize the structure to the initializer <a class="el" href="group__cipher.html#ga2da0541aabf9a4995cf2004e36311919">PSA_CIPHER_OPERATION_INIT</a>, for example: <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;</div></div><!-- fragment --></li>
-<li>Assign the result of the function psa_cipher_operation_init() to the structure, for example: <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> psa_cipher_operation_t operation;</div><div class="line"><a name="l00002"></a><span class="lineno"> 2</span> operation = psa_cipher_operation_init();</div></div><!-- fragment --></li>
-</ul>
-<p>This is an implementation-defined <code>struct</code>. Applications should not make any assumptions about the content of this structure except as directed by the documentation of a specific implementation. </p>
-
-</div>
-</div>
-<h2 class="groupheader">Function Documentation</h2>
-<a class="anchor" id="gaad482cdca2098bca0620596aaa02eaa4"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_cipher_abort </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> * </td>
- <td class="paramname"><em>operation</em></td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Abort a cipher operation.</p>
-<p>Aborting an operation frees all associated resources except for the <code>operation</code> structure itself. Once aborted, the operation object can be reused for another operation by calling <a class="el" href="group__cipher.html#ga2a7fc79a9d150d42dba99f40ee3a185e">psa_cipher_encrypt_setup()</a> or <a class="el" href="group__cipher.html#gaddf8504e5367cd0efb4415bdec004f44">psa_cipher_decrypt_setup()</a> again.</p>
-<p>You may call this function any time after the operation object has been initialized by any of the following methods:</p><ul>
-<li>A call to <a class="el" href="group__cipher.html#ga2a7fc79a9d150d42dba99f40ee3a185e">psa_cipher_encrypt_setup()</a> or <a class="el" href="group__cipher.html#gaddf8504e5367cd0efb4415bdec004f44">psa_cipher_decrypt_setup()</a>, whether it succeeds or not.</li>
-<li>Initializing the <code>struct</code> to all-bits-zero.</li>
-<li>Initializing the <code>struct</code> to logical zeros, e.g. <code>psa_cipher_operation_t operation = {0}</code>.</li>
-</ul>
-<p>In particular, calling <a class="el" href="group__cipher.html#gaad482cdca2098bca0620596aaa02eaa4">psa_cipher_abort()</a> after the operation has been terminated by a call to <a class="el" href="group__cipher.html#gaad482cdca2098bca0620596aaa02eaa4">psa_cipher_abort()</a> or <a class="el" href="group__cipher.html#ga1dcb58b8befe23f8a4d7a1d49c99249b">psa_cipher_finish()</a> is safe and has no effect.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">operation</td><td>Initialized cipher operation.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td><code>operation</code> is not an active cipher operation. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga43d5991711ec45c98af0c1d99f6e0216"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_cipher_decrypt </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> </td>
- <td class="paramname"><em>alg</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>input</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>input_length</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">uint8_t * </td>
- <td class="paramname"><em>output</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>output_size</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t * </td>
- <td class="paramname"><em>output_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Decrypt a message using a symmetric cipher.</p>
-<p>This function decrypts a message encrypted with a symmetric cipher.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir"></td><td class="paramname">handle</td><td>Handle to the key to use for the operation. It must remain valid until the operation terminates. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">alg</td><td>The cipher algorithm to compute (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#ga1d1a5a402ad89a2e68f12bfb535490eb">PSA_ALG_IS_CIPHER</a>(<code>alg</code>) is true). </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">input</td><td>Buffer containing the message to decrypt. This consists of the IV followed by the ciphertext proper. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">input_length</td><td>Size of the <code>input</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">output</td><td>Buffer where the plaintext is to be written. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">output_size</td><td>Size of the <code>output</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">output_length</td><td>On success, the number of bytes that make up the output.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040">PSA_ERROR_EMPTY_SLOT</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4d1b8dd8526177a15a210b7afc1accb1">PSA_ERROR_NOT_PERMITTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td><code>key</code> is not compatible with <code>alg</code>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td><code>alg</code> is not supported or is not a cipher algorithm. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga695025f4ec11249aee7ea3d0f65e01c8">PSA_ERROR_BUFFER_TOO_SMALL</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="gaddf8504e5367cd0efb4415bdec004f44"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_cipher_decrypt_setup </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> * </td>
- <td class="paramname"><em>operation</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> </td>
- <td class="paramname"><em>alg</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Set the key for a multipart symmetric decryption operation.</p>
-<p>The sequence of operations to decrypt a message with a symmetric cipher is as follows:</p><ol type="1">
-<li>Allocate an operation object which will be passed to all the functions listed here.</li>
-<li>Initialize the operation object with one of the methods described in the documentation for <a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a>, e.g. PSA_CIPHER_OPERATION_INIT.</li>
-<li>Call <a class="el" href="group__cipher.html#gaddf8504e5367cd0efb4415bdec004f44">psa_cipher_decrypt_setup()</a> to specify the algorithm and key.</li>
-<li>Call <a class="el" href="group__cipher.html#ga1359b2101f31637496ce7cc36c6e3d42">psa_cipher_set_iv()</a> with the IV (initialization vector) for the decryption. If the IV is prepended to the ciphertext, you can call <a class="el" href="group__cipher.html#gafd0caea99cf1052527e4089d37f5ab91">psa_cipher_update()</a> on a buffer containing the IV followed by the beginning of the message.</li>
-<li>Call <a class="el" href="group__cipher.html#gafd0caea99cf1052527e4089d37f5ab91">psa_cipher_update()</a> zero, one or more times, passing a fragment of the message each time.</li>
-<li>Call <a class="el" href="group__cipher.html#ga1dcb58b8befe23f8a4d7a1d49c99249b">psa_cipher_finish()</a>.</li>
-</ol>
-<p>The application may call <a class="el" href="group__cipher.html#gaad482cdca2098bca0620596aaa02eaa4">psa_cipher_abort()</a> at any time after the operation has been initialized.</p>
-<p>After a successful call to <a class="el" href="group__cipher.html#gaddf8504e5367cd0efb4415bdec004f44">psa_cipher_decrypt_setup()</a>, the application must eventually terminate the operation. The following events terminate an operation:</p><ul>
-<li>A failed call to any of the <code>psa_cipher_xxx</code> functions.</li>
-<li>A call to <a class="el" href="group__cipher.html#ga1dcb58b8befe23f8a4d7a1d49c99249b">psa_cipher_finish()</a> or <a class="el" href="group__cipher.html#gaad482cdca2098bca0620596aaa02eaa4">psa_cipher_abort()</a>.</li>
-</ul>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">operation</td><td>The operation object to set up. It must have been initialized as per the documentation for <a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> and not yet in use. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">handle</td><td>Handle to the key to use for the operation. It must remain valid until the operation terminates. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">alg</td><td>The cipher algorithm to compute (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#ga1d1a5a402ad89a2e68f12bfb535490eb">PSA_ALG_IS_CIPHER</a>(<code>alg</code>) is true).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040">PSA_ERROR_EMPTY_SLOT</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4d1b8dd8526177a15a210b7afc1accb1">PSA_ERROR_NOT_PERMITTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td><code>key</code> is not compatible with <code>alg</code>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td><code>alg</code> is not supported or is not a cipher algorithm. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The library has not been previously initialized by <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a>. It is implementation-dependent whether a failure to initialize results in this error code. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="gac76dda492d9a1ba6b327bff610ec17b2"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_cipher_encrypt </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> </td>
- <td class="paramname"><em>alg</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>input</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>input_length</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">uint8_t * </td>
- <td class="paramname"><em>output</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>output_size</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t * </td>
- <td class="paramname"><em>output_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Encrypt a message using a symmetric cipher.</p>
-<p>This function encrypts a message with a random IV (initialization vector).</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir"></td><td class="paramname">handle</td><td>Handle to the key to use for the operation. It must remain valid until the operation terminates. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">alg</td><td>The cipher algorithm to compute (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#ga1d1a5a402ad89a2e68f12bfb535490eb">PSA_ALG_IS_CIPHER</a>(<code>alg</code>) is true). </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">input</td><td>Buffer containing the message to encrypt. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">input_length</td><td>Size of the <code>input</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">output</td><td>Buffer where the output is to be written. The output contains the IV followed by the ciphertext proper. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">output_size</td><td>Size of the <code>output</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">output_length</td><td>On success, the number of bytes that make up the output.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040">PSA_ERROR_EMPTY_SLOT</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4d1b8dd8526177a15a210b7afc1accb1">PSA_ERROR_NOT_PERMITTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td><code>key</code> is not compatible with <code>alg</code>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td><code>alg</code> is not supported or is not a cipher algorithm. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga695025f4ec11249aee7ea3d0f65e01c8">PSA_ERROR_BUFFER_TOO_SMALL</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga2a7fc79a9d150d42dba99f40ee3a185e"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_cipher_encrypt_setup </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> * </td>
- <td class="paramname"><em>operation</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> </td>
- <td class="paramname"><em>alg</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Set the key for a multipart symmetric encryption operation.</p>
-<p>The sequence of operations to encrypt a message with a symmetric cipher is as follows:</p><ol type="1">
-<li>Allocate an operation object which will be passed to all the functions listed here.</li>
-<li>Initialize the operation object with one of the methods described in the documentation for <a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a>, e.g. PSA_CIPHER_OPERATION_INIT.</li>
-<li>Call <a class="el" href="group__cipher.html#ga2a7fc79a9d150d42dba99f40ee3a185e">psa_cipher_encrypt_setup()</a> to specify the algorithm and key.</li>
-<li>Call either <a class="el" href="group__cipher.html#ga44857cf5e0c3d134a3c560f8ff5b50aa">psa_cipher_generate_iv()</a> or <a class="el" href="group__cipher.html#ga1359b2101f31637496ce7cc36c6e3d42">psa_cipher_set_iv()</a> to generate or set the IV (initialization vector). You should use <a class="el" href="group__cipher.html#ga44857cf5e0c3d134a3c560f8ff5b50aa">psa_cipher_generate_iv()</a> unless the protocol you are implementing requires a specific IV value.</li>
-<li>Call <a class="el" href="group__cipher.html#gafd0caea99cf1052527e4089d37f5ab91">psa_cipher_update()</a> zero, one or more times, passing a fragment of the message each time.</li>
-<li>Call <a class="el" href="group__cipher.html#ga1dcb58b8befe23f8a4d7a1d49c99249b">psa_cipher_finish()</a>.</li>
-</ol>
-<p>The application may call <a class="el" href="group__cipher.html#gaad482cdca2098bca0620596aaa02eaa4">psa_cipher_abort()</a> at any time after the operation has been initialized.</p>
-<p>After a successful call to <a class="el" href="group__cipher.html#ga2a7fc79a9d150d42dba99f40ee3a185e">psa_cipher_encrypt_setup()</a>, the application must eventually terminate the operation. The following events terminate an operation:</p><ul>
-<li>A failed call to any of the <code>psa_cipher_xxx</code> functions.</li>
-<li>A call to <a class="el" href="group__cipher.html#ga1dcb58b8befe23f8a4d7a1d49c99249b">psa_cipher_finish()</a> or <a class="el" href="group__cipher.html#gaad482cdca2098bca0620596aaa02eaa4">psa_cipher_abort()</a>.</li>
-</ul>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">operation</td><td>The operation object to set up. It must have been initialized as per the documentation for <a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> and not yet in use. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">handle</td><td>Handle to the key to use for the operation. It must remain valid until the operation terminates. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">alg</td><td>The cipher algorithm to compute (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#ga1d1a5a402ad89a2e68f12bfb535490eb">PSA_ALG_IS_CIPHER</a>(<code>alg</code>) is true).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040">PSA_ERROR_EMPTY_SLOT</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4d1b8dd8526177a15a210b7afc1accb1">PSA_ERROR_NOT_PERMITTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td><code>key</code> is not compatible with <code>alg</code>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td><code>alg</code> is not supported or is not a cipher algorithm. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The library has not been previously initialized by <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a>. It is implementation-dependent whether a failure to initialize results in this error code. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga1dcb58b8befe23f8a4d7a1d49c99249b"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_cipher_finish </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> * </td>
- <td class="paramname"><em>operation</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">uint8_t * </td>
- <td class="paramname"><em>output</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>output_size</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t * </td>
- <td class="paramname"><em>output_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Finish encrypting or decrypting a message in a cipher operation.</p>
-<p>The application must call <a class="el" href="group__cipher.html#ga2a7fc79a9d150d42dba99f40ee3a185e">psa_cipher_encrypt_setup()</a> or <a class="el" href="group__cipher.html#gaddf8504e5367cd0efb4415bdec004f44">psa_cipher_decrypt_setup()</a> before calling this function. The choice of setup function determines whether this function encrypts or decrypts its input.</p>
-<p>This function finishes the encryption or decryption of the message formed by concatenating the inputs passed to preceding calls to <a class="el" href="group__cipher.html#gafd0caea99cf1052527e4089d37f5ab91">psa_cipher_update()</a>.</p>
-<p>When this function returns, the operation becomes inactive.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">operation</td><td>Active cipher operation. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">output</td><td>Buffer where the output is to be written. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">output_size</td><td>Size of the <code>output</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">output_length</td><td>On success, the number of bytes that make up the returned output.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The operation state is not valid (not set up, IV required but not set, or already completed). </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga695025f4ec11249aee7ea3d0f65e01c8">PSA_ERROR_BUFFER_TOO_SMALL</a></td><td>The size of the <code>output</code> buffer is too small. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga44857cf5e0c3d134a3c560f8ff5b50aa"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_cipher_generate_iv </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> * </td>
- <td class="paramname"><em>operation</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">unsigned char * </td>
- <td class="paramname"><em>iv</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>iv_size</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t * </td>
- <td class="paramname"><em>iv_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Generate an IV for a symmetric encryption operation.</p>
-<p>This function generates a random IV (initialization vector), nonce or initial counter value for the encryption operation as appropriate for the chosen algorithm, key type and key size.</p>
-<p>The application must call <a class="el" href="group__cipher.html#ga2a7fc79a9d150d42dba99f40ee3a185e">psa_cipher_encrypt_setup()</a> before calling this function.</p>
-<p>If this function returns an error status, the operation becomes inactive.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">operation</td><td>Active cipher operation. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">iv</td><td>Buffer where the generated IV is to be written. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">iv_size</td><td>Size of the <code>iv</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">iv_length</td><td>On success, the number of bytes of the generated IV.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The operation state is not valid (not set up, or IV already set). </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga695025f4ec11249aee7ea3d0f65e01c8">PSA_ERROR_BUFFER_TOO_SMALL</a></td><td>The size of the <code>iv</code> buffer is too small. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga1359b2101f31637496ce7cc36c6e3d42"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_cipher_set_iv </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> * </td>
- <td class="paramname"><em>operation</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const unsigned char * </td>
- <td class="paramname"><em>iv</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>iv_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Set the IV for a symmetric encryption or decryption operation.</p>
-<p>This function sets the IV (initialization vector), nonce or initial counter value for the encryption or decryption operation.</p>
-<p>The application must call <a class="el" href="group__cipher.html#ga2a7fc79a9d150d42dba99f40ee3a185e">psa_cipher_encrypt_setup()</a> before calling this function.</p>
-<p>If this function returns an error status, the operation becomes inactive.</p>
-<dl class="section note"><dt>Note</dt><dd>When encrypting, applications should use <a class="el" href="group__cipher.html#ga44857cf5e0c3d134a3c560f8ff5b50aa">psa_cipher_generate_iv()</a> instead of this function, unless implementing a protocol that requires a non-random IV.</dd></dl>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">operation</td><td>Active cipher operation. </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">iv</td><td>Buffer containing the IV to use. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">iv_length</td><td>Size of the IV in bytes.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The operation state is not valid (not set up, or IV already set). </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td>The size of <code>iv</code> is not acceptable for the chosen algorithm, or the chosen algorithm does not use an IV. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="gafd0caea99cf1052527e4089d37f5ab91"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_cipher_update </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__cipher.html#ga1399de29db657e3737bb09927aae51fa">psa_cipher_operation_t</a> * </td>
- <td class="paramname"><em>operation</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>input</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>input_length</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">unsigned char * </td>
- <td class="paramname"><em>output</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>output_size</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t * </td>
- <td class="paramname"><em>output_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Encrypt or decrypt a message fragment in an active cipher operation.</p>
-<p>Before calling this function, you must:</p><ol type="1">
-<li>Call either <a class="el" href="group__cipher.html#ga2a7fc79a9d150d42dba99f40ee3a185e">psa_cipher_encrypt_setup()</a> or <a class="el" href="group__cipher.html#gaddf8504e5367cd0efb4415bdec004f44">psa_cipher_decrypt_setup()</a>. The choice of setup function determines whether this function encrypts or decrypts its input.</li>
-<li>If the algorithm requires an IV, call <a class="el" href="group__cipher.html#ga44857cf5e0c3d134a3c560f8ff5b50aa">psa_cipher_generate_iv()</a> (recommended when encrypting) or <a class="el" href="group__cipher.html#ga1359b2101f31637496ce7cc36c6e3d42">psa_cipher_set_iv()</a>.</li>
-</ol>
-<p>If this function returns an error status, the operation becomes inactive.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">operation</td><td>Active cipher operation. </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">input</td><td>Buffer containing the message fragment to encrypt or decrypt. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">input_length</td><td>Size of the <code>input</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">output</td><td>Buffer where the output is to be written. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">output_size</td><td>Size of the <code>output</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">output_length</td><td>On success, the number of bytes that make up the returned output.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The operation state is not valid (not set up, IV required but not set, or already completed). </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga695025f4ec11249aee7ea3d0f65e01c8">PSA_ERROR_BUFFER_TOO_SMALL</a></td><td>The size of the <code>output</code> buffer is too small. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/group__crypto__types.html b/docs/html/group__crypto__types.html
deleted file mode 100644
index b4ff343..0000000
--- a/docs/html/group__crypto__types.html
+++ /dev/null
@@ -1,2566 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: Key and algorithm types</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li class="current"><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
-</div><!-- top -->
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div class="header">
- <div class="summary">
-<a href="#define-members">Macros</a> |
-<a href="#typedef-members">Typedefs</a> </div>
- <div class="headertitle">
-<div class="title">Key and algorithm types</div> </div>
-</div><!--header-->
-<div class="contents">
-<table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="define-members"></a>
-Macros</h2></td></tr>
-<tr class="memitem:gafce7ab2b54ce97ea5bff73f13a9f3e5b"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gafce7ab2b54ce97ea5bff73f13a9f3e5b">PSA_KEY_TYPE_NONE</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x00000000)</td></tr>
-<tr class="separator:gafce7ab2b54ce97ea5bff73f13a9f3e5b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga8dbaed2fdb1ebae8aa127ad3988516f7"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga8dbaed2fdb1ebae8aa127ad3988516f7">PSA_KEY_TYPE_VENDOR_FLAG</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x80000000)</td></tr>
-<tr class="separator:ga8dbaed2fdb1ebae8aa127ad3988516f7"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6eeda1b2a1550050cf68dbcac35ad8ac"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga6eeda1b2a1550050cf68dbcac35ad8ac"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_TYPE_CATEGORY_MASK</b>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x70000000)</td></tr>
-<tr class="separator:ga6eeda1b2a1550050cf68dbcac35ad8ac"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga8f214beb04334be08f927f227f097ef1"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga8f214beb04334be08f927f227f097ef1"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_TYPE_CATEGORY_SYMMETRIC</b>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x40000000)</td></tr>
-<tr class="separator:ga8f214beb04334be08f927f227f097ef1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab8af75718c5e7b8987720a3fe8abb18f"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gab8af75718c5e7b8987720a3fe8abb18f"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_TYPE_CATEGORY_RAW</b>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x50000000)</td></tr>
-<tr class="separator:gab8af75718c5e7b8987720a3fe8abb18f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga58b975beeee1f937cecb71c8051c6357"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga58b975beeee1f937cecb71c8051c6357"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY</b>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x60000000)</td></tr>
-<tr class="separator:ga58b975beeee1f937cecb71c8051c6357"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga708196a91ec0384de98e092b9a16f5e8"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga708196a91ec0384de98e092b9a16f5e8"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_TYPE_CATEGORY_KEY_PAIR</b>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x70000000)</td></tr>
-<tr class="separator:ga708196a91ec0384de98e092b9a16f5e8"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga5a77cb4db2d02ffce77631339e3240f4"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga5a77cb4db2d02ffce77631339e3240f4"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_TYPE_CATEGORY_FLAG_PAIR</b>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x10000000)</td></tr>
-<tr class="separator:ga5a77cb4db2d02ffce77631339e3240f4"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gadbe4c086a6562aefe344bc79e51bdfd3"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gadbe4c086a6562aefe344bc79e51bdfd3">PSA_KEY_TYPE_IS_VENDOR_DEFINED</a>(type)   (((type) & <a class="el" href="group__crypto__types.html#ga8dbaed2fdb1ebae8aa127ad3988516f7">PSA_KEY_TYPE_VENDOR_FLAG</a>) != 0)</td></tr>
-<tr class="separator:gadbe4c086a6562aefe344bc79e51bdfd3"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaef86ce4e810e1c2c76068ac874bfef54"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaef86ce4e810e1c2c76068ac874bfef54">PSA_KEY_TYPE_IS_UNSTRUCTURED</a>(type)</td></tr>
-<tr class="separator:gaef86ce4e810e1c2c76068ac874bfef54"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab138ae2ebf2905dfbaf4154db2620939"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gab138ae2ebf2905dfbaf4154db2620939">PSA_KEY_TYPE_IS_ASYMMETRIC</a>(type)</td></tr>
-<tr class="separator:gab138ae2ebf2905dfbaf4154db2620939"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac674a0f059bc0cb72b47f0c517b4f45b"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gac674a0f059bc0cb72b47f0c517b4f45b">PSA_KEY_TYPE_IS_PUBLIC_KEY</a>(type)   (((type) & PSA_KEY_TYPE_CATEGORY_MASK) == PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY)</td></tr>
-<tr class="separator:gac674a0f059bc0cb72b47f0c517b4f45b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac14c6d6e1b2b7f4a92a7b757465cff29"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gac14c6d6e1b2b7f4a92a7b757465cff29">PSA_KEY_TYPE_IS_KEYPAIR</a>(type)   (((type) & PSA_KEY_TYPE_CATEGORY_MASK) == PSA_KEY_TYPE_CATEGORY_KEY_PAIR)</td></tr>
-<tr class="separator:gac14c6d6e1b2b7f4a92a7b757465cff29"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaf09f1ca1de6a7e7cff0fe516f3f6c91d"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaf09f1ca1de6a7e7cff0fe516f3f6c91d">PSA_KEY_TYPE_KEYPAIR_OF_PUBLIC_KEY</a>(type)   ((type) | PSA_KEY_TYPE_CATEGORY_FLAG_PAIR)</td></tr>
-<tr class="separator:gaf09f1ca1de6a7e7cff0fe516f3f6c91d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gace08e46dd7cbf642d50d982a25d02bec"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gace08e46dd7cbf642d50d982a25d02bec">PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR</a>(type)   ((type) & ~PSA_KEY_TYPE_CATEGORY_FLAG_PAIR)</td></tr>
-<tr class="separator:gace08e46dd7cbf642d50d982a25d02bec"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa97f92025533102616b32d571c940d80"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaa97f92025533102616b32d571c940d80">PSA_KEY_TYPE_RAW_DATA</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x50000001)</td></tr>
-<tr class="separator:gaa97f92025533102616b32d571c940d80"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga92d989f4ca64abd00f463defd773a6f8"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga92d989f4ca64abd00f463defd773a6f8">PSA_KEY_TYPE_HMAC</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x51000000)</td></tr>
-<tr class="separator:ga92d989f4ca64abd00f463defd773a6f8"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae871b2357b8593f33bfd51abbf93ebb1"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gae871b2357b8593f33bfd51abbf93ebb1">PSA_KEY_TYPE_DERIVE</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x52000000)</td></tr>
-<tr class="separator:gae871b2357b8593f33bfd51abbf93ebb1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6ee54579dcf278c677eda4bb1a29575e"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga6ee54579dcf278c677eda4bb1a29575e">PSA_KEY_TYPE_AES</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x40000001)</td></tr>
-<tr class="separator:ga6ee54579dcf278c677eda4bb1a29575e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga577562bfbbc691c820d55ec308333138"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga577562bfbbc691c820d55ec308333138">PSA_KEY_TYPE_DES</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x40000002)</td></tr>
-<tr class="separator:ga577562bfbbc691c820d55ec308333138"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gad8e5da742343fd5519f9d8a630c2ed81"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gad8e5da742343fd5519f9d8a630c2ed81">PSA_KEY_TYPE_CAMELLIA</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x40000003)</td></tr>
-<tr class="separator:gad8e5da742343fd5519f9d8a630c2ed81"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae4d46e83f910dcaa126000a8ed03cde9"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gae4d46e83f910dcaa126000a8ed03cde9">PSA_KEY_TYPE_ARC4</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x40000004)</td></tr>
-<tr class="separator:gae4d46e83f910dcaa126000a8ed03cde9"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga9ba0878f56c8bcd1995ac017a74f513b"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga9ba0878f56c8bcd1995ac017a74f513b">PSA_KEY_TYPE_RSA_PUBLIC_KEY</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x60010000)</td></tr>
-<tr class="separator:ga9ba0878f56c8bcd1995ac017a74f513b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga581f50687f5d650456925278948f2799"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga581f50687f5d650456925278948f2799">PSA_KEY_TYPE_RSA_KEYPAIR</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x70010000)</td></tr>
-<tr class="separator:ga581f50687f5d650456925278948f2799"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga0e1d8f241228e49c9cadadfb4579ef1a"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga0e1d8f241228e49c9cadadfb4579ef1a">PSA_KEY_TYPE_IS_RSA</a>(type)   (<a class="el" href="group__crypto__types.html#gace08e46dd7cbf642d50d982a25d02bec">PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR</a>(type) == <a class="el" href="group__crypto__types.html#ga9ba0878f56c8bcd1995ac017a74f513b">PSA_KEY_TYPE_RSA_PUBLIC_KEY</a>)</td></tr>
-<tr class="separator:ga0e1d8f241228e49c9cadadfb4579ef1a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga5e7439c2905136366c3a876e62e5ddfc"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga5e7439c2905136366c3a876e62e5ddfc">PSA_KEY_TYPE_DSA_PUBLIC_KEY</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x60020000)</td></tr>
-<tr class="separator:ga5e7439c2905136366c3a876e62e5ddfc"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga011010ee28c20388f3d89fb27088ed62"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga011010ee28c20388f3d89fb27088ed62">PSA_KEY_TYPE_DSA_KEYPAIR</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x70020000)</td></tr>
-<tr class="separator:ga011010ee28c20388f3d89fb27088ed62"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga273fdfcf23eb0624f8b63d2321cf95c1"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga273fdfcf23eb0624f8b63d2321cf95c1">PSA_KEY_TYPE_IS_DSA</a>(type)   (<a class="el" href="group__crypto__types.html#gace08e46dd7cbf642d50d982a25d02bec">PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR</a>(type) == <a class="el" href="group__crypto__types.html#ga5e7439c2905136366c3a876e62e5ddfc">PSA_KEY_TYPE_DSA_PUBLIC_KEY</a>)</td></tr>
-<tr class="separator:ga273fdfcf23eb0624f8b63d2321cf95c1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gad8d37a32a305dda9fb4af1707aace47c"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gad8d37a32a305dda9fb4af1707aace47c"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE</b>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x60030000)</td></tr>
-<tr class="separator:gad8d37a32a305dda9fb4af1707aace47c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6754658749714c6ac674bdf6d2d40767"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga6754658749714c6ac674bdf6d2d40767"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_TYPE_ECC_KEYPAIR_BASE</b>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x70030000)</td></tr>
-<tr class="separator:ga6754658749714c6ac674bdf6d2d40767"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gadc2a3c0041ac1d0a2b6f421d8e089b25"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gadc2a3c0041ac1d0a2b6f421d8e089b25"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_KEY_TYPE_ECC_CURVE_MASK</b>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x0000ffff)</td></tr>
-<tr class="separator:gadc2a3c0041ac1d0a2b6f421d8e089b25"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gadf3ad65d157bf5282849c954bf3f51af"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gadf3ad65d157bf5282849c954bf3f51af">PSA_KEY_TYPE_ECC_KEYPAIR</a>(curve)   (PSA_KEY_TYPE_ECC_KEYPAIR_BASE | (curve))</td></tr>
-<tr class="separator:gadf3ad65d157bf5282849c954bf3f51af"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gad54c03d3b47020e571a72cd01d978cf2"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gad54c03d3b47020e571a72cd01d978cf2">PSA_KEY_TYPE_ECC_PUBLIC_KEY</a>(curve)   (PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE | (curve))</td></tr>
-<tr class="separator:gad54c03d3b47020e571a72cd01d978cf2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga88e01fa06b585654689a99bcc06bbe66"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga88e01fa06b585654689a99bcc06bbe66">PSA_KEY_TYPE_IS_ECC</a>(type)</td></tr>
-<tr class="separator:ga88e01fa06b585654689a99bcc06bbe66"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga7bf101b671e8cf26f4cb08fcb679db4b"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga7bf101b671e8cf26f4cb08fcb679db4b">PSA_KEY_TYPE_IS_ECC_KEYPAIR</a>(type)</td></tr>
-<tr class="separator:ga7bf101b671e8cf26f4cb08fcb679db4b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga5af146a173b0c84d7e737e2fb6a3c0a7"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga5af146a173b0c84d7e737e2fb6a3c0a7">PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY</a>(type)</td></tr>
-<tr class="separator:ga5af146a173b0c84d7e737e2fb6a3c0a7"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga0c567210e6f80aa8f2aa87efa7a3a3f9"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga0c567210e6f80aa8f2aa87efa7a3a3f9">PSA_KEY_TYPE_GET_CURVE</a>(type)</td></tr>
-<tr class="separator:ga0c567210e6f80aa8f2aa87efa7a3a3f9"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4201013d5947c375fae7311b0f98bac7"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga4201013d5947c375fae7311b0f98bac7"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT163K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0001)</td></tr>
-<tr class="separator:ga4201013d5947c375fae7311b0f98bac7"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaca8816b785f492a8795b5276977d1369"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gaca8816b785f492a8795b5276977d1369"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT163R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0002)</td></tr>
-<tr class="separator:gaca8816b785f492a8795b5276977d1369"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4ab7a853ceb3ad0a525ecb571633a1ca"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga4ab7a853ceb3ad0a525ecb571633a1ca"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT163R2</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0003)</td></tr>
-<tr class="separator:ga4ab7a853ceb3ad0a525ecb571633a1ca"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac9fd11da90ca67649a5f51a158afe5f3"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gac9fd11da90ca67649a5f51a158afe5f3"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT193R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0004)</td></tr>
-<tr class="separator:gac9fd11da90ca67649a5f51a158afe5f3"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga7a77f5e385f6439dae5857a7f35756eb"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga7a77f5e385f6439dae5857a7f35756eb"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT193R2</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0005)</td></tr>
-<tr class="separator:ga7a77f5e385f6439dae5857a7f35756eb"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga36e409c36983e41db5db202b1d2095b5"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga36e409c36983e41db5db202b1d2095b5"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT233K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0006)</td></tr>
-<tr class="separator:ga36e409c36983e41db5db202b1d2095b5"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga54997a9f8ef752c6d717171e01c31019"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga54997a9f8ef752c6d717171e01c31019"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT233R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0007)</td></tr>
-<tr class="separator:ga54997a9f8ef752c6d717171e01c31019"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaabccf2759188c3e98d82faa5d8dfcd8c"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gaabccf2759188c3e98d82faa5d8dfcd8c"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT239K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0008)</td></tr>
-<tr class="separator:gaabccf2759188c3e98d82faa5d8dfcd8c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga28c765d75773b5fe083219e7c0b054f9"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga28c765d75773b5fe083219e7c0b054f9"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT283K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0009)</td></tr>
-<tr class="separator:ga28c765d75773b5fe083219e7c0b054f9"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gafd8ecacea0d9e7e1a0247c047baf3372"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gafd8ecacea0d9e7e1a0247c047baf3372"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT283R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x000a)</td></tr>
-<tr class="separator:gafd8ecacea0d9e7e1a0247c047baf3372"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga2bf301617cc84a6f2b36a86cc29eaf4d"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga2bf301617cc84a6f2b36a86cc29eaf4d"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT409K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x000b)</td></tr>
-<tr class="separator:ga2bf301617cc84a6f2b36a86cc29eaf4d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae41caa1cc16d3c35769b6edcb62c8957"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gae41caa1cc16d3c35769b6edcb62c8957"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT409R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x000c)</td></tr>
-<tr class="separator:gae41caa1cc16d3c35769b6edcb62c8957"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga2043aa519549a6194d132d81816879bc"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga2043aa519549a6194d132d81816879bc"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT571K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x000d)</td></tr>
-<tr class="separator:ga2043aa519549a6194d132d81816879bc"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1607d2cb9591b56dbe1295bedc33e19e"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga1607d2cb9591b56dbe1295bedc33e19e"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECT571R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x000e)</td></tr>
-<tr class="separator:ga1607d2cb9591b56dbe1295bedc33e19e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga2ad14935d244d93ee0e4cfe9b1f218a4"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga2ad14935d244d93ee0e4cfe9b1f218a4"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP160K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x000f)</td></tr>
-<tr class="separator:ga2ad14935d244d93ee0e4cfe9b1f218a4"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga35ed41203039e94eb4855cc70f28f7f0"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga35ed41203039e94eb4855cc70f28f7f0"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP160R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0010)</td></tr>
-<tr class="separator:ga35ed41203039e94eb4855cc70f28f7f0"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac465f57c34914a01aea8c220a613dfe6"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gac465f57c34914a01aea8c220a613dfe6"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP160R2</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0011)</td></tr>
-<tr class="separator:gac465f57c34914a01aea8c220a613dfe6"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga58c806d45ab350287ddc49da833bd558"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga58c806d45ab350287ddc49da833bd558"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP192K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0012)</td></tr>
-<tr class="separator:ga58c806d45ab350287ddc49da833bd558"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga5aa3ceff4603fa3fafd8f2286c5d3e4a"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga5aa3ceff4603fa3fafd8f2286c5d3e4a"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP192R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0013)</td></tr>
-<tr class="separator:ga5aa3ceff4603fa3fafd8f2286c5d3e4a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gabfaaab2eaab0ac360e41c1aff6133cdf"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gabfaaab2eaab0ac360e41c1aff6133cdf"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP224K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0014)</td></tr>
-<tr class="separator:gabfaaab2eaab0ac360e41c1aff6133cdf"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga8d1d21b6b87ba4158235b876ae79031d"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga8d1d21b6b87ba4158235b876ae79031d"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP224R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0015)</td></tr>
-<tr class="separator:ga8d1d21b6b87ba4158235b876ae79031d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaaa61941f815aff976a1debd910b1704c"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gaaa61941f815aff976a1debd910b1704c"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP256K1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0016)</td></tr>
-<tr class="separator:gaaa61941f815aff976a1debd910b1704c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga11224270225c2b2dbfa2ab01073a4e93"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga11224270225c2b2dbfa2ab01073a4e93"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP256R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0017)</td></tr>
-<tr class="separator:ga11224270225c2b2dbfa2ab01073a4e93"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga3e870a36493143507a01a28c70790fa3"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga3e870a36493143507a01a28c70790fa3"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP384R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0018)</td></tr>
-<tr class="separator:ga3e870a36493143507a01a28c70790fa3"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4482ff6155006ff509071c32ce263fdf"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga4482ff6155006ff509071c32ce263fdf"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_SECP521R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x0019)</td></tr>
-<tr class="separator:ga4482ff6155006ff509071c32ce263fdf"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa999b69c56af0cc1cebf4596f8578191"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gaa999b69c56af0cc1cebf4596f8578191"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_BRAINPOOL_P256R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x001a)</td></tr>
-<tr class="separator:gaa999b69c56af0cc1cebf4596f8578191"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga79f95ed8050f2dc7750cbac212c6e687"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga79f95ed8050f2dc7750cbac212c6e687"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_BRAINPOOL_P384R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x001b)</td></tr>
-<tr class="separator:ga79f95ed8050f2dc7750cbac212c6e687"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa03a2dc6096f336be3d68a1f7405e86c"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gaa03a2dc6096f336be3d68a1f7405e86c"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_BRAINPOOL_P512R1</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x001c)</td></tr>
-<tr class="separator:gaa03a2dc6096f336be3d68a1f7405e86c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac94faf3b8d9884221541f51f26b11c7a"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gac94faf3b8d9884221541f51f26b11c7a"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_CURVE25519</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x001d)</td></tr>
-<tr class="separator:gac94faf3b8d9884221541f51f26b11c7a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga902b0e91eff920873b3b59c740854305"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga902b0e91eff920873b3b59c740854305"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ECC_CURVE_CURVE448</b>   ((<a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) 0x001e)</td></tr>
-<tr class="separator:ga902b0e91eff920873b3b59c740854305"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga325a340d7c72d99d3a678eb210bf6e0a"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga325a340d7c72d99d3a678eb210bf6e0a">PSA_KEY_TYPE_DH_PUBLIC_KEY</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x60040000)</td></tr>
-<tr class="separator:ga325a340d7c72d99d3a678eb210bf6e0a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga39b63c6b97a62a316c0660bf72b2fdd5"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga39b63c6b97a62a316c0660bf72b2fdd5">PSA_KEY_TYPE_DH_KEYPAIR</a>   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x70040000)</td></tr>
-<tr class="separator:ga39b63c6b97a62a316c0660bf72b2fdd5"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga248ae35c0e2becaebbf479fc1c3a3b0e"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga248ae35c0e2becaebbf479fc1c3a3b0e">PSA_KEY_TYPE_IS_DH</a>(type)   (<a class="el" href="group__crypto__types.html#gace08e46dd7cbf642d50d982a25d02bec">PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR</a>(type) == <a class="el" href="group__crypto__types.html#ga325a340d7c72d99d3a678eb210bf6e0a">PSA_KEY_TYPE_DH_PUBLIC_KEY</a>)</td></tr>
-<tr class="separator:ga248ae35c0e2becaebbf479fc1c3a3b0e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gacaa366bdeb0413e63e87a667c5457b2e"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gacaa366bdeb0413e63e87a667c5457b2e">PSA_BLOCK_CIPHER_BLOCK_SIZE</a>(type)</td></tr>
-<tr class="separator:gacaa366bdeb0413e63e87a667c5457b2e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaf5d76750b6cfe3e7f0c8e9eee1162318"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gaf5d76750b6cfe3e7f0c8e9eee1162318"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_VENDOR_FLAG</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x80000000)</td></tr>
-<tr class="separator:gaf5d76750b6cfe3e7f0c8e9eee1162318"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga25e918c465b4421dbfaedad6b693d110"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga25e918c465b4421dbfaedad6b693d110"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CATEGORY_MASK</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x7f000000)</td></tr>
-<tr class="separator:ga25e918c465b4421dbfaedad6b693d110"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gafd048e1835b80e6daaff7fddce699757"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gafd048e1835b80e6daaff7fddce699757"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CATEGORY_HASH</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000000)</td></tr>
-<tr class="separator:gafd048e1835b80e6daaff7fddce699757"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga5e6e0039d0b0d18afb3e13e5b9602b3a"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga5e6e0039d0b0d18afb3e13e5b9602b3a"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CATEGORY_MAC</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x02000000)</td></tr>
-<tr class="separator:ga5e6e0039d0b0d18afb3e13e5b9602b3a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga68228a619db59eba93fd13e9129dbfe2"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga68228a619db59eba93fd13e9129dbfe2"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CATEGORY_CIPHER</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x04000000)</td></tr>
-<tr class="separator:ga68228a619db59eba93fd13e9129dbfe2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga37fdd9cac2552f1568f38e091a826549"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga37fdd9cac2552f1568f38e091a826549"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CATEGORY_AEAD</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x06000000)</td></tr>
-<tr class="separator:ga37fdd9cac2552f1568f38e091a826549"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga68a0af1dd89b33fb1e53139f654988f6"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga68a0af1dd89b33fb1e53139f654988f6"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CATEGORY_SIGN</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x10000000)</td></tr>
-<tr class="separator:ga68a0af1dd89b33fb1e53139f654988f6"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga72f46c8256b760b174e6db61a61cd608"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga72f46c8256b760b174e6db61a61cd608"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x12000000)</td></tr>
-<tr class="separator:ga72f46c8256b760b174e6db61a61cd608"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac185b2274dd4e5f0b97c43334c2e478f"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gac185b2274dd4e5f0b97c43334c2e478f"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CATEGORY_KEY_DERIVATION</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x20000000)</td></tr>
-<tr class="separator:gac185b2274dd4e5f0b97c43334c2e478f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga808e397a4891c612df4a5b20eebc2fac"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga808e397a4891c612df4a5b20eebc2fac"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CATEGORY_KEY_AGREEMENT</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x30000000)</td></tr>
-<tr class="separator:ga808e397a4891c612df4a5b20eebc2fac"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga2396d8ba67096b3ebc69bc351a74c78b"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga2396d8ba67096b3ebc69bc351a74c78b"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_VENDOR_DEFINED</b>(alg)   (((alg) & PSA_ALG_VENDOR_FLAG) != 0)</td></tr>
-<tr class="separator:ga2396d8ba67096b3ebc69bc351a74c78b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac9280662bb482590b4b33d1dcd32930f"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gac9280662bb482590b4b33d1dcd32930f">PSA_ALG_IS_HASH</a>(alg)   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_HASH)</td></tr>
-<tr class="separator:gac9280662bb482590b4b33d1dcd32930f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaca7aee4c9dde316b3b1a150a26eab776"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaca7aee4c9dde316b3b1a150a26eab776">PSA_ALG_IS_MAC</a>(alg)   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_MAC)</td></tr>
-<tr class="separator:gaca7aee4c9dde316b3b1a150a26eab776"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1d1a5a402ad89a2e68f12bfb535490eb"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga1d1a5a402ad89a2e68f12bfb535490eb">PSA_ALG_IS_CIPHER</a>(alg)   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_CIPHER)</td></tr>
-<tr class="separator:ga1d1a5a402ad89a2e68f12bfb535490eb"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1d44829d60065eaa4ac9a703e7d6abc8"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga1d44829d60065eaa4ac9a703e7d6abc8">PSA_ALG_IS_AEAD</a>(alg)   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_AEAD)</td></tr>
-<tr class="separator:ga1d44829d60065eaa4ac9a703e7d6abc8"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6d490d0904e0698f6c1268a89d72ff31"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga6d490d0904e0698f6c1268a89d72ff31">PSA_ALG_IS_SIGN</a>(alg)   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_SIGN)</td></tr>
-<tr class="separator:ga6d490d0904e0698f6c1268a89d72ff31"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga41d2ee937d54efd76bd54a97b2ebc08a"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga41d2ee937d54efd76bd54a97b2ebc08a">PSA_ALG_IS_ASYMMETRIC_ENCRYPTION</a>(alg)   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION)</td></tr>
-<tr class="separator:ga41d2ee937d54efd76bd54a97b2ebc08a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga59753742cb06553bd22751bbef472b6f"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga59753742cb06553bd22751bbef472b6f">PSA_ALG_IS_KEY_AGREEMENT</a>(alg)   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_KEY_AGREEMENT)</td></tr>
-<tr class="separator:ga59753742cb06553bd22751bbef472b6f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaf8b90c648aa53dbd06c236695e300cd0"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaf8b90c648aa53dbd06c236695e300cd0">PSA_ALG_IS_KEY_DERIVATION</a>(alg)   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_KEY_DERIVATION)</td></tr>
-<tr class="separator:gaf8b90c648aa53dbd06c236695e300cd0"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac41a7077aef55bb20c629c8949d43c57"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gac41a7077aef55bb20c629c8949d43c57"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_HASH_MASK</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x000000ff)</td></tr>
-<tr class="separator:gac41a7077aef55bb20c629c8949d43c57"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab076ca67238cb4ebd81556db8f3dbac1"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gab076ca67238cb4ebd81556db8f3dbac1"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_MD2</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000001)</td></tr>
-<tr class="separator:gab076ca67238cb4ebd81556db8f3dbac1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaac7ab8c28c117ef4ddf01affc8d3ceb2"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gaac7ab8c28c117ef4ddf01affc8d3ceb2"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_MD4</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000002)</td></tr>
-<tr class="separator:gaac7ab8c28c117ef4ddf01affc8d3ceb2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gade591d9286d23382eb5cec099c84180d"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gade591d9286d23382eb5cec099c84180d"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_MD5</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000003)</td></tr>
-<tr class="separator:gade591d9286d23382eb5cec099c84180d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6c5d3a32cda59086f07b85ef007033dd"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga6c5d3a32cda59086f07b85ef007033dd"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_RIPEMD160</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000004)</td></tr>
-<tr class="separator:ga6c5d3a32cda59086f07b85ef007033dd"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga3fca4e9f9ad4a1158817d1850dee82e5"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga3fca4e9f9ad4a1158817d1850dee82e5"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_SHA_1</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000005)</td></tr>
-<tr class="separator:ga3fca4e9f9ad4a1158817d1850dee82e5"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga25d6a3244d10a7148fe6b026d1979f7b"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga25d6a3244d10a7148fe6b026d1979f7b">PSA_ALG_SHA_224</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000008)</td></tr>
-<tr class="separator:ga25d6a3244d10a7148fe6b026d1979f7b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga619471f978e13cdd0a1e37145e4bf341"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga619471f978e13cdd0a1e37145e4bf341">PSA_ALG_SHA_256</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000009)</td></tr>
-<tr class="separator:ga619471f978e13cdd0a1e37145e4bf341"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga58af64dd9a86a287e8da9ed7739eead4"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga58af64dd9a86a287e8da9ed7739eead4">PSA_ALG_SHA_384</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x0100000a)</td></tr>
-<tr class="separator:ga58af64dd9a86a287e8da9ed7739eead4"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gafba3ae409f46d3dd7f37a0910660c3e9"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gafba3ae409f46d3dd7f37a0910660c3e9">PSA_ALG_SHA_512</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x0100000b)</td></tr>
-<tr class="separator:gafba3ae409f46d3dd7f37a0910660c3e9"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga3fe2d7c3c80e3186ca78d16a35d5d931"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga3fe2d7c3c80e3186ca78d16a35d5d931">PSA_ALG_SHA_512_224</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x0100000c)</td></tr>
-<tr class="separator:ga3fe2d7c3c80e3186ca78d16a35d5d931"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga5910b3964c14e9613e8643a45b09c2d4"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga5910b3964c14e9613e8643a45b09c2d4">PSA_ALG_SHA_512_256</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x0100000d)</td></tr>
-<tr class="separator:ga5910b3964c14e9613e8643a45b09c2d4"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga16f5fe34ccce68c2fada1224c054a999"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga16f5fe34ccce68c2fada1224c054a999">PSA_ALG_SHA3_224</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000010)</td></tr>
-<tr class="separator:ga16f5fe34ccce68c2fada1224c054a999"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaace70d9515489bbe3c5e7ac1b7d9155b"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaace70d9515489bbe3c5e7ac1b7d9155b">PSA_ALG_SHA3_256</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000011)</td></tr>
-<tr class="separator:gaace70d9515489bbe3c5e7ac1b7d9155b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab0f079257ea75e2acfe2fc3b38c78cd8"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gab0f079257ea75e2acfe2fc3b38c78cd8">PSA_ALG_SHA3_384</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000012)</td></tr>
-<tr class="separator:gab0f079257ea75e2acfe2fc3b38c78cd8"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga37e5dbe936dddb155e76f2997de27188"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga37e5dbe936dddb155e76f2997de27188">PSA_ALG_SHA3_512</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000013)</td></tr>
-<tr class="separator:ga37e5dbe936dddb155e76f2997de27188"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa1288ea8bd397a8a3f5e19e94110f2e4"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaa1288ea8bd397a8a3f5e19e94110f2e4">PSA_ALG_ANY_HASH</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x010000ff)</td></tr>
-<tr class="separator:gaa1288ea8bd397a8a3f5e19e94110f2e4"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gabba3fcfee55533b0e25350e78a942e07"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gabba3fcfee55533b0e25350e78a942e07"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_MAC_SUBCATEGORY_MASK</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x00c00000)</td></tr>
-<tr class="separator:gabba3fcfee55533b0e25350e78a942e07"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga0675192b82720fb8c9037a95bdeb6c88"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga0675192b82720fb8c9037a95bdeb6c88"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_HMAC_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x02800000)</td></tr>
-<tr class="separator:ga0675192b82720fb8c9037a95bdeb6c88"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga70f397425684b3efcde1e0e34c28261f"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga70f397425684b3efcde1e0e34c28261f">PSA_ALG_HMAC</a>(hash_alg)   (PSA_ALG_HMAC_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga70f397425684b3efcde1e0e34c28261f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaee84269106a947cb6ac353e15e6c4687"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gaee84269106a947cb6ac353e15e6c4687"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_HMAC_GET_HASH</b>(hmac_alg)   (PSA_ALG_CATEGORY_HASH | ((hmac_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:gaee84269106a947cb6ac353e15e6c4687"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4a050c3c3cbc6eb96418f18847601c8a"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga4a050c3c3cbc6eb96418f18847601c8a">PSA_ALG_IS_HMAC</a>(alg)</td></tr>
-<tr class="separator:ga4a050c3c3cbc6eb96418f18847601c8a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga8c48784065c65c623a21b9a3ccc56b1d"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga8c48784065c65c623a21b9a3ccc56b1d"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_MAC_TRUNCATION_MASK</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x00003f00)</td></tr>
-<tr class="separator:ga8c48784065c65c623a21b9a3ccc56b1d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6db5ce573e6ad52068aba31c3afdce31"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga6db5ce573e6ad52068aba31c3afdce31"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_MAC_TRUNCATION_OFFSET</b>   8</td></tr>
-<tr class="separator:ga6db5ce573e6ad52068aba31c3afdce31"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaf36137110baf7bb13c5028fd62c64276"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaf36137110baf7bb13c5028fd62c64276">PSA_ALG_TRUNCATED_MAC</a>(alg, mac_length)</td></tr>
-<tr class="separator:gaf36137110baf7bb13c5028fd62c64276"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa05a8d99634f3350597ac9284fb70cb1"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaa05a8d99634f3350597ac9284fb70cb1">PSA_ALG_FULL_LENGTH_MAC</a>(alg)   ((alg) & ~PSA_ALG_MAC_TRUNCATION_MASK)</td></tr>
-<tr class="separator:gaa05a8d99634f3350597ac9284fb70cb1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab03726c4476174e019a08e2a04018ce8"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gab03726c4476174e019a08e2a04018ce8">PSA_MAC_TRUNCATED_LENGTH</a>(alg)   (((alg) & PSA_ALG_MAC_TRUNCATION_MASK) >> PSA_MAC_TRUNCATION_OFFSET)</td></tr>
-<tr class="separator:gab03726c4476174e019a08e2a04018ce8"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaee0c29980b08305f6d0e7b3fbb588ade"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gaee0c29980b08305f6d0e7b3fbb588ade"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CIPHER_MAC_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x02c00000)</td></tr>
-<tr class="separator:gaee0c29980b08305f6d0e7b3fbb588ade"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga20bdc755de7b90f6621ccb1e6bb5d9e1"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga20bdc755de7b90f6621ccb1e6bb5d9e1"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CBC_MAC</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x02c00001)</td></tr>
-<tr class="separator:ga20bdc755de7b90f6621ccb1e6bb5d9e1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga146328a1e0023a02464e232d6ecefdc2"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga146328a1e0023a02464e232d6ecefdc2"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CMAC</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x02c00002)</td></tr>
-<tr class="separator:ga146328a1e0023a02464e232d6ecefdc2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga69a012ce150219a2d97c3ab5582f0004"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga69a012ce150219a2d97c3ab5582f0004"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_GMAC</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x02c00003)</td></tr>
-<tr class="separator:ga69a012ce150219a2d97c3ab5582f0004"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae49d1eb601125d65a5c5b252aa45479e"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gae49d1eb601125d65a5c5b252aa45479e">PSA_ALG_IS_BLOCK_CIPHER_MAC</a>(alg)</td></tr>
-<tr class="separator:gae49d1eb601125d65a5c5b252aa45479e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac79618293c4254143caa75f6c5c82fa1"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gac79618293c4254143caa75f6c5c82fa1"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CIPHER_STREAM_FLAG</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x00800000)</td></tr>
-<tr class="separator:gac79618293c4254143caa75f6c5c82fa1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gabc80d19d140032e3b138db4ed37d0bd7"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gabc80d19d140032e3b138db4ed37d0bd7"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CIPHER_FROM_BLOCK_FLAG</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x00400000)</td></tr>
-<tr class="separator:gabc80d19d140032e3b138db4ed37d0bd7"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gacfec68e0c6175e02e1b2ebc97df383c0"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gacfec68e0c6175e02e1b2ebc97df383c0">PSA_ALG_IS_STREAM_CIPHER</a>(alg)</td></tr>
-<tr class="separator:gacfec68e0c6175e02e1b2ebc97df383c0"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab6a5284decb0e5e1b5b8740a41ef3c5e"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gab6a5284decb0e5e1b5b8740a41ef3c5e">PSA_ALG_ARC4</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x04800001)</td></tr>
-<tr class="separator:gab6a5284decb0e5e1b5b8740a41ef3c5e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gad318309706a769cffdc64e4c7e06b2e9"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gad318309706a769cffdc64e4c7e06b2e9">PSA_ALG_CTR</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x04c00001)</td></tr>
-<tr class="separator:gad318309706a769cffdc64e4c7e06b2e9"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga0088c933e01d671f263a9a1f177cb5bc"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga0088c933e01d671f263a9a1f177cb5bc"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_CFB</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x04c00002)</td></tr>
-<tr class="separator:ga0088c933e01d671f263a9a1f177cb5bc"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae96bb421fa634c6fa8f571f0112f1ddb"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gae96bb421fa634c6fa8f571f0112f1ddb"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_OFB</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x04c00003)</td></tr>
-<tr class="separator:gae96bb421fa634c6fa8f571f0112f1ddb"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa722c0e426a797fd6d99623f59748125"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaa722c0e426a797fd6d99623f59748125">PSA_ALG_XTS</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x044000ff)</td></tr>
-<tr class="separator:gaa722c0e426a797fd6d99623f59748125"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gacb332d72716958880ee7f97d8365ae66"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gacb332d72716958880ee7f97d8365ae66">PSA_ALG_CBC_NO_PADDING</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x04600100)</td></tr>
-<tr class="separator:gacb332d72716958880ee7f97d8365ae66"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaef50d2e9716eb6d476046608e4e0c78c"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaef50d2e9716eb6d476046608e4e0c78c">PSA_ALG_CBC_PKCS7</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x04600101)</td></tr>
-<tr class="separator:gaef50d2e9716eb6d476046608e4e0c78c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac2c0e7d21f1b2df5e76bcb4a8f84273c"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gac2c0e7d21f1b2df5e76bcb4a8f84273c">PSA_ALG_CCM</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x06001001)</td></tr>
-<tr class="separator:gac2c0e7d21f1b2df5e76bcb4a8f84273c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga0d7d02b15aaae490d38277d99f1c637c"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga0d7d02b15aaae490d38277d99f1c637c">PSA_ALG_GCM</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x06001002)</td></tr>
-<tr class="separator:ga0d7d02b15aaae490d38277d99f1c637c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga575d9082463a06a86c2a22dd63c2e772"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga575d9082463a06a86c2a22dd63c2e772"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_AEAD_TAG_LENGTH_MASK</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x00003f00)</td></tr>
-<tr class="separator:ga575d9082463a06a86c2a22dd63c2e772"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga987d416146048906d40dd1d9572e3193"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga987d416146048906d40dd1d9572e3193"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_AEAD_TAG_LENGTH_OFFSET</b>   8</td></tr>
-<tr class="separator:ga987d416146048906d40dd1d9572e3193"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa63c520b62ab001d54d28801742fc9db"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaa63c520b62ab001d54d28801742fc9db">PSA_ALG_AEAD_WITH_TAG_LENGTH</a>(alg, tag_length)</td></tr>
-<tr class="separator:gaa63c520b62ab001d54d28801742fc9db"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaddea507e062250cda8a29407a9480d2b"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaddea507e062250cda8a29407a9480d2b">PSA_ALG_AEAD_WITH_DEFAULT_TAG_LENGTH</a>(alg)</td></tr>
-<tr class="separator:gaddea507e062250cda8a29407a9480d2b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6e52012ca3be6acb4c756c372f18c3eb"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><b>PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE</b>(alg, ref)</td></tr>
-<tr class="separator:ga6e52012ca3be6acb4c756c372f18c3eb"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga819b23c9899e92e9f867c7b2ae8f264c"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga819b23c9899e92e9f867c7b2ae8f264c"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_RSA_PKCS1V15_SIGN_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x10020000)</td></tr>
-<tr class="separator:ga819b23c9899e92e9f867c7b2ae8f264c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga702ff75385a6ae7d4247033f479439af"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga702ff75385a6ae7d4247033f479439af">PSA_ALG_RSA_PKCS1V15_SIGN</a>(hash_alg)   (PSA_ALG_RSA_PKCS1V15_SIGN_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga702ff75385a6ae7d4247033f479439af"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4215e2a78dcf834e9a625927faa2a817"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga4215e2a78dcf834e9a625927faa2a817">PSA_ALG_RSA_PKCS1V15_SIGN_RAW</a>   PSA_ALG_RSA_PKCS1V15_SIGN_BASE</td></tr>
-<tr class="separator:ga4215e2a78dcf834e9a625927faa2a817"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga9d545279f23d43b1b2a744d0dd6826d0"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga9d545279f23d43b1b2a744d0dd6826d0"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_RSA_PKCS1V15_SIGN</b>(alg)   (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_RSA_PKCS1V15_SIGN_BASE)</td></tr>
-<tr class="separator:ga9d545279f23d43b1b2a744d0dd6826d0"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga49d39a343790971b7a74644f4faea0c0"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga49d39a343790971b7a74644f4faea0c0"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_RSA_PSS_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x10030000)</td></tr>
-<tr class="separator:ga49d39a343790971b7a74644f4faea0c0"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga62152bf4cb4bf6aace5e1be8f143564d"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga62152bf4cb4bf6aace5e1be8f143564d">PSA_ALG_RSA_PSS</a>(hash_alg)   (PSA_ALG_RSA_PSS_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga62152bf4cb4bf6aace5e1be8f143564d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gafa04fae7393a76d5161558768cb82a78"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gafa04fae7393a76d5161558768cb82a78"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_RSA_PSS</b>(alg)   (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_RSA_PSS_BASE)</td></tr>
-<tr class="separator:gafa04fae7393a76d5161558768cb82a78"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga863284106894476e3a8524805410b55b"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga863284106894476e3a8524805410b55b"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_DSA_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x10040000)</td></tr>
-<tr class="separator:ga863284106894476e3a8524805410b55b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga9a68efdddff5ae95f104a1416b12742e"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga9a68efdddff5ae95f104a1416b12742e">PSA_ALG_DSA</a>(hash_alg)   (PSA_ALG_DSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga9a68efdddff5ae95f104a1416b12742e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gad3800dafc62d6a17bcae4bce98402e68"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gad3800dafc62d6a17bcae4bce98402e68"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_DETERMINISTIC_DSA_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x10050000)</td></tr>
-<tr class="separator:gad3800dafc62d6a17bcae4bce98402e68"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1d2a96f788cce4f8fc156d13342e70de"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga1d2a96f788cce4f8fc156d13342e70de"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_DSA_DETERMINISTIC_FLAG</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x00010000)</td></tr>
-<tr class="separator:ga1d2a96f788cce4f8fc156d13342e70de"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab8eb98fb6d2e094e47f3b44dfe128f94"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gab8eb98fb6d2e094e47f3b44dfe128f94">PSA_ALG_DETERMINISTIC_DSA</a>(hash_alg)   (PSA_ALG_DETERMINISTIC_DSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:gab8eb98fb6d2e094e47f3b44dfe128f94"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gacfc3cd50ef0c4bf694cf936079bcbaee"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_DSA</b>(alg)</td></tr>
-<tr class="separator:gacfc3cd50ef0c4bf694cf936079bcbaee"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae01ae792228c16eac05102f8e900efd1"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gae01ae792228c16eac05102f8e900efd1"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_DSA_IS_DETERMINISTIC</b>(alg)   (((alg) & PSA_ALG_DSA_DETERMINISTIC_FLAG) != 0)</td></tr>
-<tr class="separator:gae01ae792228c16eac05102f8e900efd1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga11f7d6fe7a4441143ed398420b7d1980"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga11f7d6fe7a4441143ed398420b7d1980"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_DETERMINISTIC_DSA</b>(alg)   (PSA_ALG_IS_DSA(alg) && PSA_ALG_DSA_IS_DETERMINISTIC(alg))</td></tr>
-<tr class="separator:ga11f7d6fe7a4441143ed398420b7d1980"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga474c0582c4726d0c0274e470f4199cf9"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga474c0582c4726d0c0274e470f4199cf9"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_RANDOMIZED_DSA</b>(alg)   (PSA_ALG_IS_DSA(alg) && !PSA_ALG_DSA_IS_DETERMINISTIC(alg))</td></tr>
-<tr class="separator:ga474c0582c4726d0c0274e470f4199cf9"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gafd9800fdbe6ea881e0ac0ce03d145928"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gafd9800fdbe6ea881e0ac0ce03d145928"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_ECDSA_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x10060000)</td></tr>
-<tr class="separator:gafd9800fdbe6ea881e0ac0ce03d145928"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga7e3ce9f514a227d5ba5d8318870452e3"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga7e3ce9f514a227d5ba5d8318870452e3">PSA_ALG_ECDSA</a>(hash_alg)   (PSA_ALG_ECDSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga7e3ce9f514a227d5ba5d8318870452e3"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga51d6b6044a62e33cae0cf64bfc3b22a4"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga51d6b6044a62e33cae0cf64bfc3b22a4">PSA_ALG_ECDSA_ANY</a>   PSA_ALG_ECDSA_BASE</td></tr>
-<tr class="separator:ga51d6b6044a62e33cae0cf64bfc3b22a4"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6c08b65200140aeb46ee9db9c8ed878c"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga6c08b65200140aeb46ee9db9c8ed878c"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_DETERMINISTIC_ECDSA_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x10070000)</td></tr>
-<tr class="separator:ga6c08b65200140aeb46ee9db9c8ed878c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga11da566bcd341661c8de921e2ca5ed03"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga11da566bcd341661c8de921e2ca5ed03">PSA_ALG_DETERMINISTIC_ECDSA</a>(hash_alg)   (PSA_ALG_DETERMINISTIC_ECDSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga11da566bcd341661c8de921e2ca5ed03"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gafb92dc138c9d2388033ff5fc1dab7b48"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_ECDSA</b>(alg)</td></tr>
-<tr class="separator:gafb92dc138c9d2388033ff5fc1dab7b48"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaced29d8e3a1740aaec01e9ef8211df4f"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gaced29d8e3a1740aaec01e9ef8211df4f"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_ECDSA_IS_DETERMINISTIC</b>(alg)   (((alg) & PSA_ALG_DSA_DETERMINISTIC_FLAG) != 0)</td></tr>
-<tr class="separator:gaced29d8e3a1740aaec01e9ef8211df4f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gacd8766fe0fb8c1e2d32644e0d092c43a"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gacd8766fe0fb8c1e2d32644e0d092c43a"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_DETERMINISTIC_ECDSA</b>(alg)   (PSA_ALG_IS_ECDSA(alg) && PSA_ALG_ECDSA_IS_DETERMINISTIC(alg))</td></tr>
-<tr class="separator:gacd8766fe0fb8c1e2d32644e0d092c43a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae7b0fafebd139f6f815285b7cad622ea"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gae7b0fafebd139f6f815285b7cad622ea"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_RANDOMIZED_ECDSA</b>(alg)   (PSA_ALG_IS_ECDSA(alg) && !PSA_ALG_ECDSA_IS_DETERMINISTIC(alg))</td></tr>
-<tr class="separator:gae7b0fafebd139f6f815285b7cad622ea"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gad8a8ea0536975363b66410cdeafe38b6"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gad8a8ea0536975363b66410cdeafe38b6">PSA_ALG_IS_HASH_AND_SIGN</a>(alg)</td></tr>
-<tr class="separator:gad8a8ea0536975363b66410cdeafe38b6"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga24cf6d7bcd2b9aeeeff86f07b6c674e3"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga24cf6d7bcd2b9aeeeff86f07b6c674e3">PSA_ALG_SIGN_GET_HASH</a>(alg)</td></tr>
-<tr class="separator:ga24cf6d7bcd2b9aeeeff86f07b6c674e3"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4c540d3abe43fb9abcb94f2bc51acef9"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga4c540d3abe43fb9abcb94f2bc51acef9">PSA_ALG_RSA_PKCS1V15_CRYPT</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x12020000)</td></tr>
-<tr class="separator:ga4c540d3abe43fb9abcb94f2bc51acef9"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga67ba62fbd154f5d3098866ae68ba66eb"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga67ba62fbd154f5d3098866ae68ba66eb"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_RSA_OAEP_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x12030000)</td></tr>
-<tr class="separator:ga67ba62fbd154f5d3098866ae68ba66eb"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa1235dc3fdd9839c6c1b1a9857344c76"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaa1235dc3fdd9839c6c1b1a9857344c76">PSA_ALG_RSA_OAEP</a>(hash_alg)   (PSA_ALG_RSA_OAEP_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:gaa1235dc3fdd9839c6c1b1a9857344c76"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga9a85c05fd5c39ca63bbc47fb0755da39"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga9a85c05fd5c39ca63bbc47fb0755da39"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_RSA_OAEP</b>(alg)   (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_RSA_OAEP_BASE)</td></tr>
-<tr class="separator:ga9a85c05fd5c39ca63bbc47fb0755da39"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae6b0b87aabe82a1b3113824f022c52e8"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_RSA_OAEP_GET_HASH</b>(alg)</td></tr>
-<tr class="separator:gae6b0b87aabe82a1b3113824f022c52e8"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga85fe668f95a1e65b573dc5acb798be6f"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga85fe668f95a1e65b573dc5acb798be6f"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_HKDF_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x20000100)</td></tr>
-<tr class="separator:ga85fe668f95a1e65b573dc5acb798be6f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga32a888fb360e6e25cab8a343772c4a82"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga32a888fb360e6e25cab8a343772c4a82">PSA_ALG_HKDF</a>(hash_alg)   (PSA_ALG_HKDF_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga32a888fb360e6e25cab8a343772c4a82"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1979d0a76fcee6164cf2e65960f38db2"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga1979d0a76fcee6164cf2e65960f38db2">PSA_ALG_IS_HKDF</a>(alg)   (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_HKDF_BASE)</td></tr>
-<tr class="separator:ga1979d0a76fcee6164cf2e65960f38db2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga643df48b529b176995927b697ff07a4c"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga643df48b529b176995927b697ff07a4c"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_HKDF_GET_HASH</b>(hkdf_alg)   (PSA_ALG_CATEGORY_HASH | ((hkdf_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga643df48b529b176995927b697ff07a4c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gadb328698047e32da8e16551b28b50a35"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gadb328698047e32da8e16551b28b50a35"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_TLS12_PRF_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x20000200)</td></tr>
-<tr class="separator:gadb328698047e32da8e16551b28b50a35"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga6d5623c2ccda1d4a84e34351af8382d5"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga6d5623c2ccda1d4a84e34351af8382d5">PSA_ALG_TLS12_PRF</a>(hash_alg)   (PSA_ALG_TLS12_PRF_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga6d5623c2ccda1d4a84e34351af8382d5"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa3c18890c50222e5219f40ade8927e66"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaa3c18890c50222e5219f40ade8927e66">PSA_ALG_IS_TLS12_PRF</a>(alg)   (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_TLS12_PRF_BASE)</td></tr>
-<tr class="separator:gaa3c18890c50222e5219f40ade8927e66"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga403b2695655c7e03d6c07c061c606ab7"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga403b2695655c7e03d6c07c061c606ab7"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_TLS12_PRF_GET_HASH</b>(hkdf_alg)   (PSA_ALG_CATEGORY_HASH | ((hkdf_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga403b2695655c7e03d6c07c061c606ab7"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaaca4b1953a3f31f1a285a48454aa4a6f"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gaaca4b1953a3f31f1a285a48454aa4a6f"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_TLS12_PSK_TO_MS_BASE</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x20000300)</td></tr>
-<tr class="separator:gaaca4b1953a3f31f1a285a48454aa4a6f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga039ec797f15d1635d9b2e09a611f8a68"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga039ec797f15d1635d9b2e09a611f8a68">PSA_ALG_TLS12_PSK_TO_MS</a>(hash_alg)   (PSA_ALG_TLS12_PSK_TO_MS_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga039ec797f15d1635d9b2e09a611f8a68"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab25ecc074a93fd11069bedfbba5a287b"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gab25ecc074a93fd11069bedfbba5a287b">PSA_ALG_IS_TLS12_PSK_TO_MS</a>(alg)   (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_TLS12_PSK_TO_MS_BASE)</td></tr>
-<tr class="separator:gab25ecc074a93fd11069bedfbba5a287b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga49f873d8cf9fb0042118e626330eec9d"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga49f873d8cf9fb0042118e626330eec9d"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_TLS12_PSK_TO_MS_GET_HASH</b>(hkdf_alg)   (PSA_ALG_CATEGORY_HASH | ((hkdf_alg) & PSA_ALG_HASH_MASK))</td></tr>
-<tr class="separator:ga49f873d8cf9fb0042118e626330eec9d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga914b52f4be62633b3350c5e03bf32ecb"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga914b52f4be62633b3350c5e03bf32ecb"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_KEY_DERIVATION_MASK</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x080fffff)</td></tr>
-<tr class="separator:ga914b52f4be62633b3350c5e03bf32ecb"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gad39afc70a46a0ed399e3a1b931fd108b"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gad39afc70a46a0ed399e3a1b931fd108b"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_KEY_AGREEMENT_MASK</b>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x10f00000)</td></tr>
-<tr class="separator:gad39afc70a46a0ed399e3a1b931fd108b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga78bb81cffb87a635c247725eeb2a2682"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga78bb81cffb87a635c247725eeb2a2682">PSA_ALG_KEY_AGREEMENT</a>(ka_alg, kdf_alg)   ((ka_alg) | (kdf_alg))</td></tr>
-<tr class="separator:ga78bb81cffb87a635c247725eeb2a2682"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga56c1189add62b59e8e6a28a809b57037"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga56c1189add62b59e8e6a28a809b57037"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_KEY_AGREEMENT_GET_KDF</b>(alg)   (((alg) & PSA_ALG_KEY_DERIVATION_MASK) | PSA_ALG_CATEGORY_KEY_DERIVATION)</td></tr>
-<tr class="separator:ga56c1189add62b59e8e6a28a809b57037"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaf837c55ba698b488b6e63300e3470abf"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gaf837c55ba698b488b6e63300e3470abf"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_KEY_AGREEMENT_GET_BASE</b>(alg)   (((alg) & PSA_ALG_KEY_AGREEMENT_MASK) | PSA_ALG_CATEGORY_KEY_AGREEMENT)</td></tr>
-<tr class="separator:gaf837c55ba698b488b6e63300e3470abf"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa40ab362ce141ce541d69b2eb1f41438"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaa40ab362ce141ce541d69b2eb1f41438">PSA_ALG_IS_RAW_KEY_AGREEMENT</a>(alg)</td></tr>
-<tr class="separator:gaa40ab362ce141ce541d69b2eb1f41438"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga14529588c008091de0ad2716170dbd48"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga14529588c008091de0ad2716170dbd48"></a>
-#define </td><td class="memItemRight" valign="bottom"><b>PSA_ALG_IS_KEY_DERIVATION_OR_AGREEMENT</b>(alg)   ((<a class="el" href="group__crypto__types.html#gaf8b90c648aa53dbd06c236695e300cd0">PSA_ALG_IS_KEY_DERIVATION</a>(alg) || <a class="el" href="group__crypto__types.html#ga59753742cb06553bd22751bbef472b6f">PSA_ALG_IS_KEY_AGREEMENT</a>(alg)))</td></tr>
-<tr class="separator:ga14529588c008091de0ad2716170dbd48"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga0ebbb6f93a05b6511e6f108ffd2d1eb4"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga0ebbb6f93a05b6511e6f108ffd2d1eb4">PSA_ALG_FFDH</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x30100000)</td></tr>
-<tr class="separator:ga0ebbb6f93a05b6511e6f108ffd2d1eb4"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa3cf76164cd9375af4fb8a291078a19e"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gaa3cf76164cd9375af4fb8a291078a19e">PSA_ALG_IS_FFDH</a>(alg)   (PSA_ALG_KEY_AGREEMENT_GET_BASE(alg) == <a class="el" href="group__crypto__types.html#ga0ebbb6f93a05b6511e6f108ffd2d1eb4">PSA_ALG_FFDH</a>)</td></tr>
-<tr class="separator:gaa3cf76164cd9375af4fb8a291078a19e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab2dbcf71b63785e7dd7b54a100edee43"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gab2dbcf71b63785e7dd7b54a100edee43">PSA_ALG_ECDH</a>   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x30200000)</td></tr>
-<tr class="separator:gab2dbcf71b63785e7dd7b54a100edee43"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga9d9b6533d2a6bea7bac7ae01facb820d"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga9d9b6533d2a6bea7bac7ae01facb820d">PSA_ALG_IS_ECDH</a>(alg)   (PSA_ALG_KEY_AGREEMENT_GET_BASE(alg) == <a class="el" href="group__crypto__types.html#gab2dbcf71b63785e7dd7b54a100edee43">PSA_ALG_ECDH</a>)</td></tr>
-<tr class="separator:ga9d9b6533d2a6bea7bac7ae01facb820d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gacf83d7430e82b97cecb8b26ca6fa1426"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gacf83d7430e82b97cecb8b26ca6fa1426">PSA_ALG_IS_WILDCARD</a>(alg)</td></tr>
-<tr class="separator:gacf83d7430e82b97cecb8b26ca6fa1426"><td class="memSeparator" colspan="2"> </td></tr>
-</table><table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="typedef-members"></a>
-Typedefs</h2></td></tr>
-<tr class="memitem:ga578159487dfc7096cb191b0d2befe628"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga578159487dfc7096cb191b0d2befe628"></a>
-typedef uint32_t </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a></td></tr>
-<tr class="memdesc:ga578159487dfc7096cb191b0d2befe628"><td class="mdescLeft"> </td><td class="mdescRight">Encoding of a key type. <br /></td></tr>
-<tr class="separator:ga578159487dfc7096cb191b0d2befe628"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4e8977c145cce5077c4bce7fec890ad9"><td class="memItemLeft" align="right" valign="top">typedef uint16_t </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a></td></tr>
-<tr class="separator:ga4e8977c145cce5077c4bce7fec890ad9"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac2e4d47f1300d73c2f829a6d99252d69"><td class="memItemLeft" align="right" valign="top">typedef uint32_t </td><td class="memItemRight" valign="bottom"><a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a></td></tr>
-<tr class="memdesc:gac2e4d47f1300d73c2f829a6d99252d69"><td class="mdescLeft"> </td><td class="mdescRight">Encoding of a cryptographic algorithm. <a href="#gac2e4d47f1300d73c2f829a6d99252d69">More...</a><br /></td></tr>
-<tr class="separator:gac2e4d47f1300d73c2f829a6d99252d69"><td class="memSeparator" colspan="2"> </td></tr>
-</table>
-<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
-<h2 class="groupheader">Macro Definition Documentation</h2>
-<a class="anchor" id="ga6e52012ca3be6acb4c756c372f18c3eb"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"> </td>
- <td class="paramname">ref </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line"><a class="code" href="group__crypto__types.html#gaa63c520b62ab001d54d28801742fc9db">PSA_ALG_AEAD_WITH_TAG_LENGTH</a>(alg, 0) == <a class="code" href="group__crypto__types.html#gaa63c520b62ab001d54d28801742fc9db">\</a></div><div class="line"><a class="code" href="group__crypto__types.html#gaa63c520b62ab001d54d28801742fc9db"> PSA_ALG_AEAD_WITH_TAG_LENGTH</a>(ref, 0) ? \</div><div class="line"> ref :</div><div class="ttc" id="group__crypto__types_html_gaa63c520b62ab001d54d28801742fc9db"><div class="ttname"><a href="group__crypto__types.html#gaa63c520b62ab001d54d28801742fc9db">PSA_ALG_AEAD_WITH_TAG_LENGTH</a></div><div class="ttdeci">#define PSA_ALG_AEAD_WITH_TAG_LENGTH(alg, tag_length)</div><div class="ttdef"><b>Definition:</b> crypto_values.h:921</div></div>
-</div><!-- fragment -->
-</div>
-</div>
-<a class="anchor" id="gaddea507e062250cda8a29407a9480d2b"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_AEAD_WITH_DEFAULT_TAG_LENGTH</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">( \</div><div class="line"> PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE(alg, <a class="code" href="group__crypto__types.html#gac2c0e7d21f1b2df5e76bcb4a8f84273c">PSA_ALG_CCM</a>) \</div><div class="line"> PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE(alg, <a class="code" href="group__crypto__types.html#ga0d7d02b15aaae490d38277d99f1c637c">PSA_ALG_GCM</a>) \</div><div class="line"> 0)</div><div class="ttc" id="group__crypto__types_html_ga0d7d02b15aaae490d38277d99f1c637c"><div class="ttname"><a href="group__crypto__types.html#ga0d7d02b15aaae490d38277d99f1c637c">PSA_ALG_GCM</a></div><div class="ttdeci">#define PSA_ALG_GCM</div><div class="ttdef"><b>Definition:</b> crypto_values.h:894</div></div>
-<div class="ttc" id="group__crypto__types_html_gac2c0e7d21f1b2df5e76bcb4a8f84273c"><div class="ttname"><a href="group__crypto__types.html#gac2c0e7d21f1b2df5e76bcb4a8f84273c">PSA_ALG_CCM</a></div><div class="ttdeci">#define PSA_ALG_CCM</div><div class="ttdef"><b>Definition:</b> crypto_values.h:890</div></div>
-</div><!-- fragment --><p>Calculate the corresponding AEAD algorithm with the default tag length.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>An AEAD algorithm (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#ga1d44829d60065eaa4ac9a703e7d6abc8">PSA_ALG_IS_AEAD</a>(<code>alg</code>) is true).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>The corresponding AEAD algorithm with the default tag length for that algorithm. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="gaa63c520b62ab001d54d28801742fc9db"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_AEAD_WITH_TAG_LENGTH</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"> </td>
- <td class="paramname">tag_length </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">(((alg) & ~PSA_ALG_AEAD_TAG_LENGTH_MASK) | \</div><div class="line"> ((tag_length) << PSA_AEAD_TAG_LENGTH_OFFSET & \</div><div class="line"> PSA_ALG_AEAD_TAG_LENGTH_MASK))</div></div><!-- fragment --><p>Macro to build a shortened AEAD algorithm.</p>
-<p>A shortened AEAD algorithm is similar to the corresponding AEAD algorithm, but has an authentication tag that consists of fewer bytes. Depending on the algorithm, the tag length may affect the calculation of the ciphertext.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>A AEAD algorithm identifier (value of type <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69" title="Encoding of a cryptographic algorithm. ">psa_algorithm_t</a> such that <a class="el" href="group__crypto__types.html#ga1d44829d60065eaa4ac9a703e7d6abc8">PSA_ALG_IS_AEAD</a>(<code>alg</code>) is true). </td></tr>
- <tr><td class="paramname">tag_length</td><td>Desired length of the authentication tag in bytes.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>The corresponding AEAD algorithm with the specified length. </dd>
-<dd>
-Unspecified if <code>alg</code> is not a supported AEAD algorithm or if <code>tag_length</code> is not valid for the specified AEAD algorithm. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="gaa1288ea8bd397a8a3f5e19e94110f2e4"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_ANY_HASH   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x010000ff)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Allow any hash algorithm.</p>
-<p>This value may only be used to form the algorithm usage field of a policy for a signature algorithm that is parametrized by a hash. That is, suppose that <code>PSA_xxx_SIGNATURE</code> is one of the following macros:</p><ul>
-<li><a class="el" href="group__crypto__types.html#ga702ff75385a6ae7d4247033f479439af">PSA_ALG_RSA_PKCS1V15_SIGN</a>, <a class="el" href="group__crypto__types.html#ga62152bf4cb4bf6aace5e1be8f143564d">PSA_ALG_RSA_PSS</a>,</li>
-<li><a class="el" href="group__crypto__types.html#ga9a68efdddff5ae95f104a1416b12742e">PSA_ALG_DSA</a>, <a class="el" href="group__crypto__types.html#gab8eb98fb6d2e094e47f3b44dfe128f94">PSA_ALG_DETERMINISTIC_DSA</a>,</li>
-<li><a class="el" href="group__crypto__types.html#ga7e3ce9f514a227d5ba5d8318870452e3">PSA_ALG_ECDSA</a>, <a class="el" href="group__crypto__types.html#ga11da566bcd341661c8de921e2ca5ed03">PSA_ALG_DETERMINISTIC_ECDSA</a>. Then you may create a key as follows:</li>
-<li>Set the key usage field using <a class="el" href="group__crypto__types.html#gaa1288ea8bd397a8a3f5e19e94110f2e4">PSA_ALG_ANY_HASH</a>, for example: <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> psa_key_policy_set_usage(&policy,</div><div class="line"><a name="l00002"></a><span class="lineno"> 2</span>  PSA_KEY_USAGE_SIGN, //or PSA_KEY_USAGE_VERIFY</div><div class="line"><a name="l00003"></a><span class="lineno"> 3</span>  PSA_xxx_SIGNATURE(PSA_ALG_ANY_HASH));</div><div class="line"><a name="l00004"></a><span class="lineno"> 4</span> psa_set_key_policy(handle, &policy);</div></div><!-- fragment --></li>
-<li>Import or generate key material.</li>
-<li>Call <a class="el" href="group__asymmetric.html#ga1b0db9d345b5048cdd39357ac2d56c07" title="Sign a hash or short message with a private key. ">psa_asymmetric_sign()</a> or <a class="el" href="group__asymmetric.html#ga1b8e964c8d927e3d632325d762959eb7" title="Verify the signature a hash or short message using a public key. ">psa_asymmetric_verify()</a>, passing an algorithm built from <code>PSA_xxx_SIGNATURE</code> and a specific hash. Each call to sign or verify a message may use a different hash. <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> psa_asymmetric_sign(handle, PSA_xxx_SIGNATURE(PSA_ALG_SHA_256), ...);</div><div class="line"><a name="l00002"></a><span class="lineno"> 2</span> psa_asymmetric_sign(handle, PSA_xxx_SIGNATURE(PSA_ALG_SHA_512), ...);</div><div class="line"><a name="l00003"></a><span class="lineno"> 3</span> psa_asymmetric_sign(handle, PSA_xxx_SIGNATURE(PSA_ALG_SHA3_256), ...);</div></div><!-- fragment --></li>
-</ul>
-<p>This value may not be used to build other algorithms that are parametrized over a hash. For any valid use of this macro to build an algorithm <code>\p alg</code>, <a class="el" href="group__crypto__types.html#gad8a8ea0536975363b66410cdeafe38b6">PSA_ALG_IS_HASH_AND_SIGN</a>(<code>alg</code>) is true.</p>
-<p>This value may not be used to build an algorithm specification to perform an operation. It is only valid to build policies. </p>
-
-</div>
-</div>
-<a class="anchor" id="gab6a5284decb0e5e1b5b8740a41ef3c5e"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_ARC4   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x04800001)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The ARC4 stream cipher algorithm. </p>
-
-</div>
-</div>
-<a class="anchor" id="gacb332d72716958880ee7f97d8365ae66"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_CBC_NO_PADDING   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x04600100)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The CBC block cipher chaining mode, with no padding.</p>
-<p>The underlying block cipher is determined by the key type.</p>
-<p>This symmetric cipher mode can only be used with messages whose lengths are whole number of blocks for the chosen block cipher. </p>
-
-</div>
-</div>
-<a class="anchor" id="gaef50d2e9716eb6d476046608e4e0c78c"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_CBC_PKCS7   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x04600101)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The CBC block cipher chaining mode with PKCS#7 padding.</p>
-<p>The underlying block cipher is determined by the key type.</p>
-<p>This is the padding method defined by PKCS#7 (RFC 2315) §10.3. </p>
-
-</div>
-</div>
-<a class="anchor" id="gac2c0e7d21f1b2df5e76bcb4a8f84273c"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_CCM   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x06001001)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The CCM authenticated encryption algorithm. </p>
-
-</div>
-</div>
-<a class="anchor" id="gad318309706a769cffdc64e4c7e06b2e9"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_CTR   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x04c00001)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The CTR stream cipher mode.</p>
-<p>CTR is a stream cipher which is built from a block cipher. The underlying block cipher is determined by the key type. For example, to use AES-128-CTR, use this algorithm with a key of type <a class="el" href="group__crypto__types.html#ga6ee54579dcf278c677eda4bb1a29575e">PSA_KEY_TYPE_AES</a> and a length of 128 bits (16 bytes). </p>
-
-</div>
-</div>
-<a class="anchor" id="gab8eb98fb6d2e094e47f3b44dfe128f94"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_DETERMINISTIC_DSA</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">hash_alg</td><td>)</td>
- <td>   (PSA_ALG_DETERMINISTIC_DSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Deterministic DSA signature with hashing.</p>
-<p>This is the deterministic variant defined by RFC 6979 of the signature scheme defined by FIPS 186-4.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">hash_alg</td><td>A hash algorithm (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#gac9280662bb482590b4b33d1dcd32930f">PSA_ALG_IS_HASH</a>(<code>hash_alg</code>) is true). This includes <a class="el" href="group__crypto__types.html#gaa1288ea8bd397a8a3f5e19e94110f2e4">PSA_ALG_ANY_HASH</a> when specifying the algorithm in a usage policy.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>The corresponding DSA signature algorithm. </dd>
-<dd>
-Unspecified if <code>alg</code> is not a supported hash algorithm. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="ga11da566bcd341661c8de921e2ca5ed03"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_DETERMINISTIC_ECDSA</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">hash_alg</td><td>)</td>
- <td>   (PSA_ALG_DETERMINISTIC_ECDSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Deterministic ECDSA signature with hashing.</p>
-<p>This is the deterministic ECDSA signature scheme defined by RFC 6979.</p>
-<p>The representation of a signature is the same as with <a class="el" href="group__crypto__types.html#ga7e3ce9f514a227d5ba5d8318870452e3">PSA_ALG_ECDSA()</a>.</p>
-<p>Note that when this algorithm is used for verification, signatures made with randomized ECDSA (<a class="el" href="group__crypto__types.html#ga7e3ce9f514a227d5ba5d8318870452e3">PSA_ALG_ECDSA</a>(<code>hash_alg</code>)) with the same private key are accepted. In other words, <a class="el" href="group__crypto__types.html#ga11da566bcd341661c8de921e2ca5ed03">PSA_ALG_DETERMINISTIC_ECDSA</a>(<code>hash_alg</code>) differs from <a class="el" href="group__crypto__types.html#ga7e3ce9f514a227d5ba5d8318870452e3">PSA_ALG_ECDSA</a>(<code>hash_alg</code>) only for signature, not for verification.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">hash_alg</td><td>A hash algorithm (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#gac9280662bb482590b4b33d1dcd32930f">PSA_ALG_IS_HASH</a>(<code>hash_alg</code>) is true). This includes <a class="el" href="group__crypto__types.html#gaa1288ea8bd397a8a3f5e19e94110f2e4">PSA_ALG_ANY_HASH</a> when specifying the algorithm in a usage policy.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>The corresponding deterministic ECDSA signature algorithm. </dd>
-<dd>
-Unspecified if <code>alg</code> is not a supported hash algorithm. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="ga9a68efdddff5ae95f104a1416b12742e"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_DSA</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">hash_alg</td><td>)</td>
- <td>   (PSA_ALG_DSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>DSA signature with hashing.</p>
-<p>This is the signature scheme defined by FIPS 186-4, with a random per-message secret number (<em>k</em>).</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">hash_alg</td><td>A hash algorithm (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#gac9280662bb482590b4b33d1dcd32930f">PSA_ALG_IS_HASH</a>(<code>hash_alg</code>) is true). This includes <a class="el" href="group__crypto__types.html#gaa1288ea8bd397a8a3f5e19e94110f2e4">PSA_ALG_ANY_HASH</a> when specifying the algorithm in a usage policy.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>The corresponding DSA signature algorithm. </dd>
-<dd>
-Unspecified if <code>alg</code> is not a supported hash algorithm. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="gab2dbcf71b63785e7dd7b54a100edee43"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_ECDH   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x30200000)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The elliptic curve Diffie-Hellman (ECDH) key agreement algorithm.</p>
-<p>The shared secret produced by key agreement is the x-coordinate of the shared secret point. It is always <code>ceiling(m / 8)</code> bytes long where <code>m</code> is the bit size associated with the curve, i.e. the bit size of the order of the curve's coordinate field. When <code>m</code> is not a multiple of 8, the byte containing the most significant bit of the shared secret is padded with zero bits. The byte order is either little-endian or big-endian depending on the curve type.</p>
-<ul>
-<li>For Montgomery curves (curve types <code>PSA_ECC_CURVE_CURVEXXX</code>), the shared secret is the x-coordinate of <code>d_A Q_B = d_B Q_A</code> in little-endian byte order. The bit size is 448 for Curve448 and 255 for Curve25519.</li>
-<li>For Weierstrass curves over prime fields (curve types <code>PSA_ECC_CURVE_SECPXXX</code> and <code>PSA_ECC_CURVE_BRAINPOOL_PXXX</code>), the shared secret is the x-coordinate of <code>d_A Q_B = d_B Q_A</code> in big-endian byte order. The bit size is <code>m = ceiling(log_2(p))</code> for the field <code>F_p</code>.</li>
-<li>For Weierstrass curves over binary fields (curve types <code>PSA_ECC_CURVE_SECTXXX</code>), the shared secret is the x-coordinate of <code>d_A Q_B = d_B Q_A</code> in big-endian byte order. The bit size is <code>m</code> for the field <code>F_{2^m}</code>. </li>
-</ul>
-
-</div>
-</div>
-<a class="anchor" id="ga7e3ce9f514a227d5ba5d8318870452e3"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_ECDSA</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">hash_alg</td><td>)</td>
- <td>   (PSA_ALG_ECDSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>ECDSA signature with hashing.</p>
-<p>This is the ECDSA signature scheme defined by ANSI X9.62, with a random per-message secret number (<em>k</em>).</p>
-<p>The representation of the signature as a byte string consists of the concatentation of the signature values <em>r</em> and <em>s</em>. Each of <em>r</em> and <em>s</em> is encoded as an <em>N</em>-octet string, where <em>N</em> is the length of the base point of the curve in octets. Each value is represented in big-endian order (most significant octet first).</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">hash_alg</td><td>A hash algorithm (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#gac9280662bb482590b4b33d1dcd32930f">PSA_ALG_IS_HASH</a>(<code>hash_alg</code>) is true). This includes <a class="el" href="group__crypto__types.html#gaa1288ea8bd397a8a3f5e19e94110f2e4">PSA_ALG_ANY_HASH</a> when specifying the algorithm in a usage policy.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>The corresponding ECDSA signature algorithm. </dd>
-<dd>
-Unspecified if <code>alg</code> is not a supported hash algorithm. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="ga51d6b6044a62e33cae0cf64bfc3b22a4"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_ECDSA_ANY   PSA_ALG_ECDSA_BASE</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>ECDSA signature without hashing.</p>
-<p>This is the same signature scheme as <a class="el" href="group__crypto__types.html#ga7e3ce9f514a227d5ba5d8318870452e3">PSA_ALG_ECDSA()</a>, but without specifying a hash algorithm. This algorithm may only be used to sign or verify a sequence of bytes that should be an already-calculated hash. Note that the input is padded with zeros on the left or truncated on the left as required to fit the curve size. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga0ebbb6f93a05b6511e6f108ffd2d1eb4"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_FFDH   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x30100000)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The finite-field Diffie-Hellman (DH) key agreement algorithm.</p>
-<p>The shared secret produced by key agreement and passed as input to the derivation or selection algorithm <code>kdf_alg</code> is the shared secret <code>g^{ab}</code> in big-endian format. It is <code>ceiling(m / 8)</code> bytes long where <code>m</code> is the size of the prime <code>p</code> in bits. </p>
-
-</div>
-</div>
-<a class="anchor" id="gaa05a8d99634f3350597ac9284fb70cb1"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_FULL_LENGTH_MAC</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td>   ((alg) & ~PSA_ALG_MAC_TRUNCATION_MASK)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Macro to build the base MAC algorithm corresponding to a truncated MAC algorithm.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>A MAC algorithm identifier (value of type <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69" title="Encoding of a cryptographic algorithm. ">psa_algorithm_t</a> such that <a class="el" href="group__crypto__types.html#gaca7aee4c9dde316b3b1a150a26eab776">PSA_ALG_IS_MAC</a>(<code>alg</code>) is true). This may be a truncated or untruncated MAC algorithm.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>The corresponding base MAC algorithm. </dd>
-<dd>
-Unspecified if <code>alg</code> is not a supported MAC algorithm. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="ga0d7d02b15aaae490d38277d99f1c637c"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_GCM   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x06001002)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The GCM authenticated encryption algorithm. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga32a888fb360e6e25cab8a343772c4a82"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_HKDF</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">hash_alg</td><td>)</td>
- <td>   (PSA_ALG_HKDF_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Macro to build an HKDF algorithm.</p>
-<p>For example, <code><a class="el" href="group__crypto__types.html#ga32a888fb360e6e25cab8a343772c4a82">PSA_ALG_HKDF(PSA_ALG_SHA256)</a></code> is HKDF using HMAC-SHA-256.</p>
-<p>This key derivation algorithm uses the following inputs:</p><ul>
-<li><a class="el" href="group__derivation.html#ga384777dac55791d8f3a1af72c847b327">PSA_KDF_STEP_SALT</a> is the salt used in the "extract" step. It is optional; if omitted, the derivation uses an empty salt.</li>
-<li><a class="el" href="group__derivation.html#ga90a1995a41e26ed5ca30d2d4641d1168">PSA_KDF_STEP_SECRET</a> is the secret key used in the "extract" step.</li>
-<li><a class="el" href="group__derivation.html#ga836afe760bbda3dafc6c29631560b1a0">PSA_KDF_STEP_INFO</a> is the info string used in the "expand" step. You must pass <a class="el" href="group__derivation.html#ga384777dac55791d8f3a1af72c847b327">PSA_KDF_STEP_SALT</a> before <a class="el" href="group__derivation.html#ga90a1995a41e26ed5ca30d2d4641d1168">PSA_KDF_STEP_SECRET</a>. You may pass <a class="el" href="group__derivation.html#ga836afe760bbda3dafc6c29631560b1a0">PSA_KDF_STEP_INFO</a> at any time after steup and before starting to generate output.</li>
-</ul>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">hash_alg</td><td>A hash algorithm (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#gac9280662bb482590b4b33d1dcd32930f">PSA_ALG_IS_HASH</a>(<code>hash_alg</code>) is true).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>The corresponding HKDF algorithm. </dd>
-<dd>
-Unspecified if <code>alg</code> is not a supported hash algorithm. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="ga70f397425684b3efcde1e0e34c28261f"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_HMAC</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">hash_alg</td><td>)</td>
- <td>   (PSA_ALG_HMAC_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Macro to build an HMAC algorithm.</p>
-<p>For example, <a class="el" href="group__crypto__types.html#ga70f397425684b3efcde1e0e34c28261f">PSA_ALG_HMAC</a>(<a class="el" href="group__crypto__types.html#ga619471f978e13cdd0a1e37145e4bf341">PSA_ALG_SHA_256</a>) is HMAC-SHA-256.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">hash_alg</td><td>A hash algorithm (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#gac9280662bb482590b4b33d1dcd32930f">PSA_ALG_IS_HASH</a>(<code>hash_alg</code>) is true).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>The corresponding HMAC algorithm. </dd>
-<dd>
-Unspecified if <code>alg</code> is not a supported hash algorithm. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="ga1d44829d60065eaa4ac9a703e7d6abc8"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_IS_AEAD</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td>   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_AEAD)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Whether the specified algorithm is an authenticated encryption with associated data (AEAD) algorithm.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>An algorithm identifier (value of type <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69" title="Encoding of a cryptographic algorithm. ">psa_algorithm_t</a>).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>1 if <code>alg</code> is an AEAD algorithm, 0 otherwise. This macro may return either 0 or 1 if <code>alg</code> is not a supported algorithm identifier. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="ga41d2ee937d54efd76bd54a97b2ebc08a"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_IS_ASYMMETRIC_ENCRYPTION</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td>   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Whether the specified algorithm is a public-key encryption algorithm.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>An algorithm identifier (value of type <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69" title="Encoding of a cryptographic algorithm. ">psa_algorithm_t</a>).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>1 if <code>alg</code> is a public-key encryption algorithm, 0 otherwise. This macro may return either 0 or 1 if <code>alg</code> is not a supported algorithm identifier. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="gae49d1eb601125d65a5c5b252aa45479e"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_IS_BLOCK_CIPHER_MAC</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">(((alg) & (PSA_ALG_CATEGORY_MASK | PSA_ALG_MAC_SUBCATEGORY_MASK)) == \</div><div class="line"> PSA_ALG_CIPHER_MAC_BASE)</div></div><!-- fragment --><p>Whether the specified algorithm is a MAC algorithm based on a block cipher.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>An algorithm identifier (value of type <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69" title="Encoding of a cryptographic algorithm. ">psa_algorithm_t</a>).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>1 if <code>alg</code> is a MAC algorithm based on a block cipher, 0 otherwise. This macro may return either 0 or 1 if <code>alg</code> is not a supported algorithm identifier. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="ga1d1a5a402ad89a2e68f12bfb535490eb"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_IS_CIPHER</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td>   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_CIPHER)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Whether the specified algorithm is a symmetric cipher algorithm.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>An algorithm identifier (value of type <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69" title="Encoding of a cryptographic algorithm. ">psa_algorithm_t</a>).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>1 if <code>alg</code> is a symmetric cipher algorithm, 0 otherwise. This macro may return either 0 or 1 if <code>alg</code> is not a supported algorithm identifier. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="gacfc3cd50ef0c4bf694cf936079bcbaee"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_IS_DSA</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">(((alg) & ~PSA_ALG_HASH_MASK & ~PSA_ALG_DSA_DETERMINISTIC_FLAG) == \</div><div class="line"> PSA_ALG_DSA_BASE)</div></div><!-- fragment -->
-</div>
-</div>
-<a class="anchor" id="ga9d9b6533d2a6bea7bac7ae01facb820d"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_IS_ECDH</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td>   (PSA_ALG_KEY_AGREEMENT_GET_BASE(alg) == <a class="el" href="group__crypto__types.html#gab2dbcf71b63785e7dd7b54a100edee43">PSA_ALG_ECDH</a>)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Whether the specified algorithm is an elliptic curve Diffie-Hellman algorithm.</p>
-<p>This includes every supported key selection or key agreement algorithm for the output of the Diffie-Hellman calculation.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>An algorithm identifier (value of type <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69" title="Encoding of a cryptographic algorithm. ">psa_algorithm_t</a>).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>1 if <code>alg</code> is an elliptic curve Diffie-Hellman algorithm, 0 otherwise. This macro may return either 0 or 1 if <code>alg</code> is not a supported key agreement algorithm identifier. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="gafb92dc138c9d2388033ff5fc1dab7b48"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_IS_ECDSA</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">(((alg) & ~PSA_ALG_HASH_MASK & ~PSA_ALG_DSA_DETERMINISTIC_FLAG) == \</div><div class="line"> PSA_ALG_ECDSA_BASE)</div></div><!-- fragment -->
-</div>
-</div>
-<a class="anchor" id="gaa3cf76164cd9375af4fb8a291078a19e"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_IS_FFDH</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td>   (PSA_ALG_KEY_AGREEMENT_GET_BASE(alg) == <a class="el" href="group__crypto__types.html#ga0ebbb6f93a05b6511e6f108ffd2d1eb4">PSA_ALG_FFDH</a>)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Whether the specified algorithm is a finite field Diffie-Hellman algorithm.</p>
-<p>This includes every supported key selection or key agreement algorithm for the output of the Diffie-Hellman calculation.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>An algorithm identifier (value of type <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69" title="Encoding of a cryptographic algorithm. ">psa_algorithm_t</a>).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>1 if <code>alg</code> is a finite field Diffie-Hellman algorithm, 0 otherwise. This macro may return either 0 or 1 if <code>alg</code> is not a supported key agreement algorithm identifier. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="gac9280662bb482590b4b33d1dcd32930f"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_IS_HASH</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td>   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_HASH)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Whether the specified algorithm is a hash algorithm.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>An algorithm identifier (value of type <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69" title="Encoding of a cryptographic algorithm. ">psa_algorithm_t</a>).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>1 if <code>alg</code> is a hash algorithm, 0 otherwise. This macro may return either 0 or 1 if <code>alg</code> is not a supported algorithm identifier. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="gad8a8ea0536975363b66410cdeafe38b6"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_IS_HASH_AND_SIGN</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">(PSA_ALG_IS_RSA_PSS(alg) || PSA_ALG_IS_RSA_PKCS1V15_SIGN(alg) || \</div><div class="line"> PSA_ALG_IS_DSA(alg) || PSA_ALG_IS_ECDSA(alg))</div></div><!-- fragment --><p>Whether the specified algorithm is a hash-and-sign algorithm.</p>
-<p>Hash-and-sign algorithms are public-key signature algorithms structured in two parts: first the calculation of a hash in a way that does not depend on the key, then the calculation of a signature from the hash value and the key.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>An algorithm identifier (value of type <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69" title="Encoding of a cryptographic algorithm. ">psa_algorithm_t</a>).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>1 if <code>alg</code> is a hash-and-sign algorithm, 0 otherwise. This macro may return either 0 or 1 if <code>alg</code> is not a supported algorithm identifier. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="ga1979d0a76fcee6164cf2e65960f38db2"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_IS_HKDF</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td>   (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_HKDF_BASE)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Whether the specified algorithm is an HKDF algorithm.</p>
-<p>HKDF is a family of key derivation algorithms that are based on a hash function and the HMAC construction.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>An algorithm identifier (value of type <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69" title="Encoding of a cryptographic algorithm. ">psa_algorithm_t</a>).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>1 if <code>alg</code> is an HKDF algorithm, 0 otherwise. This macro may return either 0 or 1 if <code>alg</code> is not a supported key derivation algorithm identifier. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="ga4a050c3c3cbc6eb96418f18847601c8a"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_IS_HMAC</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">(((alg) & (PSA_ALG_CATEGORY_MASK | PSA_ALG_MAC_SUBCATEGORY_MASK)) == \</div><div class="line"> PSA_ALG_HMAC_BASE)</div></div><!-- fragment --><p>Whether the specified algorithm is an HMAC algorithm.</p>
-<p>HMAC is a family of MAC algorithms that are based on a hash function.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>An algorithm identifier (value of type <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69" title="Encoding of a cryptographic algorithm. ">psa_algorithm_t</a>).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>1 if <code>alg</code> is an HMAC algorithm, 0 otherwise. This macro may return either 0 or 1 if <code>alg</code> is not a supported algorithm identifier. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="ga59753742cb06553bd22751bbef472b6f"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_IS_KEY_AGREEMENT</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td>   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_KEY_AGREEMENT)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Whether the specified algorithm is a key agreement algorithm.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>An algorithm identifier (value of type <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69" title="Encoding of a cryptographic algorithm. ">psa_algorithm_t</a>).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>1 if <code>alg</code> is a key agreement algorithm, 0 otherwise. This macro may return either 0 or 1 if <code>alg</code> is not a supported algorithm identifier. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="gaf8b90c648aa53dbd06c236695e300cd0"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_IS_KEY_DERIVATION</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td>   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_KEY_DERIVATION)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Whether the specified algorithm is a key derivation algorithm.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>An algorithm identifier (value of type <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69" title="Encoding of a cryptographic algorithm. ">psa_algorithm_t</a>).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>1 if <code>alg</code> is a key derivation algorithm, 0 otherwise. This macro may return either 0 or 1 if <code>alg</code> is not a supported algorithm identifier. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="gaca7aee4c9dde316b3b1a150a26eab776"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_IS_MAC</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td>   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_MAC)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Whether the specified algorithm is a MAC algorithm.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>An algorithm identifier (value of type <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69" title="Encoding of a cryptographic algorithm. ">psa_algorithm_t</a>).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>1 if <code>alg</code> is a MAC algorithm, 0 otherwise. This macro may return either 0 or 1 if <code>alg</code> is not a supported algorithm identifier. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="gaa40ab362ce141ce541d69b2eb1f41438"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_IS_RAW_KEY_AGREEMENT</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">(<a class="code" href="group__crypto__types.html#ga59753742cb06553bd22751bbef472b6f">PSA_ALG_IS_KEY_AGREEMENT</a>(alg) && \</div><div class="line"> PSA_ALG_KEY_AGREEMENT_GET_KDF(alg) == PSA_ALG_CATEGORY_KEY_DERIVATION)</div><div class="ttc" id="group__crypto__types_html_ga59753742cb06553bd22751bbef472b6f"><div class="ttname"><a href="group__crypto__types.html#ga59753742cb06553bd22751bbef472b6f">PSA_ALG_IS_KEY_AGREEMENT</a></div><div class="ttdeci">#define PSA_ALG_IS_KEY_AGREEMENT(alg)</div><div class="ttdef"><b>Definition:</b> crypto_values.h:624</div></div>
-</div><!-- fragment --><p>Whether the specified algorithm is a raw key agreement algorithm.</p>
-<p>A raw key agreement algorithm is one that does not specify a key derivation function. Usually, raw key agreement algorithms are constructed directly with a <code>PSA_ALG_xxx</code> macro while non-raw key agreement algorithms are constructed with <a class="el" href="group__crypto__types.html#ga78bb81cffb87a635c247725eeb2a2682">PSA_ALG_KEY_AGREEMENT()</a>.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>An algorithm identifier (value of type <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69" title="Encoding of a cryptographic algorithm. ">psa_algorithm_t</a>).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>1 if <code>alg</code> is a raw key agreement algorithm, 0 otherwise. This macro may return either 0 or 1 if <code>alg</code> is not a supported algorithm identifier. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="ga6d490d0904e0698f6c1268a89d72ff31"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_IS_SIGN</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td>   (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_SIGN)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Whether the specified algorithm is a public-key signature algorithm.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>An algorithm identifier (value of type <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69" title="Encoding of a cryptographic algorithm. ">psa_algorithm_t</a>).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>1 if <code>alg</code> is a public-key signature algorithm, 0 otherwise. This macro may return either 0 or 1 if <code>alg</code> is not a supported algorithm identifier. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="gacfec68e0c6175e02e1b2ebc97df383c0"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_IS_STREAM_CIPHER</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">(((alg) & (PSA_ALG_CATEGORY_MASK | PSA_ALG_CIPHER_STREAM_FLAG)) == \</div><div class="line"> (PSA_ALG_CATEGORY_CIPHER | PSA_ALG_CIPHER_STREAM_FLAG))</div></div><!-- fragment --><p>Whether the specified algorithm is a stream cipher.</p>
-<p>A stream cipher is a symmetric cipher that encrypts or decrypts messages by applying a bitwise-xor with a stream of bytes that is generated from a key.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>An algorithm identifier (value of type <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69" title="Encoding of a cryptographic algorithm. ">psa_algorithm_t</a>).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>1 if <code>alg</code> is a stream cipher algorithm, 0 otherwise. This macro may return either 0 or 1 if <code>alg</code> is not a supported algorithm identifier or if it is not a symmetric cipher algorithm. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="gaa3c18890c50222e5219f40ade8927e66"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_IS_TLS12_PRF</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td>   (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_TLS12_PRF_BASE)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Whether the specified algorithm is a TLS-1.2 PRF algorithm.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>An algorithm identifier (value of type <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69" title="Encoding of a cryptographic algorithm. ">psa_algorithm_t</a>).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>1 if <code>alg</code> is a TLS-1.2 PRF algorithm, 0 otherwise. This macro may return either 0 or 1 if <code>alg</code> is not a supported key derivation algorithm identifier. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="gab25ecc074a93fd11069bedfbba5a287b"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_IS_TLS12_PSK_TO_MS</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td>   (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_TLS12_PSK_TO_MS_BASE)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Whether the specified algorithm is a TLS-1.2 PSK to MS algorithm.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>An algorithm identifier (value of type <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69" title="Encoding of a cryptographic algorithm. ">psa_algorithm_t</a>).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>1 if <code>alg</code> is a TLS-1.2 PSK to MS algorithm, 0 otherwise. This macro may return either 0 or 1 if <code>alg</code> is not a supported key derivation algorithm identifier. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="gacf83d7430e82b97cecb8b26ca6fa1426"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_IS_WILDCARD</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">(<a class="code" href="group__crypto__types.html#gad8a8ea0536975363b66410cdeafe38b6">PSA_ALG_IS_HASH_AND_SIGN</a>(alg) ? <a class="code" href="group__crypto__types.html#ga24cf6d7bcd2b9aeeeff86f07b6c674e3">\</a></div><div class="line"><a class="code" href="group__crypto__types.html#ga24cf6d7bcd2b9aeeeff86f07b6c674e3"> PSA_ALG_SIGN_GET_HASH</a>(alg) == <a class="code" href="group__crypto__types.html#gaa1288ea8bd397a8a3f5e19e94110f2e4">PSA_ALG_ANY_HASH</a> : \</div><div class="line"> (alg) == <a class="code" href="group__crypto__types.html#gaa1288ea8bd397a8a3f5e19e94110f2e4">PSA_ALG_ANY_HASH</a>)</div><div class="ttc" id="group__crypto__types_html_gaa1288ea8bd397a8a3f5e19e94110f2e4"><div class="ttname"><a href="group__crypto__types.html#gaa1288ea8bd397a8a3f5e19e94110f2e4">PSA_ALG_ANY_HASH</a></div><div class="ttdeci">#define PSA_ALG_ANY_HASH</div><div class="ttdef"><b>Definition:</b> crypto_values.h:699</div></div>
-<div class="ttc" id="group__crypto__types_html_ga24cf6d7bcd2b9aeeeff86f07b6c674e3"><div class="ttname"><a href="group__crypto__types.html#ga24cf6d7bcd2b9aeeeff86f07b6c674e3">PSA_ALG_SIGN_GET_HASH</a></div><div class="ttdeci">#define PSA_ALG_SIGN_GET_HASH(alg)</div><div class="ttdef"><b>Definition:</b> crypto_values.h:1144</div></div>
-<div class="ttc" id="group__crypto__types_html_gad8a8ea0536975363b66410cdeafe38b6"><div class="ttname"><a href="group__crypto__types.html#gad8a8ea0536975363b66410cdeafe38b6">PSA_ALG_IS_HASH_AND_SIGN</a></div><div class="ttdeci">#define PSA_ALG_IS_HASH_AND_SIGN(alg)</div><div class="ttdef"><b>Definition:</b> crypto_values.h:1122</div></div>
-</div><!-- fragment --><p>Whether the specified algorithm encoding is a wildcard.</p>
-<p>Wildcard values may only be used to set the usage algorithm field in a policy, not to perform an operation.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>An algorithm identifier (value of type <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69" title="Encoding of a cryptographic algorithm. ">psa_algorithm_t</a>).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>1 if <code>alg</code> is a wildcard algorithm encoding. </dd>
-<dd>
-0 if <code>alg</code> is a non-wildcard algorithm encoding (suitable for an operation). </dd>
-<dd>
-This macro may return either 0 or 1 if <code>alg</code> is not a supported algorithm identifier. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="ga78bb81cffb87a635c247725eeb2a2682"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_KEY_AGREEMENT</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">ka_alg, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"> </td>
- <td class="paramname">kdf_alg </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td>   ((ka_alg) | (kdf_alg))</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Macro to build a combined algorithm that chains a key agreement with a key derivation.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">ka_alg</td><td>A key agreement algorithm (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#ga59753742cb06553bd22751bbef472b6f">PSA_ALG_IS_KEY_AGREEMENT</a>(<code>ka_alg</code>) is true). </td></tr>
- <tr><td class="paramname">kdf_alg</td><td>A key derivation algorithm (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#gaf8b90c648aa53dbd06c236695e300cd0">PSA_ALG_IS_KEY_DERIVATION</a>(<code>kdf_alg</code>) is true).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>The corresponding key agreement and derivation algorithm. </dd>
-<dd>
-Unspecified if <code>ka_alg</code> is not a supported key agreement algorithm or <code>kdf_alg</code> is not a supported key derivation algorithm. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="gaa1235dc3fdd9839c6c1b1a9857344c76"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_RSA_OAEP</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">hash_alg</td><td>)</td>
- <td>   (PSA_ALG_RSA_OAEP_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>RSA OAEP encryption.</p>
-<p>This is the encryption scheme defined by RFC 8017 (PKCS#1: RSA Cryptography Specifications) under the name RSAES-OAEP, with the message generation function MGF1.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">hash_alg</td><td>The hash algorithm (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#gac9280662bb482590b4b33d1dcd32930f">PSA_ALG_IS_HASH</a>(<code>hash_alg</code>) is true) to use for MGF1.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>The corresponding RSA OAEP signature algorithm. </dd>
-<dd>
-Unspecified if <code>alg</code> is not a supported hash algorithm. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="gae6b0b87aabe82a1b3113824f022c52e8"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_RSA_OAEP_GET_HASH</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">(PSA_ALG_IS_RSA_OAEP(alg) ? \</div><div class="line"> ((alg) & PSA_ALG_HASH_MASK) | PSA_ALG_CATEGORY_HASH : \</div><div class="line"> 0)</div></div><!-- fragment -->
-</div>
-</div>
-<a class="anchor" id="ga4c540d3abe43fb9abcb94f2bc51acef9"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_RSA_PKCS1V15_CRYPT   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x12020000)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>RSA PKCS#1 v1.5 encryption. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga702ff75385a6ae7d4247033f479439af"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_RSA_PKCS1V15_SIGN</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">hash_alg</td><td>)</td>
- <td>   (PSA_ALG_RSA_PKCS1V15_SIGN_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>RSA PKCS#1 v1.5 signature with hashing.</p>
-<p>This is the signature scheme defined by RFC 8017 (PKCS#1: RSA Cryptography Specifications) under the name RSASSA-PKCS1-v1_5.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">hash_alg</td><td>A hash algorithm (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#gac9280662bb482590b4b33d1dcd32930f">PSA_ALG_IS_HASH</a>(<code>hash_alg</code>) is true). This includes <a class="el" href="group__crypto__types.html#gaa1288ea8bd397a8a3f5e19e94110f2e4">PSA_ALG_ANY_HASH</a> when specifying the algorithm in a usage policy.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>The corresponding RSA PKCS#1 v1.5 signature algorithm. </dd>
-<dd>
-Unspecified if <code>alg</code> is not a supported hash algorithm. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="ga4215e2a78dcf834e9a625927faa2a817"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_RSA_PKCS1V15_SIGN_RAW   PSA_ALG_RSA_PKCS1V15_SIGN_BASE</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Raw PKCS#1 v1.5 signature.</p>
-<p>The input to this algorithm is the DigestInfo structure used by RFC 8017 (PKCS#1: RSA Cryptography Specifications), §9.2 steps 3–6. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga62152bf4cb4bf6aace5e1be8f143564d"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_RSA_PSS</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">hash_alg</td><td>)</td>
- <td>   (PSA_ALG_RSA_PSS_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>RSA PSS signature with hashing.</p>
-<p>This is the signature scheme defined by RFC 8017 (PKCS#1: RSA Cryptography Specifications) under the name RSASSA-PSS, with the message generation function MGF1, and with a salt length equal to the length of the hash. The specified hash algorithm is used to hash the input message, to create the salted hash, and for the mask generation.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">hash_alg</td><td>A hash algorithm (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#gac9280662bb482590b4b33d1dcd32930f">PSA_ALG_IS_HASH</a>(<code>hash_alg</code>) is true). This includes <a class="el" href="group__crypto__types.html#gaa1288ea8bd397a8a3f5e19e94110f2e4">PSA_ALG_ANY_HASH</a> when specifying the algorithm in a usage policy.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>The corresponding RSA PSS signature algorithm. </dd>
-<dd>
-Unspecified if <code>alg</code> is not a supported hash algorithm. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="ga16f5fe34ccce68c2fada1224c054a999"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_SHA3_224   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000010)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>SHA3-224 </p>
-
-</div>
-</div>
-<a class="anchor" id="gaace70d9515489bbe3c5e7ac1b7d9155b"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_SHA3_256   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000011)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>SHA3-256 </p>
-
-</div>
-</div>
-<a class="anchor" id="gab0f079257ea75e2acfe2fc3b38c78cd8"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_SHA3_384   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000012)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>SHA3-384 </p>
-
-</div>
-</div>
-<a class="anchor" id="ga37e5dbe936dddb155e76f2997de27188"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_SHA3_512   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000013)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>SHA3-512 </p>
-
-</div>
-</div>
-<a class="anchor" id="ga25d6a3244d10a7148fe6b026d1979f7b"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_SHA_224   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000008)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>SHA2-224 </p>
-
-</div>
-</div>
-<a class="anchor" id="ga619471f978e13cdd0a1e37145e4bf341"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_SHA_256   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x01000009)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>SHA2-256 </p>
-
-</div>
-</div>
-<a class="anchor" id="ga58af64dd9a86a287e8da9ed7739eead4"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_SHA_384   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x0100000a)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>SHA2-384 </p>
-
-</div>
-</div>
-<a class="anchor" id="gafba3ae409f46d3dd7f37a0910660c3e9"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_SHA_512   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x0100000b)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>SHA2-512 </p>
-
-</div>
-</div>
-<a class="anchor" id="ga3fe2d7c3c80e3186ca78d16a35d5d931"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_SHA_512_224   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x0100000c)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>SHA2-512/224 </p>
-
-</div>
-</div>
-<a class="anchor" id="ga5910b3964c14e9613e8643a45b09c2d4"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_SHA_512_256   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x0100000d)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>SHA2-512/256 </p>
-
-</div>
-</div>
-<a class="anchor" id="ga24cf6d7bcd2b9aeeeff86f07b6c674e3"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_SIGN_GET_HASH</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">(<a class="code" href="group__crypto__types.html#gad8a8ea0536975363b66410cdeafe38b6">PSA_ALG_IS_HASH_AND_SIGN</a>(alg) ? \</div><div class="line"> ((alg) & PSA_ALG_HASH_MASK) == 0 ? <span class="comment">/*"raw" algorithm*/</span> 0 : \</div><div class="line"> ((alg) & PSA_ALG_HASH_MASK) | PSA_ALG_CATEGORY_HASH : \</div><div class="line"> 0)</div><div class="ttc" id="group__crypto__types_html_gad8a8ea0536975363b66410cdeafe38b6"><div class="ttname"><a href="group__crypto__types.html#gad8a8ea0536975363b66410cdeafe38b6">PSA_ALG_IS_HASH_AND_SIGN</a></div><div class="ttdeci">#define PSA_ALG_IS_HASH_AND_SIGN(alg)</div><div class="ttdef"><b>Definition:</b> crypto_values.h:1122</div></div>
-</div><!-- fragment --><p>Get the hash used by a hash-and-sign signature algorithm.</p>
-<p>A hash-and-sign algorithm is a signature algorithm which is composed of two phases: first a hashing phase which does not use the key and produces a hash of the input message, then a signing phase which only uses the hash and the key and not the message itself.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>A signature algorithm (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#ga6d490d0904e0698f6c1268a89d72ff31">PSA_ALG_IS_SIGN</a>(<code>alg</code>) is true).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>The underlying hash algorithm if <code>alg</code> is a hash-and-sign algorithm. </dd>
-<dd>
-0 if <code>alg</code> is a signature algorithm that does not follow the hash-and-sign structure. </dd>
-<dd>
-Unspecified if <code>alg</code> is not a signature algorithm or if it is not supported by the implementation. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="ga6d5623c2ccda1d4a84e34351af8382d5"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_TLS12_PRF</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">hash_alg</td><td>)</td>
- <td>   (PSA_ALG_TLS12_PRF_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Macro to build a TLS-1.2 PRF algorithm.</p>
-<p>TLS 1.2 uses a custom pseudorandom function (PRF) for key schedule, specified in Section 5 of RFC 5246. It is based on HMAC and can be used with either SHA-256 or SHA-384.</p>
-<p>For the application to TLS-1.2, the salt and label arguments passed to psa_key_derivation() are what's called 'seed' and 'label' in RFC 5246, respectively. For example, for TLS key expansion, the salt is the concatenation of ServerHello.Random + ClientHello.Random, while the label is "key expansion".</p>
-<p>For example, <code><a class="el" href="group__crypto__types.html#ga6d5623c2ccda1d4a84e34351af8382d5">PSA_ALG_TLS12_PRF(PSA_ALG_SHA256)</a></code> represents the TLS 1.2 PRF using HMAC-SHA-256.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">hash_alg</td><td>A hash algorithm (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#gac9280662bb482590b4b33d1dcd32930f">PSA_ALG_IS_HASH</a>(<code>hash_alg</code>) is true).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>The corresponding TLS-1.2 PRF algorithm. </dd>
-<dd>
-Unspecified if <code>alg</code> is not a supported hash algorithm. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="ga039ec797f15d1635d9b2e09a611f8a68"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_TLS12_PSK_TO_MS</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">hash_alg</td><td>)</td>
- <td>   (PSA_ALG_TLS12_PSK_TO_MS_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Macro to build a TLS-1.2 PSK-to-MasterSecret algorithm.</p>
-<p>In a pure-PSK handshake in TLS 1.2, the master secret is derived from the PreSharedKey (PSK) through the application of padding (RFC 4279, Section 2) and the TLS-1.2 PRF (RFC 5246, Section 5). The latter is based on HMAC and can be used with either SHA-256 or SHA-384.</p>
-<p>For the application to TLS-1.2, the salt passed to psa_key_derivation() (and forwarded to the TLS-1.2 PRF) is the concatenation of the ClientHello.Random + ServerHello.Random, while the label is "master secret" or "extended master secret".</p>
-<p>For example, <code><a class="el" href="group__crypto__types.html#ga039ec797f15d1635d9b2e09a611f8a68">PSA_ALG_TLS12_PSK_TO_MS(PSA_ALG_SHA256)</a></code> represents the TLS-1.2 PSK to MasterSecret derivation PRF using HMAC-SHA-256.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">hash_alg</td><td>A hash algorithm (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#gac9280662bb482590b4b33d1dcd32930f">PSA_ALG_IS_HASH</a>(<code>hash_alg</code>) is true).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>The corresponding TLS-1.2 PSK to MS algorithm. </dd>
-<dd>
-Unspecified if <code>alg</code> is not a supported hash algorithm. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="gaf36137110baf7bb13c5028fd62c64276"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_TRUNCATED_MAC</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"> </td>
- <td class="paramname">mac_length </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">(((alg) & ~PSA_ALG_MAC_TRUNCATION_MASK) | \</div><div class="line"> ((mac_length) << PSA_MAC_TRUNCATION_OFFSET & PSA_ALG_MAC_TRUNCATION_MASK))</div></div><!-- fragment --><p>Macro to build a truncated MAC algorithm.</p>
-<p>A truncated MAC algorithm is identical to the corresponding MAC algorithm except that the MAC value for the truncated algorithm consists of only the first <code>mac_length</code> bytes of the MAC value for the untruncated algorithm.</p>
-<dl class="section note"><dt>Note</dt><dd>This macro may allow constructing algorithm identifiers that are not valid, either because the specified length is larger than the untruncated MAC or because the specified length is smaller than permitted by the implementation.</dd>
-<dd>
-It is implementation-defined whether a truncated MAC that is truncated to the same length as the MAC of the untruncated algorithm is considered identical to the untruncated algorithm for policy comparison purposes.</dd></dl>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>A MAC algorithm identifier (value of type <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69" title="Encoding of a cryptographic algorithm. ">psa_algorithm_t</a> such that <a class="el" href="group__crypto__types.html#gaca7aee4c9dde316b3b1a150a26eab776">PSA_ALG_IS_MAC</a>(<code>alg</code>) is true). This may be a truncated or untruncated MAC algorithm. </td></tr>
- <tr><td class="paramname">mac_length</td><td>Desired length of the truncated MAC in bytes. This must be at most the full length of the MAC and must be at least an implementation-specified minimum. The implementation-specified minimum shall not be zero.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>The corresponding MAC algorithm with the specified length. </dd>
-<dd>
-Unspecified if <code>alg</code> is not a supported MAC algorithm or if <code>mac_length</code> is too small or too large for the specified MAC algorithm. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="gaa722c0e426a797fd6d99623f59748125"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ALG_XTS   ((<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a>)0x044000ff)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The XTS cipher mode.</p>
-<p>XTS is a cipher mode which is built from a block cipher. It requires at least one full block of input, but beyond this minimum the input does not need to be a whole number of blocks. </p>
-
-</div>
-</div>
-<a class="anchor" id="gacaa366bdeb0413e63e87a667c5457b2e"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_BLOCK_CIPHER_BLOCK_SIZE</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">type</td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">( \</div><div class="line"> (type) == <a class="code" href="group__crypto__types.html#ga6ee54579dcf278c677eda4bb1a29575e">PSA_KEY_TYPE_AES</a> ? 16 : \</div><div class="line"> (type) == <a class="code" href="group__crypto__types.html#ga577562bfbbc691c820d55ec308333138">PSA_KEY_TYPE_DES</a> ? 8 : \</div><div class="line"> (type) == <a class="code" href="group__crypto__types.html#gad8e5da742343fd5519f9d8a630c2ed81">PSA_KEY_TYPE_CAMELLIA</a> ? 16 : \</div><div class="line"> (type) == <a class="code" href="group__crypto__types.html#gae4d46e83f910dcaa126000a8ed03cde9">PSA_KEY_TYPE_ARC4</a> ? 1 : \</div><div class="line"> 0)</div><div class="ttc" id="group__crypto__types_html_ga577562bfbbc691c820d55ec308333138"><div class="ttname"><a href="group__crypto__types.html#ga577562bfbbc691c820d55ec308333138">PSA_KEY_TYPE_DES</a></div><div class="ttdeci">#define PSA_KEY_TYPE_DES</div><div class="ttdef"><b>Definition:</b> crypto_values.h:407</div></div>
-<div class="ttc" id="group__crypto__types_html_gad8e5da742343fd5519f9d8a630c2ed81"><div class="ttname"><a href="group__crypto__types.html#gad8e5da742343fd5519f9d8a630c2ed81">PSA_KEY_TYPE_CAMELLIA</a></div><div class="ttdeci">#define PSA_KEY_TYPE_CAMELLIA</div><div class="ttdef"><b>Definition:</b> crypto_values.h:411</div></div>
-<div class="ttc" id="group__crypto__types_html_ga6ee54579dcf278c677eda4bb1a29575e"><div class="ttname"><a href="group__crypto__types.html#ga6ee54579dcf278c677eda4bb1a29575e">PSA_KEY_TYPE_AES</a></div><div class="ttdeci">#define PSA_KEY_TYPE_AES</div><div class="ttdef"><b>Definition:</b> crypto_values.h:396</div></div>
-<div class="ttc" id="group__crypto__types_html_gae4d46e83f910dcaa126000a8ed03cde9"><div class="ttname"><a href="group__crypto__types.html#gae4d46e83f910dcaa126000a8ed03cde9">PSA_KEY_TYPE_ARC4</a></div><div class="ttdeci">#define PSA_KEY_TYPE_ARC4</div><div class="ttdef"><b>Definition:</b> crypto_values.h:417</div></div>
-</div><!-- fragment --><p>The block size of a block cipher.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">type</td><td>A cipher key type (value of type <a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628" title="Encoding of a key type. ">psa_key_type_t</a>).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>The block size for a block cipher, or 1 for a stream cipher. The return value is undefined if <code>type</code> is not a supported cipher key type.</dd></dl>
-<dl class="section note"><dt>Note</dt><dd>It is possible to build stream cipher algorithms on top of a block cipher, for example CTR mode (<a class="el" href="group__crypto__types.html#gad318309706a769cffdc64e4c7e06b2e9">PSA_ALG_CTR</a>). This macro only takes the key type into account, so it cannot be used to determine the size of the data that <a class="el" href="group__cipher.html#gafd0caea99cf1052527e4089d37f5ab91">psa_cipher_update()</a> might buffer for future processing in general.</dd>
-<dd>
-This macro returns a compile-time constant if its argument is one.</dd></dl>
-<dl class="section warning"><dt>Warning</dt><dd>This macro may evaluate its argument multiple times. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="ga6ee54579dcf278c677eda4bb1a29575e"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_AES   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x40000001)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Key for an cipher, AEAD or MAC algorithm based on the AES block cipher.</p>
-<p>The size of the key can be 16 bytes (AES-128), 24 bytes (AES-192) or 32 bytes (AES-256). </p>
-
-</div>
-</div>
-<a class="anchor" id="gae4d46e83f910dcaa126000a8ed03cde9"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_ARC4   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x40000004)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Key for the RC4 stream cipher.</p>
-<p>Note that RC4 is weak and deprecated and should only be used in legacy protocols. </p>
-
-</div>
-</div>
-<a class="anchor" id="gad8e5da742343fd5519f9d8a630c2ed81"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_CAMELLIA   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x40000003)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Key for an cipher, AEAD or MAC algorithm based on the Camellia block cipher. </p>
-
-</div>
-</div>
-<a class="anchor" id="gae871b2357b8593f33bfd51abbf93ebb1"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_DERIVE   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x52000000)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>A secret for key derivation.</p>
-<p>The key policy determines which key derivation algorithm the key can be used for. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga577562bfbbc691c820d55ec308333138"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_DES   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x40000002)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Key for a cipher or MAC algorithm based on DES or 3DES (Triple-DES).</p>
-<p>The size of the key can be 8 bytes (single DES), 16 bytes (2-key 3DES) or 24 bytes (3-key 3DES).</p>
-<p>Note that single DES and 2-key 3DES are weak and strongly deprecated and should only be used to decrypt legacy data. 3-key 3DES is weak and deprecated and should only be used in legacy protocols. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga39b63c6b97a62a316c0660bf72b2fdd5"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_DH_KEYPAIR   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x70040000)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Diffie-Hellman key exchange key pair (private and public key). </p>
-
-</div>
-</div>
-<a class="anchor" id="ga325a340d7c72d99d3a678eb210bf6e0a"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_DH_PUBLIC_KEY   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x60040000)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Diffie-Hellman key exchange public key. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga011010ee28c20388f3d89fb27088ed62"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_DSA_KEYPAIR   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x70020000)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>DSA key pair (private and public key). </p>
-
-</div>
-</div>
-<a class="anchor" id="ga5e7439c2905136366c3a876e62e5ddfc"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_DSA_PUBLIC_KEY   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x60020000)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>DSA public key. </p>
-
-</div>
-</div>
-<a class="anchor" id="gadf3ad65d157bf5282849c954bf3f51af"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_ECC_KEYPAIR</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">curve</td><td>)</td>
- <td>   (PSA_KEY_TYPE_ECC_KEYPAIR_BASE | (curve))</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Elliptic curve key pair. </p>
-
-</div>
-</div>
-<a class="anchor" id="gad54c03d3b47020e571a72cd01d978cf2"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_ECC_PUBLIC_KEY</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">curve</td><td>)</td>
- <td>   (PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE | (curve))</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Elliptic curve public key. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga0c567210e6f80aa8f2aa87efa7a3a3f9"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_GET_CURVE</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">type</td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">((<a class="code" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a>) (<a class="code" href="group__crypto__types.html#ga88e01fa06b585654689a99bcc06bbe66">PSA_KEY_TYPE_IS_ECC</a>(type) ? \</div><div class="line"> ((type) & PSA_KEY_TYPE_ECC_CURVE_MASK) : \</div><div class="line"> 0))</div><div class="ttc" id="group__crypto__types_html_ga4e8977c145cce5077c4bce7fec890ad9"><div class="ttname"><a href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a></div><div class="ttdeci">uint16_t psa_ecc_curve_t</div><div class="ttdef"><b>Definition:</b> crypto_types.h:64</div></div>
-<div class="ttc" id="group__crypto__types_html_ga88e01fa06b585654689a99bcc06bbe66"><div class="ttname"><a href="group__crypto__types.html#ga88e01fa06b585654689a99bcc06bbe66">PSA_KEY_TYPE_IS_ECC</a></div><div class="ttdeci">#define PSA_KEY_TYPE_IS_ECC(type)</div><div class="ttdef"><b>Definition:</b> crypto_values.h:446</div></div>
-</div><!-- fragment --><p>Extract the curve from an elliptic curve key type. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga92d989f4ca64abd00f463defd773a6f8"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_HMAC   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x51000000)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>HMAC key.</p>
-<p>The key policy determines which underlying hash algorithm the key can be used for.</p>
-<p>HMAC keys should generally have the same size as the underlying hash. This size can be calculated with <a class="el" href="crypto__sizes_8h.html#aef340331ce3cba2b57e1fc5624bf1f99">PSA_HASH_SIZE</a>(<code>alg</code>) where <code>alg</code> is the HMAC algorithm or the underlying hash algorithm. </p>
-
-</div>
-</div>
-<a class="anchor" id="gab138ae2ebf2905dfbaf4154db2620939"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_IS_ASYMMETRIC</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">type</td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">(((type) & PSA_KEY_TYPE_CATEGORY_MASK \</div><div class="line"> & ~PSA_KEY_TYPE_CATEGORY_FLAG_PAIR) == \</div><div class="line"> PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY)</div></div><!-- fragment --><p>Whether a key type is asymmetric: either a key pair or a public key. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga248ae35c0e2becaebbf479fc1c3a3b0e"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_IS_DH</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">type</td><td>)</td>
- <td>   (<a class="el" href="group__crypto__types.html#gace08e46dd7cbf642d50d982a25d02bec">PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR</a>(type) == <a class="el" href="group__crypto__types.html#ga325a340d7c72d99d3a678eb210bf6e0a">PSA_KEY_TYPE_DH_PUBLIC_KEY</a>)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Whether a key type is a Diffie-Hellman key exchange key (pair or public-only). </p>
-
-</div>
-</div>
-<a class="anchor" id="ga273fdfcf23eb0624f8b63d2321cf95c1"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_IS_DSA</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">type</td><td>)</td>
- <td>   (<a class="el" href="group__crypto__types.html#gace08e46dd7cbf642d50d982a25d02bec">PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR</a>(type) == <a class="el" href="group__crypto__types.html#ga5e7439c2905136366c3a876e62e5ddfc">PSA_KEY_TYPE_DSA_PUBLIC_KEY</a>)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Whether a key type is an DSA key (pair or public-only). </p>
-
-</div>
-</div>
-<a class="anchor" id="ga88e01fa06b585654689a99bcc06bbe66"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_IS_ECC</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">type</td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">((<a class="code" href="group__crypto__types.html#gace08e46dd7cbf642d50d982a25d02bec">PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR</a>(type) & \</div><div class="line"> ~PSA_KEY_TYPE_ECC_CURVE_MASK) == PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE)</div><div class="ttc" id="group__crypto__types_html_gace08e46dd7cbf642d50d982a25d02bec"><div class="ttname"><a href="group__crypto__types.html#gace08e46dd7cbf642d50d982a25d02bec">PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR</a></div><div class="ttdeci">#define PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR(type)</div><div class="ttdef"><b>Definition:</b> crypto_values.h:365</div></div>
-</div><!-- fragment --><p>Whether a key type is an elliptic curve key (pair or public-only). </p>
-
-</div>
-</div>
-<a class="anchor" id="ga7bf101b671e8cf26f4cb08fcb679db4b"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_IS_ECC_KEYPAIR</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">type</td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">(((type) & ~PSA_KEY_TYPE_ECC_CURVE_MASK) == \</div><div class="line"> PSA_KEY_TYPE_ECC_KEYPAIR_BASE)</div></div><!-- fragment --><p>Whether a key type is an elliptic curve key pair. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga5af146a173b0c84d7e737e2fb6a3c0a7"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">type</td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">(((type) & ~PSA_KEY_TYPE_ECC_CURVE_MASK) == \</div><div class="line"> PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE)</div></div><!-- fragment --><p>Whether a key type is an elliptic curve public key. </p>
-
-</div>
-</div>
-<a class="anchor" id="gac14c6d6e1b2b7f4a92a7b757465cff29"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_IS_KEYPAIR</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">type</td><td>)</td>
- <td>   (((type) & PSA_KEY_TYPE_CATEGORY_MASK) == PSA_KEY_TYPE_CATEGORY_KEY_PAIR)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Whether a key type is a key pair containing a private part and a public part. </p>
-
-</div>
-</div>
-<a class="anchor" id="gac674a0f059bc0cb72b47f0c517b4f45b"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_IS_PUBLIC_KEY</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">type</td><td>)</td>
- <td>   (((type) & PSA_KEY_TYPE_CATEGORY_MASK) == PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Whether a key type is the public part of a key pair. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga0e1d8f241228e49c9cadadfb4579ef1a"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_IS_RSA</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">type</td><td>)</td>
- <td>   (<a class="el" href="group__crypto__types.html#gace08e46dd7cbf642d50d982a25d02bec">PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR</a>(type) == <a class="el" href="group__crypto__types.html#ga9ba0878f56c8bcd1995ac017a74f513b">PSA_KEY_TYPE_RSA_PUBLIC_KEY</a>)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Whether a key type is an RSA key (pair or public-only). </p>
-
-</div>
-</div>
-<a class="anchor" id="gaef86ce4e810e1c2c76068ac874bfef54"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_IS_UNSTRUCTURED</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">type</td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<b>Value:</b><div class="fragment"><div class="line">(((type) & PSA_KEY_TYPE_CATEGORY_MASK & ~(<a class="code" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x10000000) == \</div><div class="line"> PSA_KEY_TYPE_CATEGORY_SYMMETRIC)</div><div class="ttc" id="group__crypto__types_html_ga578159487dfc7096cb191b0d2befe628"><div class="ttname"><a href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a></div><div class="ttdeci">uint32_t psa_key_type_t</div><div class="ttdoc">Encoding of a key type. </div><div class="ttdef"><b>Definition:</b> crypto_types.h:61</div></div>
-</div><!-- fragment --><p>Whether a key type is an unstructured array of bytes.</p>
-<p>This encompasses both symmetric keys and non-key data. </p>
-
-</div>
-</div>
-<a class="anchor" id="gadbe4c086a6562aefe344bc79e51bdfd3"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_IS_VENDOR_DEFINED</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">type</td><td>)</td>
- <td>   (((type) & <a class="el" href="group__crypto__types.html#ga8dbaed2fdb1ebae8aa127ad3988516f7">PSA_KEY_TYPE_VENDOR_FLAG</a>) != 0)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Whether a key type is vendor-defined. </p>
-
-</div>
-</div>
-<a class="anchor" id="gaf09f1ca1de6a7e7cff0fe516f3f6c91d"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_KEYPAIR_OF_PUBLIC_KEY</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">type</td><td>)</td>
- <td>   ((type) | PSA_KEY_TYPE_CATEGORY_FLAG_PAIR)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The key pair type corresponding to a public key type.</p>
-<p>You may also pass a key pair type as <code>type</code>, it will be left unchanged.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">type</td><td>A public key type or key pair type.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>The corresponding key pair type. If <code>type</code> is not a public key or a key pair, the return value is undefined. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="gafce7ab2b54ce97ea5bff73f13a9f3e5b"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_NONE   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x00000000)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>An invalid key type value.</p>
-<p>Zero is not the encoding of any key type. </p>
-
-</div>
-</div>
-<a class="anchor" id="gace08e46dd7cbf642d50d982a25d02bec"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">type</td><td>)</td>
- <td>   ((type) & ~PSA_KEY_TYPE_CATEGORY_FLAG_PAIR)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The public key type corresponding to a key pair type.</p>
-<p>You may also pass a key pair type as <code>type</code>, it will be left unchanged.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">type</td><td>A public key type or key pair type.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>The corresponding public key type. If <code>type</code> is not a public key or a key pair, the return value is undefined. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="gaa97f92025533102616b32d571c940d80"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_RAW_DATA   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x50000001)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Raw data.</p>
-<p>A "key" of this type cannot be used for any cryptographic operation. Applications may use this type to store arbitrary data in the keystore. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga581f50687f5d650456925278948f2799"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_RSA_KEYPAIR   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x70010000)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>RSA key pair (private and public key). </p>
-
-</div>
-</div>
-<a class="anchor" id="ga9ba0878f56c8bcd1995ac017a74f513b"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_RSA_PUBLIC_KEY   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x60010000)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>RSA public key. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga8dbaed2fdb1ebae8aa127ad3988516f7"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_TYPE_VENDOR_FLAG   ((<a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a>)0x80000000)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Vendor-defined flag</p>
-<p>Key types defined by this standard will never have the <a class="el" href="group__crypto__types.html#ga8dbaed2fdb1ebae8aa127ad3988516f7">PSA_KEY_TYPE_VENDOR_FLAG</a> bit set. Vendors who define additional key types must use an encoding with the <a class="el" href="group__crypto__types.html#ga8dbaed2fdb1ebae8aa127ad3988516f7">PSA_KEY_TYPE_VENDOR_FLAG</a> bit set and should respect the bitwise structure used by standard encodings whenever practical. </p>
-
-</div>
-</div>
-<a class="anchor" id="gab03726c4476174e019a08e2a04018ce8"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_MAC_TRUNCATED_LENGTH</td>
- <td>(</td>
- <td class="paramtype"> </td>
- <td class="paramname">alg</td><td>)</td>
- <td>   (((alg) & PSA_ALG_MAC_TRUNCATION_MASK) >> PSA_MAC_TRUNCATION_OFFSET)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Length to which a MAC algorithm is truncated.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">alg</td><td>A MAC algorithm identifier (value of type <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69" title="Encoding of a cryptographic algorithm. ">psa_algorithm_t</a> such that <a class="el" href="group__crypto__types.html#gaca7aee4c9dde316b3b1a150a26eab776">PSA_ALG_IS_MAC</a>(<code>alg</code>) is true).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>Length of the truncated MAC in bytes. </dd>
-<dd>
-0 if <code>alg</code> is a non-truncated MAC algorithm. </dd>
-<dd>
-Unspecified if <code>alg</code> is not a supported MAC algorithm. </dd></dl>
-
-</div>
-</div>
-<h2 class="groupheader">Typedef Documentation</h2>
-<a class="anchor" id="gac2e4d47f1300d73c2f829a6d99252d69"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">typedef uint32_t <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a></td>
- </tr>
- </table>
-</div><div class="memdoc">
-
-<p>Encoding of a cryptographic algorithm. </p>
-<p>For algorithms that can be applied to multiple key types, this type does not encode the key type. For example, for symmetric ciphers based on a block cipher, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69" title="Encoding of a cryptographic algorithm. ">psa_algorithm_t</a> encodes the block cipher mode and the padding mode while the block cipher itself is encoded via <a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628" title="Encoding of a key type. ">psa_key_type_t</a>. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga4e8977c145cce5077c4bce7fec890ad9"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">typedef uint16_t <a class="el" href="group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9">psa_ecc_curve_t</a></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The type of PSA elliptic curve identifiers. </p>
-
-</div>
-</div>
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/group__derivation.html b/docs/html/group__derivation.html
deleted file mode 100644
index 0c17519..0000000
--- a/docs/html/group__derivation.html
+++ /dev/null
@@ -1,524 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: Key derivation</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li class="current"><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
-</div><!-- top -->
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div class="header">
- <div class="summary">
-<a href="#define-members">Macros</a> |
-<a href="#typedef-members">Typedefs</a> |
-<a href="#func-members">Functions</a> </div>
- <div class="headertitle">
-<div class="title">Key derivation</div> </div>
-</div><!--header-->
-<div class="contents">
-<table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="define-members"></a>
-Macros</h2></td></tr>
-<tr class="memitem:ga90a1995a41e26ed5ca30d2d4641d1168"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__derivation.html#ga90a1995a41e26ed5ca30d2d4641d1168">PSA_KDF_STEP_SECRET</a>   ((<a class="el" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">psa_key_derivation_step_t</a>)0x0101)</td></tr>
-<tr class="separator:ga90a1995a41e26ed5ca30d2d4641d1168"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga9f4da10191bcb690b88756ed8470b03c"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__derivation.html#ga9f4da10191bcb690b88756ed8470b03c">PSA_KDF_STEP_LABEL</a>   ((<a class="el" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">psa_key_derivation_step_t</a>)0x0201)</td></tr>
-<tr class="separator:ga9f4da10191bcb690b88756ed8470b03c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga384777dac55791d8f3a1af72c847b327"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__derivation.html#ga384777dac55791d8f3a1af72c847b327">PSA_KDF_STEP_SALT</a>   ((<a class="el" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">psa_key_derivation_step_t</a>)0x0202)</td></tr>
-<tr class="separator:ga384777dac55791d8f3a1af72c847b327"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga836afe760bbda3dafc6c29631560b1a0"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__derivation.html#ga836afe760bbda3dafc6c29631560b1a0">PSA_KDF_STEP_INFO</a>   ((<a class="el" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">psa_key_derivation_step_t</a>)0x0203)</td></tr>
-<tr class="separator:ga836afe760bbda3dafc6c29631560b1a0"><td class="memSeparator" colspan="2"> </td></tr>
-</table><table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="typedef-members"></a>
-Typedefs</h2></td></tr>
-<tr class="memitem:gaac4eeacd36596c548b3a48fc06c5048b"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="gaac4eeacd36596c548b3a48fc06c5048b"></a>
-typedef uint16_t </td><td class="memItemRight" valign="bottom"><a class="el" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">psa_key_derivation_step_t</a></td></tr>
-<tr class="memdesc:gaac4eeacd36596c548b3a48fc06c5048b"><td class="mdescLeft"> </td><td class="mdescRight">Encoding of the step of a key derivation. <br /></td></tr>
-<tr class="separator:gaac4eeacd36596c548b3a48fc06c5048b"><td class="memSeparator" colspan="2"> </td></tr>
-</table><table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="func-members"></a>
-Functions</h2></td></tr>
-<tr class="memitem:ga1825696be813dfac2b8d3d02717e71c5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__derivation.html#ga1825696be813dfac2b8d3d02717e71c5">psa_key_derivation_setup</a> (<a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> *generator, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg)</td></tr>
-<tr class="separator:ga1825696be813dfac2b8d3d02717e71c5"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1b30e888db65c71f5337900848e1b03f"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__derivation.html#ga1b30e888db65c71f5337900848e1b03f">psa_key_derivation_input_bytes</a> (<a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> *generator, <a class="el" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">psa_key_derivation_step_t</a> step, const uint8_t *data, size_t data_length)</td></tr>
-<tr class="separator:ga1b30e888db65c71f5337900848e1b03f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga9e5f549aa1f6f3863a07008d3d98f91a"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__derivation.html#ga9e5f549aa1f6f3863a07008d3d98f91a">psa_key_derivation_input_key</a> (<a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> *generator, <a class="el" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">psa_key_derivation_step_t</a> step, <a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle)</td></tr>
-<tr class="separator:ga9e5f549aa1f6f3863a07008d3d98f91a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga2c7fe304cacc141ffb91553548abc5d2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__derivation.html#ga2c7fe304cacc141ffb91553548abc5d2">psa_key_agreement</a> (<a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> *generator, <a class="el" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">psa_key_derivation_step_t</a> step, <a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> private_key, const uint8_t *peer_key, size_t peer_key_length)</td></tr>
-<tr class="separator:ga2c7fe304cacc141ffb91553548abc5d2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaf1b12eff66a1a0020b5bdc8d0e910006"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__derivation.html#gaf1b12eff66a1a0020b5bdc8d0e910006">psa_key_agreement_raw_shared_secret</a> (<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg, <a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> private_key, const uint8_t *peer_key, size_t peer_key_length, uint8_t *output, size_t output_size, size_t *output_length)</td></tr>
-<tr class="separator:gaf1b12eff66a1a0020b5bdc8d0e910006"><td class="memSeparator" colspan="2"> </td></tr>
-</table>
-<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
-<h2 class="groupheader">Macro Definition Documentation</h2>
-<a class="anchor" id="ga836afe760bbda3dafc6c29631560b1a0"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KDF_STEP_INFO   ((<a class="el" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">psa_key_derivation_step_t</a>)0x0203)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>An information string for key derivation.</p>
-<p>This must be a direct input. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga9f4da10191bcb690b88756ed8470b03c"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KDF_STEP_LABEL   ((<a class="el" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">psa_key_derivation_step_t</a>)0x0201)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>A label for key derivation.</p>
-<p>This must be a direct input. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga384777dac55791d8f3a1af72c847b327"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KDF_STEP_SALT   ((<a class="el" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">psa_key_derivation_step_t</a>)0x0202)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>A salt for key derivation.</p>
-<p>This must be a direct input. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga90a1995a41e26ed5ca30d2d4641d1168"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KDF_STEP_SECRET   ((<a class="el" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">psa_key_derivation_step_t</a>)0x0101)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>A secret input for key derivation.</p>
-<p>This must be a key of type <a class="el" href="group__crypto__types.html#gae871b2357b8593f33bfd51abbf93ebb1">PSA_KEY_TYPE_DERIVE</a>. </p>
-
-</div>
-</div>
-<h2 class="groupheader">Function Documentation</h2>
-<a class="anchor" id="ga2c7fe304cacc141ffb91553548abc5d2"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_key_agreement </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> * </td>
- <td class="paramname"><em>generator</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">psa_key_derivation_step_t</a> </td>
- <td class="paramname"><em>step</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>private_key</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>peer_key</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>peer_key_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Perform a key agreement and use the shared secret as input to a key derivation.</p>
-<p>A key agreement algorithm takes two inputs: a private key <code>private_key</code> a public key <code>peer_key</code>. The result of this function is passed as input to a key derivation. The output of this key derivation can be extracted by reading from the resulting generator to produce keys and other cryptographic material.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">generator</td><td>The generator object to use. It must have been set up with <a class="el" href="group__derivation.html#ga1825696be813dfac2b8d3d02717e71c5">psa_key_derivation_setup()</a> with a key agreement and derivation algorithm <code>alg</code> (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#ga59753742cb06553bd22751bbef472b6f">PSA_ALG_IS_KEY_AGREEMENT</a>(<code>alg</code>) is true and <a class="el" href="group__crypto__types.html#gaa40ab362ce141ce541d69b2eb1f41438">PSA_ALG_IS_RAW_KEY_AGREEMENT</a>(<code>alg</code>) is false). The generator must be ready for an input of the type given by <code>step</code>. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">step</td><td>Which step the input data is for. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">private_key</td><td>Handle to the private key to use. </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">peer_key</td><td>Public key of the peer. The peer key must be in the same format that <a class="el" href="group__import__export.html#gac9f999cb4d098663d56095afe81a453a" title="Import a key in binary format. ">psa_import_key()</a> accepts for the public key type corresponding to the type of private_key. That is, this function performs the equivalent of <a class="el" href="group__import__export.html#gac9f999cb4d098663d56095afe81a453a" title="Import a key in binary format. ">psa_import_key</a>(<code>internal_public_key_handle</code>, <a class="el" href="group__crypto__types.html#gace08e46dd7cbf642d50d982a25d02bec">PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR</a>(<code>private_key_type</code>), <code>peer_key</code>, <code>peer_key_length</code>) where <code>private_key_type</code> is the type of <code>private_key</code>. For example, for EC keys, this means that peer_key is interpreted as a point on the curve that the private key is on. The standard formats for public keys are documented in the documentation of <a class="el" href="group__import__export.html#gad760d1f0d4e60972c78cbb4c8a528256" title="Export a public key or the public part of a key pair in binary format. ">psa_export_public_key()</a>. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">peer_key_length</td><td>Size of <code>peer_key</code> in bytes.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040">PSA_ERROR_EMPTY_SLOT</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4d1b8dd8526177a15a210b7afc1accb1">PSA_ERROR_NOT_PERMITTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td><code>private_key</code> is not compatible with <code>alg</code>, or <code>peer_key</code> is not valid for <code>alg</code> or not compatible with <code>private_key</code>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td><code>alg</code> is not supported or is not a key derivation algorithm. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="gaf1b12eff66a1a0020b5bdc8d0e910006"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_key_agreement_raw_shared_secret </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> </td>
- <td class="paramname"><em>alg</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>private_key</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>peer_key</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>peer_key_length</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">uint8_t * </td>
- <td class="paramname"><em>output</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>output_size</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t * </td>
- <td class="paramname"><em>output_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Perform a key agreement and use the shared secret as input to a key derivation.</p>
-<p>A key agreement algorithm takes two inputs: a private key <code>private_key</code> a public key <code>peer_key</code>.</p>
-<dl class="section warning"><dt>Warning</dt><dd>The raw result of a key agreement algorithm such as finite-field Diffie-Hellman or elliptic curve Diffie-Hellman has biases and should not be used directly as key material. It should instead be passed as input to a key derivation algorithm. To chain a key agreement with a key derivation, use <a class="el" href="group__derivation.html#ga2c7fe304cacc141ffb91553548abc5d2">psa_key_agreement()</a> and other functions from the key derivation and generator interface.</dd></dl>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir"></td><td class="paramname">alg</td><td>The key agreement algorithm to compute (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#gaa40ab362ce141ce541d69b2eb1f41438">PSA_ALG_IS_RAW_KEY_AGREEMENT</a>(<code>alg</code>) is true). </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">private_key</td><td>Handle to the private key to use. </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">peer_key</td><td>Public key of the peer. It must be in the same format that <a class="el" href="group__import__export.html#gac9f999cb4d098663d56095afe81a453a" title="Import a key in binary format. ">psa_import_key()</a> accepts. The standard formats for public keys are documented in the documentation of <a class="el" href="group__import__export.html#gad760d1f0d4e60972c78cbb4c8a528256" title="Export a public key or the public part of a key pair in binary format. ">psa_export_public_key()</a>. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">peer_key_length</td><td>Size of <code>peer_key</code> in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">output</td><td>Buffer where the decrypted message is to be written. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">output_size</td><td>Size of the <code>output</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">output_length</td><td>On success, the number of bytes that make up the returned output.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040">PSA_ERROR_EMPTY_SLOT</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4d1b8dd8526177a15a210b7afc1accb1">PSA_ERROR_NOT_PERMITTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td><code>alg</code> is not a key agreement algorithm </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td><code>private_key</code> is not compatible with <code>alg</code>, or <code>peer_key</code> is not valid for <code>alg</code> or not compatible with <code>private_key</code>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td><code>alg</code> is not a supported key agreement algorithm. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga1b30e888db65c71f5337900848e1b03f"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_key_derivation_input_bytes </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> * </td>
- <td class="paramname"><em>generator</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">psa_key_derivation_step_t</a> </td>
- <td class="paramname"><em>step</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>data</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>data_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Provide an input for key derivation or key agreement.</p>
-<p>Which inputs are required and in what order depends on the algorithm. Refer to the documentation of each key derivation or key agreement algorithm for information.</p>
-<p>This function passes direct inputs. Some inputs must be passed as keys using <a class="el" href="group__derivation.html#ga9e5f549aa1f6f3863a07008d3d98f91a">psa_key_derivation_input_key()</a> instead of this function. Refer to the documentation of individual step types for information.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">generator</td><td>The generator object to use. It must have been set up with <a class="el" href="group__derivation.html#ga1825696be813dfac2b8d3d02717e71c5">psa_key_derivation_setup()</a> and must not have produced any output yet. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">step</td><td>Which step the input data is for. </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">data</td><td>Input data to use. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">data_length</td><td>Size of the <code>data</code> buffer in bytes.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td><code>step</code> is not compatible with the generator's algorithm. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td><code>step</code> does not allow direct inputs. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The value of <code>step</code> is not valid given the state of <code>generator</code>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The library has not been previously initialized by <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a>. It is implementation-dependent whether a failure to initialize results in this error code. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga9e5f549aa1f6f3863a07008d3d98f91a"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_key_derivation_input_key </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> * </td>
- <td class="paramname"><em>generator</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b">psa_key_derivation_step_t</a> </td>
- <td class="paramname"><em>step</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Provide an input for key derivation in the form of a key.</p>
-<p>Which inputs are required and in what order depends on the algorithm. Refer to the documentation of each key derivation or key agreement algorithm for information.</p>
-<p>This function passes key inputs. Some inputs must be passed as keys of the appropriate type using this function, while others must be passed as direct inputs using <a class="el" href="group__derivation.html#ga1b30e888db65c71f5337900848e1b03f">psa_key_derivation_input_bytes()</a>. Refer to the documentation of individual step types for information.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">generator</td><td>The generator object to use. It must have been set up with <a class="el" href="group__derivation.html#ga1825696be813dfac2b8d3d02717e71c5">psa_key_derivation_setup()</a> and must not have produced any output yet. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">step</td><td>Which step the input data is for. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">handle</td><td>Handle to the key. It must have an appropriate type for <code>step</code> and must allow the usage <a class="el" href="group__policy.html#gaf19022acc5ef23cf12477f632b48a0b2">PSA_KEY_USAGE_DERIVE</a>.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040">PSA_ERROR_EMPTY_SLOT</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4d1b8dd8526177a15a210b7afc1accb1">PSA_ERROR_NOT_PERMITTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td><code>step</code> is not compatible with the generator's algorithm. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td><code>step</code> does not allow key inputs. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The value of <code>step</code> is not valid given the state of <code>generator</code>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The library has not been previously initialized by <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a>. It is implementation-dependent whether a failure to initialize results in this error code. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga1825696be813dfac2b8d3d02717e71c5"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_key_derivation_setup </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> * </td>
- <td class="paramname"><em>generator</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> </td>
- <td class="paramname"><em>alg</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Set up a key derivation operation.</p>
-<p>A key derivation algorithm takes some inputs and uses them to create a byte generator which can be used to produce keys and other cryptographic material.</p>
-<p>To use a generator for key derivation:</p><ul>
-<li>Start with an initialized object of type <a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a>.</li>
-<li>Call <a class="el" href="group__derivation.html#ga1825696be813dfac2b8d3d02717e71c5">psa_key_derivation_setup()</a> to select the algorithm.</li>
-<li>Provide the inputs for the key derivation by calling <a class="el" href="group__derivation.html#ga1b30e888db65c71f5337900848e1b03f">psa_key_derivation_input_bytes()</a> or <a class="el" href="group__derivation.html#ga9e5f549aa1f6f3863a07008d3d98f91a">psa_key_derivation_input_key()</a> as appropriate. Which inputs are needed, in what order, and whether they may be keys and if so of what type depends on the algorithm.</li>
-<li>Optionally set the generator's maximum capacity with <a class="el" href="group__generators.html#ga45676ec3c719622f95caaf926f44bb6e">psa_set_generator_capacity()</a>. You may do this before, in the middle of or after providing inputs. For some algorithms, this step is mandatory because the output depends on the maximum capacity.</li>
-<li>Generate output with <a class="el" href="group__generators.html#gab5712ad29b78c2b170e64cc5bcfc1bce">psa_generator_read()</a> or <a class="el" href="group__generators.html#ga7fcdf07cd37279ca167db484053da894">psa_generator_import_key()</a>. Successive calls to these functions use successive output bytes from the generator.</li>
-<li>Clean up the generator object with <a class="el" href="group__generators.html#ga563ca64537d90368899286b36d8cf7f3">psa_generator_abort()</a>.</li>
-</ul>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">generator</td><td>The generator object to set up. It must have been initialized but not set up yet. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">alg</td><td>The key derivation algorithm to compute (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#gaf8b90c648aa53dbd06c236695e300cd0">PSA_ALG_IS_KEY_DERIVATION</a>(<code>alg</code>) is true).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td><code>alg</code> is not a key derivation algorithm. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td><code>alg</code> is not supported or is not a key derivation algorithm. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/group__error.html b/docs/html/group__error.html
deleted file mode 100644
index 394e039..0000000
--- a/docs/html/group__error.html
+++ /dev/null
@@ -1,455 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: Error codes</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li class="current"><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
-</div><!-- top -->
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div class="header">
- <div class="summary">
-<a href="#define-members">Macros</a> |
-<a href="#typedef-members">Typedefs</a> </div>
- <div class="headertitle">
-<div class="title">Error codes</div> </div>
-</div><!--header-->
-<div class="contents">
-<table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="define-members"></a>
-Macros</h2></td></tr>
-<tr class="memitem:ga4cc859e2c66ca381c7418db3527a65e1"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)0)</td></tr>
-<tr class="separator:ga4cc859e2c66ca381c7418db3527a65e1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga24d5fdcdd759f846f79d9e581c63a83f"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga24d5fdcdd759f846f79d9e581c63a83f">PSA_ERROR_UNKNOWN_ERROR</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)1)</td></tr>
-<tr class="separator:ga24d5fdcdd759f846f79d9e581c63a83f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1dcc6d130633ed5db8942257581b55dd"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)2)</td></tr>
-<tr class="separator:ga1dcc6d130633ed5db8942257581b55dd"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4d1b8dd8526177a15a210b7afc1accb1"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga4d1b8dd8526177a15a210b7afc1accb1">PSA_ERROR_NOT_PERMITTED</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)3)</td></tr>
-<tr class="separator:ga4d1b8dd8526177a15a210b7afc1accb1"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga695025f4ec11249aee7ea3d0f65e01c8"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga695025f4ec11249aee7ea3d0f65e01c8">PSA_ERROR_BUFFER_TOO_SMALL</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)4)</td></tr>
-<tr class="separator:ga695025f4ec11249aee7ea3d0f65e01c8"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac2fee3a51249fbea45360aaa911f3e58"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#gac2fee3a51249fbea45360aaa911f3e58">PSA_ERROR_OCCUPIED_SLOT</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)5)</td></tr>
-<tr class="separator:gac2fee3a51249fbea45360aaa911f3e58"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaba00e3e6ceb2b12965a81e5ac02ae040"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040">PSA_ERROR_EMPTY_SLOT</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)6)</td></tr>
-<tr class="separator:gaba00e3e6ceb2b12965a81e5ac02ae040"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga933d40fa2a591004f2e93aa91e11db84"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)7)</td></tr>
-<tr class="separator:ga933d40fa2a591004f2e93aa91e11db84"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga798df25a505ebf931f7bec1f80f1f85f"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)8)</td></tr>
-<tr class="separator:ga798df25a505ebf931f7bec1f80f1f85f"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga91b2ad8a867517a2651f1b076c5216e5"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)9)</td></tr>
-<tr class="separator:ga91b2ad8a867517a2651f1b076c5216e5"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga897a45eb206a6f6b7be7ffbe36f0d766"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga897a45eb206a6f6b7be7ffbe36f0d766">PSA_ERROR_INSUFFICIENT_STORAGE</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)10)</td></tr>
-<tr class="separator:ga897a45eb206a6f6b7be7ffbe36f0d766"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga5cdb6948371d49e916106249020ea3f7"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)11)</td></tr>
-<tr class="separator:ga5cdb6948371d49e916106249020ea3f7"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gadd169a1af2707862b95fb9df91dfc37d"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#gadd169a1af2707862b95fb9df91dfc37d">PSA_ERROR_STORAGE_FAILURE</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)12)</td></tr>
-<tr class="separator:gadd169a1af2707862b95fb9df91dfc37d"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga08b10e70fa5ff0b05c631d9f8f6b2c6b"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)13)</td></tr>
-<tr class="separator:ga08b10e70fa5ff0b05c631d9f8f6b2c6b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga2c5dda1485cb54f2385cb9c1279a7004"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)14)</td></tr>
-<tr class="separator:ga2c5dda1485cb54f2385cb9c1279a7004"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4deb59fec02297ec5d8b42178323f675"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga4deb59fec02297ec5d8b42178323f675">PSA_ERROR_INSUFFICIENT_ENTROPY</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)15)</td></tr>
-<tr class="separator:ga4deb59fec02297ec5d8b42178323f675"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga35927f755d232c4766de600f2c49e9f2"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga35927f755d232c4766de600f2c49e9f2">PSA_ERROR_INVALID_SIGNATURE</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)16)</td></tr>
-<tr class="separator:ga35927f755d232c4766de600f2c49e9f2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gabe29594edbfb152cf153975b0597ac48"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#gabe29594edbfb152cf153975b0597ac48">PSA_ERROR_INVALID_PADDING</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)17)</td></tr>
-<tr class="separator:gabe29594edbfb152cf153975b0597ac48"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaf1fa61f72e9e5b4a848c991bea495767"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#gaf1fa61f72e9e5b4a848c991bea495767">PSA_ERROR_INSUFFICIENT_CAPACITY</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)18)</td></tr>
-<tr class="separator:gaf1fa61f72e9e5b4a848c991bea495767"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gadf22718935657c2c3168c228204085f9"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a>   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)19)</td></tr>
-<tr class="separator:gadf22718935657c2c3168c228204085f9"><td class="memSeparator" colspan="2"> </td></tr>
-</table><table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="typedef-members"></a>
-Typedefs</h2></td></tr>
-<tr class="memitem:ga05676e70ba5c6a7565aff3c36677c1f9"><td class="memItemLeft" align="right" valign="top">typedef int32_t </td><td class="memItemRight" valign="bottom"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a></td></tr>
-<tr class="memdesc:ga05676e70ba5c6a7565aff3c36677c1f9"><td class="mdescLeft"> </td><td class="mdescRight">Function return status. <a href="#ga05676e70ba5c6a7565aff3c36677c1f9">More...</a><br /></td></tr>
-<tr class="separator:ga05676e70ba5c6a7565aff3c36677c1f9"><td class="memSeparator" colspan="2"> </td></tr>
-</table>
-<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
-<h2 class="groupheader">Macro Definition Documentation</h2>
-<a class="anchor" id="ga933d40fa2a591004f2e93aa91e11db84"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ERROR_BAD_STATE   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)7)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The requested action cannot be performed in the current state.</p>
-<p>Multipart operations return this error when one of the functions is called out of sequence. Refer to the function descriptions for permitted sequencing of functions.</p>
-<p>Implementations shall not return this error code to indicate that a key slot is occupied when it needs to be free or vice versa, but shall return <a class="el" href="group__error.html#gac2fee3a51249fbea45360aaa911f3e58">PSA_ERROR_OCCUPIED_SLOT</a> or <a class="el" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040">PSA_ERROR_EMPTY_SLOT</a> as applicable. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga695025f4ec11249aee7ea3d0f65e01c8"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ERROR_BUFFER_TOO_SMALL   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)4)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>An output buffer is too small.</p>
-<p>Applications can call the <code>PSA_xxx_SIZE</code> macro listed in the function description to determine a sufficient buffer size.</p>
-<p>Implementations should preferably return this error code only in cases when performing the operation with a larger output buffer would succeed. However implementations may return this error if a function has invalid or unsupported parameters in addition to the parameters that determine the necessary output buffer size. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga5cdb6948371d49e916106249020ea3f7"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ERROR_COMMUNICATION_FAILURE   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)11)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>There was a communication failure inside the implementation.</p>
-<p>This can indicate a communication failure between the application and an external cryptoprocessor or between the cryptoprocessor and an external volatile or persistent memory. A communication failure may be transient or permanent depending on the cause.</p>
-<dl class="section warning"><dt>Warning</dt><dd>If a function returns this error, it is undetermined whether the requested action has completed or not. Implementations should return <a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a> on successful completion whenver possible, however functions may return <a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a> if the requested action was completed successfully in an external cryptoprocessor but there was a breakdown of communication before the cryptoprocessor could report the status to the application. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="gaba00e3e6ceb2b12965a81e5ac02ae040"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ERROR_EMPTY_SLOT   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)6)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>A slot is empty, but must be occupied to carry out the requested action.</p>
-<p>If a handle is invalid, it does not designate an empty slot. The error for an invalid handle is <a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a>. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga08b10e70fa5ff0b05c631d9f8f6b2c6b"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ERROR_HARDWARE_FAILURE   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)13)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>A hardware failure was detected.</p>
-<p>A hardware failure may be transient or permanent depending on the cause. </p>
-
-</div>
-</div>
-<a class="anchor" id="gaf1fa61f72e9e5b4a848c991bea495767"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ERROR_INSUFFICIENT_CAPACITY   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)18)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The generator has insufficient capacity left.</p>
-<p>Once a function returns this error, attempts to read from the generator will always return this error. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga4deb59fec02297ec5d8b42178323f675"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ERROR_INSUFFICIENT_ENTROPY   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)15)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>There is not enough entropy to generate random data needed for the requested action.</p>
-<p>This error indicates a failure of a hardware random generator. Application writers should note that this error can be returned not only by functions whose purpose is to generate random data, such as key, IV or nonce generation, but also by functions that execute an algorithm with a randomized result, as well as functions that use randomization of intermediate computations as a countermeasure to certain attacks.</p>
-<p>Implementations should avoid returning this error after <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a> has succeeded. Implementations should generate sufficient entropy during initialization and subsequently use a cryptographically secure pseudorandom generator (PRNG). However implementations may return this error at any time if a policy requires the PRNG to be reseeded during normal operation. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga91b2ad8a867517a2651f1b076c5216e5"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ERROR_INSUFFICIENT_MEMORY   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)9)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>There is not enough runtime memory.</p>
-<p>If the action is carried out across multiple security realms, this error can refer to available memory in any of the security realms. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga897a45eb206a6f6b7be7ffbe36f0d766"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ERROR_INSUFFICIENT_STORAGE   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)10)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>There is not enough persistent storage.</p>
-<p>Functions that modify the key storage return this error code if there is insufficient storage space on the host media. In addition, many functions that do not otherwise access storage may return this error code if the implementation requires a mandatory log entry for the requested action and the log storage space is full. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga798df25a505ebf931f7bec1f80f1f85f"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ERROR_INVALID_ARGUMENT   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)8)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The parameters passed to the function are invalid.</p>
-<p>Implementations may return this error any time a parameter or combination of parameters are recognized as invalid.</p>
-<p>Implementations shall not return this error code to indicate that a key slot is occupied when it needs to be free or vice versa, but shall return <a class="el" href="group__error.html#gac2fee3a51249fbea45360aaa911f3e58">PSA_ERROR_OCCUPIED_SLOT</a> or <a class="el" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040">PSA_ERROR_EMPTY_SLOT</a> as applicable.</p>
-<p>Implementation shall not return this error code to indicate that a key handle is invalid, but shall return <a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a> instead. </p>
-
-</div>
-</div>
-<a class="anchor" id="gadf22718935657c2c3168c228204085f9"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ERROR_INVALID_HANDLE   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)19)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The key handle is not valid. </p>
-
-</div>
-</div>
-<a class="anchor" id="gabe29594edbfb152cf153975b0597ac48"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ERROR_INVALID_PADDING   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)17)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The decrypted padding is incorrect.</p>
-<dl class="section warning"><dt>Warning</dt><dd>In some protocols, when decrypting data, it is essential that the behavior of the application does not depend on whether the padding is correct, down to precise timing. Applications should prefer protocols that use authenticated encryption rather than plain encryption. If the application must perform a decryption of unauthenticated data, the application writer should take care not to reveal whether the padding is invalid.</dd></dl>
-<p>Implementations should strive to make valid and invalid padding as close as possible to indistinguishable to an external observer. In particular, the timing of a decryption operation should not depend on the validity of the padding. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga35927f755d232c4766de600f2c49e9f2"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ERROR_INVALID_SIGNATURE   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)16)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The signature, MAC or hash is incorrect.</p>
-<p>Verification functions return this error if the verification calculations completed successfully, and the value to be verified was determined to be incorrect.</p>
-<p>If the value to verify has an invalid size, implementations may return either <a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a> or <a class="el" href="group__error.html#ga35927f755d232c4766de600f2c49e9f2">PSA_ERROR_INVALID_SIGNATURE</a>. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga4d1b8dd8526177a15a210b7afc1accb1"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ERROR_NOT_PERMITTED   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)3)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The requested action is denied by a policy.</p>
-<p>Implementations should return this error code when the parameters are recognized as valid and supported, and a policy explicitly denies the requested operation.</p>
-<p>If a subset of the parameters of a function call identify a forbidden operation, and another subset of the parameters are not valid or not supported, it is unspecified whether the function returns <a class="el" href="group__error.html#ga4d1b8dd8526177a15a210b7afc1accb1">PSA_ERROR_NOT_PERMITTED</a>, <a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a> or <a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a>. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga1dcc6d130633ed5db8942257581b55dd"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ERROR_NOT_SUPPORTED   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)2)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The requested operation or a parameter is not supported by this implementation.</p>
-<p>Implementations should return this error code when an enumeration parameter such as a key type, algorithm, etc. is not recognized. If a combination of parameters is recognized and identified as not valid, return <a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a> instead. </p>
-
-</div>
-</div>
-<a class="anchor" id="gac2fee3a51249fbea45360aaa911f3e58"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ERROR_OCCUPIED_SLOT   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)5)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>A slot is occupied, but must be empty to carry out the requested action.</p>
-<p>If a handle is invalid, it does not designate an occupied slot. The error for an invalid handle is <a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a>. </p>
-
-</div>
-</div>
-<a class="anchor" id="gadd169a1af2707862b95fb9df91dfc37d"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ERROR_STORAGE_FAILURE   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)12)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>There was a storage failure that may have led to data loss.</p>
-<p>This error indicates that some persistent storage is corrupted. It should not be used for a corruption of volatile memory (use <a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a>), for a communication error between the cryptoprocessor and its external storage (use <a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a>), or when the storage is in a valid state but is full (use <a class="el" href="group__error.html#ga897a45eb206a6f6b7be7ffbe36f0d766">PSA_ERROR_INSUFFICIENT_STORAGE</a>).</p>
-<p>Note that a storage failure does not indicate that any data that was previously read is invalid. However this previously read data may no longer be readable from storage.</p>
-<p>When a storage failure occurs, it is no longer possible to ensure the global integrity of the keystore. Depending on the global integrity guarantees offered by the implementation, access to other data may or may not fail even if the data is still readable but its integrity cannot be guaranteed.</p>
-<p>Implementations should only use this error code to report a permanent storage corruption. However application writers should keep in mind that transient errors while reading the storage may be reported using this error code. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga2c5dda1485cb54f2385cb9c1279a7004"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ERROR_TAMPERING_DETECTED   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)14)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>A tampering attempt was detected.</p>
-<p>If an application receives this error code, there is no guarantee that previously accessed or computed data was correct and remains confidential. Applications should not perform any security function and should enter a safe failure state.</p>
-<p>Implementations may return this error code if they detect an invalid state that cannot happen during normal operation and that indicates that the implementation's security guarantees no longer hold. Depending on the implementation architecture and on its security and safety goals, the implementation may forcibly terminate the application.</p>
-<p>This error code is intended as a last resort when a security breach is detected and it is unsure whether the keystore data is still protected. Implementations shall only return this error code to report an alarm from a tampering detector, to indicate that the confidentiality of stored data can no longer be guaranteed, or to indicate that the integrity of previously returned data is now considered compromised. Implementations shall not use this error code to indicate a hardware failure that merely makes it impossible to perform the requested operation (use <a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a>, <a class="el" href="group__error.html#gadd169a1af2707862b95fb9df91dfc37d">PSA_ERROR_STORAGE_FAILURE</a>, <a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a>, <a class="el" href="group__error.html#ga4deb59fec02297ec5d8b42178323f675">PSA_ERROR_INSUFFICIENT_ENTROPY</a> or other applicable error code instead).</p>
-<p>This error indicates an attack against the application. Implementations shall not return this error code as a consequence of the behavior of the application itself. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga24d5fdcdd759f846f79d9e581c63a83f"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_ERROR_UNKNOWN_ERROR   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)1)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>An error occurred that does not correspond to any defined failure cause.</p>
-<p>Implementations may use this error code if none of the other standard error codes are applicable. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga4cc859e2c66ca381c7418db3527a65e1"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_SUCCESS   ((<a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a>)0)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The action was completed successfully. </p>
-
-</div>
-</div>
-<h2 class="groupheader">Typedef Documentation</h2>
-<a class="anchor" id="ga05676e70ba5c6a7565aff3c36677c1f9"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">typedef int32_t <a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a></td>
- </tr>
- </table>
-</div><div class="memdoc">
-
-<p>Function return status. </p>
-<p>This is either <a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a> (which is zero), indicating success, or a nonzero value indicating that an error occurred. Errors are encoded as one of the <code>PSA_ERROR_xxx</code> values defined here. </p>
-
-</div>
-</div>
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/group__generators.html b/docs/html/group__generators.html
deleted file mode 100644
index e092ad9..0000000
--- a/docs/html/group__generators.html
+++ /dev/null
@@ -1,415 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: Generators</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li class="current"><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
-</div><!-- top -->
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div class="header">
- <div class="summary">
-<a href="#define-members">Macros</a> |
-<a href="#typedef-members">Typedefs</a> |
-<a href="#func-members">Functions</a> </div>
- <div class="headertitle">
-<div class="title">Generators</div> </div>
-</div><!--header-->
-<div class="contents">
-<table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="define-members"></a>
-Macros</h2></td></tr>
-<tr class="memitem:ga4788b471385fc667876fbd8a0d3fe062"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__generators.html#ga4788b471385fc667876fbd8a0d3fe062">PSA_CRYPTO_GENERATOR_INIT</a>   {0}</td></tr>
-<tr class="separator:ga4788b471385fc667876fbd8a0d3fe062"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac3222df9b9ecca4d33ae56a7b8fbb1c9"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__generators.html#gac3222df9b9ecca4d33ae56a7b8fbb1c9">PSA_GENERATOR_UNBRIDLED_CAPACITY</a>   ((size_t)(-1))</td></tr>
-<tr class="separator:gac3222df9b9ecca4d33ae56a7b8fbb1c9"><td class="memSeparator" colspan="2"> </td></tr>
-</table><table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="typedef-members"></a>
-Typedefs</h2></td></tr>
-<tr class="memitem:ga1f894c4fba202ef8e307d72caf489e3b"><td class="memItemLeft" align="right" valign="top">typedef struct psa_crypto_generator_s </td><td class="memItemRight" valign="bottom"><a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a></td></tr>
-<tr class="separator:ga1f894c4fba202ef8e307d72caf489e3b"><td class="memSeparator" colspan="2"> </td></tr>
-</table><table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="func-members"></a>
-Functions</h2></td></tr>
-<tr class="memitem:ga7453491e3b440193be2c5dccc2040fd2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__generators.html#ga7453491e3b440193be2c5dccc2040fd2">psa_get_generator_capacity</a> (const <a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> *generator, size_t *capacity)</td></tr>
-<tr class="separator:ga7453491e3b440193be2c5dccc2040fd2"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga45676ec3c719622f95caaf926f44bb6e"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__generators.html#ga45676ec3c719622f95caaf926f44bb6e">psa_set_generator_capacity</a> (<a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> *generator, size_t capacity)</td></tr>
-<tr class="separator:ga45676ec3c719622f95caaf926f44bb6e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab5712ad29b78c2b170e64cc5bcfc1bce"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__generators.html#gab5712ad29b78c2b170e64cc5bcfc1bce">psa_generator_read</a> (<a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> *generator, uint8_t *output, size_t output_length)</td></tr>
-<tr class="separator:gab5712ad29b78c2b170e64cc5bcfc1bce"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga7fcdf07cd37279ca167db484053da894"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__generators.html#ga7fcdf07cd37279ca167db484053da894">psa_generator_import_key</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a> type, size_t bits, <a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> *generator)</td></tr>
-<tr class="separator:ga7fcdf07cd37279ca167db484053da894"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga563ca64537d90368899286b36d8cf7f3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__generators.html#ga563ca64537d90368899286b36d8cf7f3">psa_generator_abort</a> (<a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> *generator)</td></tr>
-<tr class="separator:ga563ca64537d90368899286b36d8cf7f3"><td class="memSeparator" colspan="2"> </td></tr>
-</table>
-<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
-<h2 class="groupheader">Macro Definition Documentation</h2>
-<a class="anchor" id="ga4788b471385fc667876fbd8a0d3fe062"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_CRYPTO_GENERATOR_INIT   {0}</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>This macro returns a suitable initializer for a generator object of type <a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a>. </p>
-
-</div>
-</div>
-<a class="anchor" id="gac3222df9b9ecca4d33ae56a7b8fbb1c9"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_GENERATOR_UNBRIDLED_CAPACITY   ((size_t)(-1))</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Use the maximum possible capacity for a generator.</p>
-<p>Use this value as the capacity argument when setting up a generator to indicate that the generator should have the maximum possible capacity. The value of the maximum possible capacity depends on the generator algorithm. </p>
-
-</div>
-</div>
-<h2 class="groupheader">Typedef Documentation</h2>
-<a class="anchor" id="ga1f894c4fba202ef8e307d72caf489e3b"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">typedef struct psa_crypto_generator_s <a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The type of the state data structure for generators.</p>
-<p>Before calling any function on a generator, the application must initialize it by any of the following means:</p><ul>
-<li>Set the structure to all-bits-zero, for example: <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> psa_crypto_generator_t generator;</div><div class="line"><a name="l00002"></a><span class="lineno"> 2</span> memset(&generator, 0, sizeof(generator));</div></div><!-- fragment --></li>
-<li>Initialize the structure to logical zero values, for example: <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> psa_crypto_generator_t generator = {0};</div></div><!-- fragment --></li>
-<li>Initialize the structure to the initializer <a class="el" href="group__generators.html#ga4788b471385fc667876fbd8a0d3fe062">PSA_CRYPTO_GENERATOR_INIT</a>, for example: <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> psa_crypto_generator_t generator = PSA_CRYPTO_GENERATOR_INIT;</div></div><!-- fragment --></li>
-<li>Assign the result of the function psa_crypto_generator_init() to the structure, for example: <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> psa_crypto_generator_t generator;</div><div class="line"><a name="l00002"></a><span class="lineno"> 2</span> generator = psa_crypto_generator_init();</div></div><!-- fragment --></li>
-</ul>
-<p>This is an implementation-defined <code>struct</code>. Applications should not make any assumptions about the content of this structure except as directed by the documentation of a specific implementation. </p>
-
-</div>
-</div>
-<h2 class="groupheader">Function Documentation</h2>
-<a class="anchor" id="ga563ca64537d90368899286b36d8cf7f3"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_generator_abort </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> * </td>
- <td class="paramname"><em>generator</em></td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Abort a generator.</p>
-<p>Once a generator has been aborted, its capacity is zero. Aborting a generator frees all associated resources except for the <code>generator</code> structure itself.</p>
-<p>This function may be called at any time as long as the generator object has been initialized to <a class="el" href="group__generators.html#ga4788b471385fc667876fbd8a0d3fe062">PSA_CRYPTO_GENERATOR_INIT</a>, to psa_crypto_generator_init() or a zero value. In particular, it is valid to call <a class="el" href="group__generators.html#ga563ca64537d90368899286b36d8cf7f3">psa_generator_abort()</a> twice, or to call <a class="el" href="group__generators.html#ga563ca64537d90368899286b36d8cf7f3">psa_generator_abort()</a> on a generator that has not been set up.</p>
-<p>Once aborted, the generator object may be called.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">generator</td><td>The generator to abort.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga7fcdf07cd37279ca167db484053da894"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_generator_import_key </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a> </td>
- <td class="paramname"><em>type</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>bits</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> * </td>
- <td class="paramname"><em>generator</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Create a symmetric key from data read from a generator.</p>
-<p>This function reads a sequence of bytes from a generator and imports these bytes as a key. The data that is read is discarded from the generator. The generator's capacity is decreased by the number of bytes read.</p>
-<p>This function is equivalent to calling <a class="el" href="group__generators.html#gab5712ad29b78c2b170e64cc5bcfc1bce">psa_generator_read</a> and passing the resulting output to <a class="el" href="group__import__export.html#gac9f999cb4d098663d56095afe81a453a" title="Import a key in binary format. ">psa_import_key</a>, but if the implementation provides an isolation boundary then the key material is not exposed outside the isolation boundary.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir"></td><td class="paramname">handle</td><td>Handle to the slot where the key will be stored. It must have been obtained by calling <a class="el" href="group__key__management.html#ga40094b77b7a42b9c8e158395113f1a35">psa_allocate_key()</a> or <a class="el" href="group__key__management.html#ga4108f255d3eaa6d23a7a14b684af8d7c">psa_create_key()</a> and must not contain key material yet. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">type</td><td>Key type (a <code>PSA_KEY_TYPE_XXX</code> value). This must be a symmetric key type. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">bits</td><td>Key size in bits. </td></tr>
- <tr><td class="paramdir">[in,out]</td><td class="paramname">generator</td><td>The generator object to read from.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. If the key is persistent, the key material and the key's metadata have been saved to persistent storage. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gaf1fa61f72e9e5b4a848c991bea495767">PSA_ERROR_INSUFFICIENT_CAPACITY</a></td><td>There were fewer than <code>output_length</code> bytes in the generator. Note that in this case, no output is written to the output buffer. The generator's capacity is set to 0, thus subsequent calls to this function will not succeed, even with a smaller output buffer. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td>The key type or key size is not supported, either by the implementation in general or in this particular slot. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gac2fee3a51249fbea45360aaa911f3e58">PSA_ERROR_OCCUPIED_SLOT</a></td><td>There is already a key in the specified slot. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga897a45eb206a6f6b7be7ffbe36f0d766">PSA_ERROR_INSUFFICIENT_STORAGE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The library has not been previously initialized by <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a>. It is implementation-dependent whether a failure to initialize results in this error code. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="gab5712ad29b78c2b170e64cc5bcfc1bce"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_generator_read </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> * </td>
- <td class="paramname"><em>generator</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">uint8_t * </td>
- <td class="paramname"><em>output</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>output_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Read some data from a generator.</p>
-<p>This function reads and returns a sequence of bytes from a generator. The data that is read is discarded from the generator. The generator's capacity is decreased by the number of bytes read.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">generator</td><td>The generator object to read from. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">output</td><td>Buffer where the generator output will be written. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">output_length</td><td>Number of bytes to output.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gaf1fa61f72e9e5b4a848c991bea495767">PSA_ERROR_INSUFFICIENT_CAPACITY</a></td><td>There were fewer than <code>output_length</code> bytes in the generator. Note that in this case, no output is written to the output buffer. The generator's capacity is set to 0, thus subsequent calls to this function will not succeed, even with a smaller output buffer. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga7453491e3b440193be2c5dccc2040fd2"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_get_generator_capacity </td>
- <td>(</td>
- <td class="paramtype">const <a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> * </td>
- <td class="paramname"><em>generator</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t * </td>
- <td class="paramname"><em>capacity</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Retrieve the current capacity of a generator.</p>
-<p>The capacity of a generator is the maximum number of bytes that it can return. Reading <em>N</em> bytes from a generator reduces its capacity by <em>N</em>.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in]</td><td class="paramname">generator</td><td>The generator to query. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">capacity</td><td>On success, the capacity of the generator.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga45676ec3c719622f95caaf926f44bb6e"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_set_generator_capacity </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b">psa_crypto_generator_t</a> * </td>
- <td class="paramname"><em>generator</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>capacity</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Set the maximum capacity of a generator.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">generator</td><td>The generator object to modify. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">capacity</td><td>The new capacity of the generator. It must be less or equal to the generator's current capacity.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td><code>capacity</code> is larger than the generator's current capacity. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/group__hash.html b/docs/html/group__hash.html
deleted file mode 100644
index ef7f322..0000000
--- a/docs/html/group__hash.html
+++ /dev/null
@@ -1,619 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: Message digests</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li class="current"><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
-</div><!-- top -->
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div class="header">
- <div class="summary">
-<a href="#define-members">Macros</a> |
-<a href="#typedef-members">Typedefs</a> |
-<a href="#func-members">Functions</a> </div>
- <div class="headertitle">
-<div class="title">Message digests</div> </div>
-</div><!--header-->
-<div class="contents">
-<table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="define-members"></a>
-Macros</h2></td></tr>
-<tr class="memitem:ga6ab7fe8d3500bc2f21be840b4f4f8d1d"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__hash.html#ga6ab7fe8d3500bc2f21be840b4f4f8d1d">PSA_HASH_OPERATION_INIT</a>   {0}</td></tr>
-<tr class="separator:ga6ab7fe8d3500bc2f21be840b4f4f8d1d"><td class="memSeparator" colspan="2"> </td></tr>
-</table><table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="typedef-members"></a>
-Typedefs</h2></td></tr>
-<tr class="memitem:ga3c4205d2ce66c4095fc5c78c25273fab"><td class="memItemLeft" align="right" valign="top">typedef struct psa_hash_operation_s </td><td class="memItemRight" valign="bottom"><a class="el" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a></td></tr>
-<tr class="separator:ga3c4205d2ce66c4095fc5c78c25273fab"><td class="memSeparator" colspan="2"> </td></tr>
-</table><table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="func-members"></a>
-Functions</h2></td></tr>
-<tr class="memitem:gac69f7f19d96a56c28cf3799d11b12156"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__hash.html#gac69f7f19d96a56c28cf3799d11b12156">psa_hash_compute</a> (<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg, const uint8_t *input, size_t input_length, uint8_t *hash, size_t hash_size, size_t *hash_length)</td></tr>
-<tr class="separator:gac69f7f19d96a56c28cf3799d11b12156"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga0bb6dbd3c310648c3cf7d202413ff0bc"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__hash.html#ga0bb6dbd3c310648c3cf7d202413ff0bc">psa_hash_compare</a> (<a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg, const uint8_t *input, size_t input_length, const uint8_t *hash, const size_t hash_length)</td></tr>
-<tr class="separator:ga0bb6dbd3c310648c3cf7d202413ff0bc"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga8d72896cf70fc4d514c5c6b978912515"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__hash.html#ga8d72896cf70fc4d514c5c6b978912515">psa_hash_setup</a> (<a class="el" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> *operation, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg)</td></tr>
-<tr class="separator:ga8d72896cf70fc4d514c5c6b978912515"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga65b16ef97d7f650899b7db4b7d1112ff"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__hash.html#ga65b16ef97d7f650899b7db4b7d1112ff">psa_hash_update</a> (<a class="el" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> *operation, const uint8_t *input, size_t input_length)</td></tr>
-<tr class="separator:ga65b16ef97d7f650899b7db4b7d1112ff"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4795fd06a0067b0adcd92e9627b8c97e"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__hash.html#ga4795fd06a0067b0adcd92e9627b8c97e">psa_hash_finish</a> (<a class="el" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> *operation, uint8_t *hash, size_t hash_size, size_t *hash_length)</td></tr>
-<tr class="separator:ga4795fd06a0067b0adcd92e9627b8c97e"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga7be923c5700c9c70ef77ee9b76d1a5c0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__hash.html#ga7be923c5700c9c70ef77ee9b76d1a5c0">psa_hash_verify</a> (<a class="el" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> *operation, const uint8_t *hash, size_t hash_length)</td></tr>
-<tr class="separator:ga7be923c5700c9c70ef77ee9b76d1a5c0"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gab0b4d5f9912a615559497a467b532928"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__hash.html#gab0b4d5f9912a615559497a467b532928">psa_hash_abort</a> (<a class="el" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> *operation)</td></tr>
-<tr class="separator:gab0b4d5f9912a615559497a467b532928"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga39673348f3302b4646bd780034a5aeda"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__hash.html#ga39673348f3302b4646bd780034a5aeda">psa_hash_clone</a> (const <a class="el" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> *source_operation, <a class="el" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> *target_operation)</td></tr>
-<tr class="separator:ga39673348f3302b4646bd780034a5aeda"><td class="memSeparator" colspan="2"> </td></tr>
-</table>
-<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
-<h2 class="groupheader">Macro Definition Documentation</h2>
-<a class="anchor" id="ga6ab7fe8d3500bc2f21be840b4f4f8d1d"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_HASH_OPERATION_INIT   {0}</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>This macro returns a suitable initializer for a hash operation object of type <a class="el" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a>. </p>
-
-</div>
-</div>
-<h2 class="groupheader">Typedef Documentation</h2>
-<a class="anchor" id="ga3c4205d2ce66c4095fc5c78c25273fab"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">typedef struct psa_hash_operation_s <a class="el" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The type of the state data structure for multipart hash operations.</p>
-<p>Before calling any function on a hash operation object, the application must initialize it by any of the following means:</p><ul>
-<li>Set the structure to all-bits-zero, for example: <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> psa_hash_operation_t operation;</div><div class="line"><a name="l00002"></a><span class="lineno"> 2</span> memset(&operation, 0, sizeof(operation));</div></div><!-- fragment --></li>
-<li>Initialize the structure to logical zero values, for example: <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> psa_hash_operation_t operation = {0};</div></div><!-- fragment --></li>
-<li>Initialize the structure to the initializer <a class="el" href="group__hash.html#ga6ab7fe8d3500bc2f21be840b4f4f8d1d">PSA_HASH_OPERATION_INIT</a>, for example: <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> psa_hash_operation_t operation = PSA_HASH_OPERATION_INIT;</div></div><!-- fragment --></li>
-<li>Assign the result of the function psa_hash_operation_init() to the structure, for example: <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> psa_hash_operation_t operation;</div><div class="line"><a name="l00002"></a><span class="lineno"> 2</span> operation = psa_hash_operation_init();</div></div><!-- fragment --></li>
-</ul>
-<p>This is an implementation-defined <code>struct</code>. Applications should not make any assumptions about the content of this structure except as directed by the documentation of a specific implementation. </p>
-
-</div>
-</div>
-<h2 class="groupheader">Function Documentation</h2>
-<a class="anchor" id="gab0b4d5f9912a615559497a467b532928"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_hash_abort </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> * </td>
- <td class="paramname"><em>operation</em></td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Abort a hash operation.</p>
-<p>Aborting an operation frees all associated resources except for the <code>operation</code> structure itself. Once aborted, the operation object can be reused for another operation by calling <a class="el" href="group__hash.html#ga8d72896cf70fc4d514c5c6b978912515">psa_hash_setup()</a> again.</p>
-<p>You may call this function any time after the operation object has been initialized by any of the following methods:</p><ul>
-<li>A call to <a class="el" href="group__hash.html#ga8d72896cf70fc4d514c5c6b978912515">psa_hash_setup()</a>, whether it succeeds or not.</li>
-<li>Initializing the <code>struct</code> to all-bits-zero.</li>
-<li>Initializing the <code>struct</code> to logical zeros, e.g. <code>psa_hash_operation_t operation = {0}</code>.</li>
-</ul>
-<p>In particular, calling <a class="el" href="group__hash.html#gab0b4d5f9912a615559497a467b532928">psa_hash_abort()</a> after the operation has been terminated by a call to <a class="el" href="group__hash.html#gab0b4d5f9912a615559497a467b532928">psa_hash_abort()</a>, <a class="el" href="group__hash.html#ga4795fd06a0067b0adcd92e9627b8c97e">psa_hash_finish()</a> or <a class="el" href="group__hash.html#ga7be923c5700c9c70ef77ee9b76d1a5c0">psa_hash_verify()</a> is safe and has no effect.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">operation</td><td>Initialized hash operation.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td><code>operation</code> is not an active hash operation. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga39673348f3302b4646bd780034a5aeda"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_hash_clone </td>
- <td>(</td>
- <td class="paramtype">const <a class="el" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> * </td>
- <td class="paramname"><em>source_operation</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> * </td>
- <td class="paramname"><em>target_operation</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Clone a hash operation.</p>
-<p>This function copies the state of an ongoing hash operation to a new operation object. In other words, this function is equivalent to calling <a class="el" href="group__hash.html#ga8d72896cf70fc4d514c5c6b978912515">psa_hash_setup()</a> on <code>target_operation</code> with the same algorithm that <code>source_operation</code> was set up for, then <a class="el" href="group__hash.html#ga65b16ef97d7f650899b7db4b7d1112ff">psa_hash_update()</a> on <code>target_operation</code> with the same input that that was passed to <code>source_operation</code>. After this function returns, the two objects are independent, i.e. subsequent calls involving one of the objects do not affect the other object.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in]</td><td class="paramname">source_operation</td><td>The active hash operation to clone. </td></tr>
- <tr><td class="paramdir">[in,out]</td><td class="paramname">target_operation</td><td>The operation object to set up. It must be initialized but not active.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td><code>source_operation</code> is not an active hash operation. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td><code>target_operation</code> is active. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga0bb6dbd3c310648c3cf7d202413ff0bc"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_hash_compare </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> </td>
- <td class="paramname"><em>alg</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>input</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>input_length</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>hash</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const size_t </td>
- <td class="paramname"><em>hash_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Calculate the hash (digest) of a message and compare it with a reference value.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir"></td><td class="paramname">alg</td><td>The hash algorithm to compute (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#gac9280662bb482590b4b33d1dcd32930f">PSA_ALG_IS_HASH</a>(<code>alg</code>) is true). </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">input</td><td>Buffer containing the message to hash. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">input_length</td><td>Size of the <code>input</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">hash</td><td>Buffer containing the expected hash value. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">hash_length</td><td>Size of the <code>hash</code> buffer in bytes.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>The expected hash is identical to the actual hash of the input. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga35927f755d232c4766de600f2c49e9f2">PSA_ERROR_INVALID_SIGNATURE</a></td><td>The hash of the message was calculated successfully, but it differs from the expected hash. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td><code>alg</code> is not supported or is not a hash algorithm. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="gac69f7f19d96a56c28cf3799d11b12156"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_hash_compute </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> </td>
- <td class="paramname"><em>alg</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>input</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>input_length</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">uint8_t * </td>
- <td class="paramname"><em>hash</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>hash_size</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t * </td>
- <td class="paramname"><em>hash_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Calculate the hash (digest) of a message.</p>
-<dl class="section note"><dt>Note</dt><dd>To verify the hash of a message against an expected value, use <a class="el" href="group__hash.html#ga0bb6dbd3c310648c3cf7d202413ff0bc">psa_hash_compare()</a> instead.</dd></dl>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir"></td><td class="paramname">alg</td><td>The hash algorithm to compute (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#gac9280662bb482590b4b33d1dcd32930f">PSA_ALG_IS_HASH</a>(<code>alg</code>) is true). </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">input</td><td>Buffer containing the message to hash. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">input_length</td><td>Size of the <code>input</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">hash</td><td>Buffer where the hash is to be written. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">hash_size</td><td>Size of the <code>hash</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">hash_length</td><td>On success, the number of bytes that make up the hash value. This is always <a class="el" href="crypto__sizes_8h.html#aef340331ce3cba2b57e1fc5624bf1f99">PSA_HASH_SIZE</a>(<code>alg</code>).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td><code>alg</code> is not supported or is not a hash algorithm. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga4795fd06a0067b0adcd92e9627b8c97e"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_hash_finish </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> * </td>
- <td class="paramname"><em>operation</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">uint8_t * </td>
- <td class="paramname"><em>hash</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>hash_size</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t * </td>
- <td class="paramname"><em>hash_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Finish the calculation of the hash of a message.</p>
-<p>The application must call <a class="el" href="group__hash.html#ga8d72896cf70fc4d514c5c6b978912515">psa_hash_setup()</a> before calling this function. This function calculates the hash of the message formed by concatenating the inputs passed to preceding calls to <a class="el" href="group__hash.html#ga65b16ef97d7f650899b7db4b7d1112ff">psa_hash_update()</a>.</p>
-<p>When this function returns, the operation becomes inactive.</p>
-<dl class="section warning"><dt>Warning</dt><dd>Applications should not call this function if they expect a specific value for the hash. Call <a class="el" href="group__hash.html#ga7be923c5700c9c70ef77ee9b76d1a5c0">psa_hash_verify()</a> instead. Beware that comparing integrity or authenticity data such as hash values with a function such as <code>memcmp</code> is risky because the time taken by the comparison may leak information about the hashed data which could allow an attacker to guess a valid hash and thereby bypass security controls.</dd></dl>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">operation</td><td>Active hash operation. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">hash</td><td>Buffer where the hash is to be written. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">hash_size</td><td>Size of the <code>hash</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">hash_length</td><td>On success, the number of bytes that make up the hash value. This is always <a class="el" href="crypto__sizes_8h.html#aef340331ce3cba2b57e1fc5624bf1f99">PSA_HASH_SIZE</a>(<code>alg</code>) where <code>alg</code> is the hash algorithm that is calculated.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The operation state is not valid (not set up, or already completed). </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga695025f4ec11249aee7ea3d0f65e01c8">PSA_ERROR_BUFFER_TOO_SMALL</a></td><td>The size of the <code>hash</code> buffer is too small. You can determine a sufficient buffer size by calling <a class="el" href="crypto__sizes_8h.html#aef340331ce3cba2b57e1fc5624bf1f99">PSA_HASH_SIZE</a>(<code>alg</code>) where <code>alg</code> is the hash algorithm that is calculated. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga8d72896cf70fc4d514c5c6b978912515"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_hash_setup </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> * </td>
- <td class="paramname"><em>operation</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> </td>
- <td class="paramname"><em>alg</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Set up a multipart hash operation.</p>
-<p>The sequence of operations to calculate a hash (message digest) is as follows:</p><ol type="1">
-<li>Allocate an operation object which will be passed to all the functions listed here.</li>
-<li>Initialize the operation object with one of the methods described in the documentation for <a class="el" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a>, e.g. PSA_HASH_OPERATION_INIT.</li>
-<li>Call <a class="el" href="group__hash.html#ga8d72896cf70fc4d514c5c6b978912515">psa_hash_setup()</a> to specify the algorithm.</li>
-<li>Call <a class="el" href="group__hash.html#ga65b16ef97d7f650899b7db4b7d1112ff">psa_hash_update()</a> zero, one or more times, passing a fragment of the message each time. The hash that is calculated is the hash of the concatenation of these messages in order.</li>
-<li>To calculate the hash, call <a class="el" href="group__hash.html#ga4795fd06a0067b0adcd92e9627b8c97e">psa_hash_finish()</a>. To compare the hash with an expected value, call <a class="el" href="group__hash.html#ga7be923c5700c9c70ef77ee9b76d1a5c0">psa_hash_verify()</a>.</li>
-</ol>
-<p>The application may call <a class="el" href="group__hash.html#gab0b4d5f9912a615559497a467b532928">psa_hash_abort()</a> at any time after the operation has been initialized.</p>
-<p>After a successful call to <a class="el" href="group__hash.html#ga8d72896cf70fc4d514c5c6b978912515">psa_hash_setup()</a>, the application must eventually terminate the operation. The following events terminate an operation:</p><ul>
-<li>A failed call to <a class="el" href="group__hash.html#ga65b16ef97d7f650899b7db4b7d1112ff">psa_hash_update()</a>.</li>
-<li>A call to <a class="el" href="group__hash.html#ga4795fd06a0067b0adcd92e9627b8c97e">psa_hash_finish()</a>, <a class="el" href="group__hash.html#ga7be923c5700c9c70ef77ee9b76d1a5c0">psa_hash_verify()</a> or <a class="el" href="group__hash.html#gab0b4d5f9912a615559497a467b532928">psa_hash_abort()</a>.</li>
-</ul>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">operation</td><td>The operation object to set up. It must have been initialized as per the documentation for <a class="el" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> and not yet in use. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">alg</td><td>The hash algorithm to compute (<code>PSA_ALG_XXX</code> value such that <a class="el" href="group__crypto__types.html#gac9280662bb482590b4b33d1dcd32930f">PSA_ALG_IS_HASH</a>(<code>alg</code>) is true).</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td><code>alg</code> is not supported or is not a hash algorithm. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga65b16ef97d7f650899b7db4b7d1112ff"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_hash_update </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> * </td>
- <td class="paramname"><em>operation</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>input</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>input_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Add a message fragment to a multipart hash operation.</p>
-<p>The application must call <a class="el" href="group__hash.html#ga8d72896cf70fc4d514c5c6b978912515">psa_hash_setup()</a> before calling this function.</p>
-<p>If this function returns an error status, the operation becomes inactive.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">operation</td><td>Active hash operation. </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">input</td><td>Buffer containing the message fragment to hash. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">input_length</td><td>Size of the <code>input</code> buffer in bytes.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The operation state is not valid (not set up, or already completed). </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga7be923c5700c9c70ef77ee9b76d1a5c0"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_hash_verify </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab">psa_hash_operation_t</a> * </td>
- <td class="paramname"><em>operation</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>hash</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>hash_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Finish the calculation of the hash of a message and compare it with an expected value.</p>
-<p>The application must call <a class="el" href="group__hash.html#ga8d72896cf70fc4d514c5c6b978912515">psa_hash_setup()</a> before calling this function. This function calculates the hash of the message formed by concatenating the inputs passed to preceding calls to <a class="el" href="group__hash.html#ga65b16ef97d7f650899b7db4b7d1112ff">psa_hash_update()</a>. It then compares the calculated hash with the expected hash passed as a parameter to this function.</p>
-<p>When this function returns, the operation becomes inactive.</p>
-<dl class="section note"><dt>Note</dt><dd>Implementations shall make the best effort to ensure that the comparison between the actual hash and the expected hash is performed in constant time.</dd></dl>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">operation</td><td>Active hash operation. </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">hash</td><td>Buffer containing the expected hash value. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">hash_length</td><td>Size of the <code>hash</code> buffer in bytes.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>The expected hash is identical to the actual hash of the message. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga35927f755d232c4766de600f2c49e9f2">PSA_ERROR_INVALID_SIGNATURE</a></td><td>The hash of the message was calculated successfully, but it differs from the expected hash. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The operation state is not valid (not set up, or already completed). </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/group__import__export.html b/docs/html/group__import__export.html
deleted file mode 100644
index 7d05ce4..0000000
--- a/docs/html/group__import__export.html
+++ /dev/null
@@ -1,634 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: Key import and export</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li class="current"><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
-</div><!-- top -->
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div class="header">
- <div class="summary">
-<a href="#func-members">Functions</a> </div>
- <div class="headertitle">
-<div class="title">Key import and export</div> </div>
-</div><!--header-->
-<div class="contents">
-<table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="func-members"></a>
-Functions</h2></td></tr>
-<tr class="memitem:gac9f999cb4d098663d56095afe81a453a"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__import__export.html#gac9f999cb4d098663d56095afe81a453a">psa_import_key</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a> type, const uint8_t *data, size_t data_length)</td></tr>
-<tr class="memdesc:gac9f999cb4d098663d56095afe81a453a"><td class="mdescLeft"> </td><td class="mdescRight">Import a key in binary format. <a href="#gac9f999cb4d098663d56095afe81a453a">More...</a><br /></td></tr>
-<tr class="separator:gac9f999cb4d098663d56095afe81a453a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga165085fc1bc7a78b91792fdd94ae102c"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__import__export.html#ga165085fc1bc7a78b91792fdd94ae102c">psa_destroy_key</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle)</td></tr>
-<tr class="memdesc:ga165085fc1bc7a78b91792fdd94ae102c"><td class="mdescLeft"> </td><td class="mdescRight">Destroy a key. <a href="#ga165085fc1bc7a78b91792fdd94ae102c">More...</a><br /></td></tr>
-<tr class="separator:ga165085fc1bc7a78b91792fdd94ae102c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae8939902d6977ea8ad13eb7b4db9a042"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__import__export.html#gae8939902d6977ea8ad13eb7b4db9a042">psa_get_key_information</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a> *type, size_t *bits)</td></tr>
-<tr class="memdesc:gae8939902d6977ea8ad13eb7b4db9a042"><td class="mdescLeft"> </td><td class="mdescRight">Get basic metadata about a key. <a href="#gae8939902d6977ea8ad13eb7b4db9a042">More...</a><br /></td></tr>
-<tr class="separator:gae8939902d6977ea8ad13eb7b4db9a042"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga091da8d3d39137fd6ad59f2b10234300"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__import__export.html#ga091da8d3d39137fd6ad59f2b10234300">psa_set_key_domain_parameters</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a> type, const uint8_t *data, size_t data_length)</td></tr>
-<tr class="memdesc:ga091da8d3d39137fd6ad59f2b10234300"><td class="mdescLeft"> </td><td class="mdescRight">Set domain parameters for a key. <a href="#ga091da8d3d39137fd6ad59f2b10234300">More...</a><br /></td></tr>
-<tr class="separator:ga091da8d3d39137fd6ad59f2b10234300"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gae260b92e32ac5d63f7dfc6ffdf6536f7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__import__export.html#gae260b92e32ac5d63f7dfc6ffdf6536f7">psa_get_key_domain_parameters</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, uint8_t *data, size_t data_size, size_t *data_length)</td></tr>
-<tr class="memdesc:gae260b92e32ac5d63f7dfc6ffdf6536f7"><td class="mdescLeft"> </td><td class="mdescRight">Get domain parameters for a key. <a href="#gae260b92e32ac5d63f7dfc6ffdf6536f7">More...</a><br /></td></tr>
-<tr class="separator:gae260b92e32ac5d63f7dfc6ffdf6536f7"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga902b9a7a6cf34d6111668be777b05eaf"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__import__export.html#ga902b9a7a6cf34d6111668be777b05eaf">psa_export_key</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, uint8_t *data, size_t data_size, size_t *data_length)</td></tr>
-<tr class="memdesc:ga902b9a7a6cf34d6111668be777b05eaf"><td class="mdescLeft"> </td><td class="mdescRight">Export a key in binary format. <a href="#ga902b9a7a6cf34d6111668be777b05eaf">More...</a><br /></td></tr>
-<tr class="separator:ga902b9a7a6cf34d6111668be777b05eaf"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gad760d1f0d4e60972c78cbb4c8a528256"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__import__export.html#gad760d1f0d4e60972c78cbb4c8a528256">psa_export_public_key</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, uint8_t *data, size_t data_size, size_t *data_length)</td></tr>
-<tr class="memdesc:gad760d1f0d4e60972c78cbb4c8a528256"><td class="mdescLeft"> </td><td class="mdescRight">Export a public key or the public part of a key pair in binary format. <a href="#gad760d1f0d4e60972c78cbb4c8a528256">More...</a><br /></td></tr>
-<tr class="separator:gad760d1f0d4e60972c78cbb4c8a528256"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga5c1c24176cfb1517a8806235b3162a9d"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__import__export.html#ga5c1c24176cfb1517a8806235b3162a9d">psa_copy_key</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> source_handle, <a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> target_handle, const <a class="el" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a> *constraint)</td></tr>
-<tr class="separator:ga5c1c24176cfb1517a8806235b3162a9d"><td class="memSeparator" colspan="2"> </td></tr>
-</table>
-<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
-<h2 class="groupheader">Function Documentation</h2>
-<a class="anchor" id="ga5c1c24176cfb1517a8806235b3162a9d"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_copy_key </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>source_handle</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>target_handle</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const <a class="el" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a> * </td>
- <td class="paramname"><em>constraint</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Make a copy of a key.</p>
-<p>Copy key material from one location to another.</p>
-<p>This function is primarily useful to copy a key from one lifetime to another. The target key retains its lifetime and location.</p>
-<p>In an implementation where slots have different ownerships, this function may be used to share a key with a different party, subject to implementation-defined restrictions on key sharing. In this case <code>constraint</code> would typically prevent the recipient from exporting the key.</p>
-<p>The resulting key may only be used in a way that conforms to all three of: the policy of the source key, the policy previously set on the target, and the <code>constraint</code> parameter passed when calling this function.</p><ul>
-<li>The usage flags on the resulting key are the bitwise-and of the usage flags on the source policy, the previously-set target policy and the policy constraint.</li>
-<li>If all three policies allow the same algorithm or wildcard-based algorithm policy, the resulting key has the same algorithm policy.</li>
-<li>If one of the policies allows an algorithm and all the other policies either allow the same algorithm or a wildcard-based algorithm policy that includes this algorithm, the resulting key allows the same algorithm.</li>
-</ul>
-<p>The effect of this function on implementation-defined metadata is implementation-defined.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir"></td><td class="paramname">source_handle</td><td>The key to copy. It must be a handle to an occupied slot. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">target_handle</td><td>A handle to the target slot. It must not contain key material yet. </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">constraint</td><td>An optional policy constraint. If this parameter is non-null then the resulting key will conform to this policy in addition to the source policy and the policy already present on the target slot. If this parameter is null then the function behaves in the same way as if it was the target policy, i.e. only the source and target policies apply.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gac2fee3a51249fbea45360aaa911f3e58">PSA_ERROR_OCCUPIED_SLOT</a></td><td><code>target</code> already contains key material. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040">PSA_ERROR_EMPTY_SLOT</a></td><td><code>source</code> does not contain key material. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td>The policy constraints on the source, on the target and <code>constraints</code> are incompatible. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4d1b8dd8526177a15a210b7afc1accb1">PSA_ERROR_NOT_PERMITTED</a></td><td>The source key is not exportable and its lifetime does not allow copying it to the target's lifetime. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga897a45eb206a6f6b7be7ffbe36f0d766">PSA_ERROR_INSUFFICIENT_STORAGE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga165085fc1bc7a78b91792fdd94ae102c"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_destroy_key </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em></td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-
-<p>Destroy a key. </p>
-<p>This function destroys the content of the key slot from both volatile memory and, if applicable, non-volatile storage. Implementations shall make a best effort to ensure that any previous content of the slot is unrecoverable.</p>
-<p>This function also erases any metadata such as policies and frees all resources associated with the key.</p>
-<p>If the key is currently in use in a multipart operation, the multipart operation is aborted.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">handle</td><td>Handle to the key slot to erase.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>The slot's content, if any, has been erased. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4d1b8dd8526177a15a210b7afc1accb1">PSA_ERROR_NOT_PERMITTED</a></td><td>The slot holds content and cannot be erased because it is read-only, either due to a policy or due to physical restrictions. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td>There was an failure in communication with the cryptoprocessor. The key material may still be present in the cryptoprocessor. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadd169a1af2707862b95fb9df91dfc37d">PSA_ERROR_STORAGE_FAILURE</a></td><td>The storage is corrupted. Implementations shall make a best effort to erase key material even in this stage, however applications should be aware that it may be impossible to guarantee that the key material is not recoverable in such cases. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td>An unexpected condition which is not a storage corruption or a communication failure occurred. The cryptoprocessor may have been compromised. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The library has not been previously initialized by <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a>. It is implementation-dependent whether a failure to initialize results in this error code. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga902b9a7a6cf34d6111668be777b05eaf"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_export_key </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">uint8_t * </td>
- <td class="paramname"><em>data</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>data_size</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t * </td>
- <td class="paramname"><em>data_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-
-<p>Export a key in binary format. </p>
-<p>The output of this function can be passed to <a class="el" href="group__import__export.html#gac9f999cb4d098663d56095afe81a453a" title="Import a key in binary format. ">psa_import_key()</a> to create an equivalent object.</p>
-<p>If the implementation of <a class="el" href="group__import__export.html#gac9f999cb4d098663d56095afe81a453a" title="Import a key in binary format. ">psa_import_key()</a> supports other formats beyond the format specified here, the output from <a class="el" href="group__import__export.html#ga902b9a7a6cf34d6111668be777b05eaf" title="Export a key in binary format. ">psa_export_key()</a> must use the representation specified here, not the original representation.</p>
-<p>For standard key types, the output format is as follows:</p>
-<ul>
-<li>For symmetric keys (including MAC keys), the format is the raw bytes of the key.</li>
-<li>For DES, the key data consists of 8 bytes. The parity bits must be correct.</li>
-<li>For Triple-DES, the format is the concatenation of the two or three DES keys.</li>
-<li>For RSA key pairs (<a class="el" href="group__crypto__types.html#ga581f50687f5d650456925278948f2799">PSA_KEY_TYPE_RSA_KEYPAIR</a>), the format is the non-encrypted DER encoding of the representation defined by PKCS#1 (RFC 8017) as <code>RSAPrivateKey</code>, version 0. <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> RSAPrivateKey ::= SEQUENCE {</div><div class="line"><a name="l00002"></a><span class="lineno"> 2</span>  version INTEGER, -- must be 0</div><div class="line"><a name="l00003"></a><span class="lineno"> 3</span>  modulus INTEGER, -- n</div><div class="line"><a name="l00004"></a><span class="lineno"> 4</span>  publicExponent INTEGER, -- e</div><div class="line"><a name="l00005"></a><span class="lineno"> 5</span>  privateExponent INTEGER, -- d</div><div class="line"><a name="l00006"></a><span class="lineno"> 6</span>  prime1 INTEGER, -- p</div><div class="line"><a name="l00007"></a><span class="lineno"> 7</span>  prime2 INTEGER, -- q</div><div class="line"><a name="l00008"></a><span class="lineno"> 8</span>  exponent1 INTEGER, -- d mod (p-1)</div><div class="line"><a name="l00009"></a><span class="lineno"> 9</span>  exponent2 INTEGER, -- d mod (q-1)</div><div class="line"><a name="l00010"></a><span class="lineno"> 10</span>  coefficient INTEGER, -- (inverse of q) mod p</div><div class="line"><a name="l00011"></a><span class="lineno"> 11</span> }</div></div><!-- fragment --></li>
-<li>For DSA private keys (<a class="el" href="group__crypto__types.html#ga011010ee28c20388f3d89fb27088ed62">PSA_KEY_TYPE_DSA_KEYPAIR</a>), the format is the representation of the private key <code>x</code> as a big-endian byte string. The length of the byte string is the private key size in bytes (leading zeroes are not stripped).</li>
-<li>For elliptic curve key pairs (key types for which <a class="el" href="group__crypto__types.html#ga7bf101b671e8cf26f4cb08fcb679db4b">PSA_KEY_TYPE_IS_ECC_KEYPAIR</a> is true), the format is a representation of the private value as a <code>ceiling(m/8)</code>-byte string where <code>m</code> is the bit size associated with the curve, i.e. the bit size of the order of the curve's coordinate field. This byte string is in little-endian order for Montgomery curves (curve types <code>PSA_ECC_CURVE_CURVEXXX</code>), and in big-endian order for Weierstrass curves (curve types <code>PSA_ECC_CURVE_SECTXXX</code>, <code>PSA_ECC_CURVE_SECPXXX</code> and <code>PSA_ECC_CURVE_BRAINPOOL_PXXX</code>). This is the content of the <code>privateKey</code> field of the <code>ECPrivateKey</code> format defined by RFC 5915.</li>
-<li>For Diffie-Hellman key exchange key pairs (<a class="el" href="group__crypto__types.html#ga39b63c6b97a62a316c0660bf72b2fdd5">PSA_KEY_TYPE_DH_KEYPAIR</a>), the format is the representation of the private key <code>x</code> as a big-endian byte string. The length of the byte string is the private key size in bytes (leading zeroes are not stripped).</li>
-<li>For public keys (key types for which <a class="el" href="group__crypto__types.html#gac674a0f059bc0cb72b47f0c517b4f45b">PSA_KEY_TYPE_IS_PUBLIC_KEY</a> is true), the format is the same as for <a class="el" href="group__import__export.html#gad760d1f0d4e60972c78cbb4c8a528256" title="Export a public key or the public part of a key pair in binary format. ">psa_export_public_key()</a>.</li>
-</ul>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir"></td><td class="paramname">handle</td><td>Handle to the key to export. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">data</td><td>Buffer where the key data is to be written. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">data_size</td><td>Size of the <code>data</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">data_length</td><td>On success, the number of bytes that make up the key data.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040">PSA_ERROR_EMPTY_SLOT</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4d1b8dd8526177a15a210b7afc1accb1">PSA_ERROR_NOT_PERMITTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga695025f4ec11249aee7ea3d0f65e01c8">PSA_ERROR_BUFFER_TOO_SMALL</a></td><td>The size of the <code>data</code> buffer is too small. You can determine a sufficient buffer size by calling <a class="el" href="crypto__sizes_8h.html#a0aae885cc8ff92e00fb5248420b939c3">PSA_KEY_EXPORT_MAX_SIZE</a>(<code>type</code>, <code>bits</code>) where <code>type</code> is the key type and <code>bits</code> is the key size in bits. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The library has not been previously initialized by <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a>. It is implementation-dependent whether a failure to initialize results in this error code. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="gad760d1f0d4e60972c78cbb4c8a528256"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_export_public_key </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">uint8_t * </td>
- <td class="paramname"><em>data</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>data_size</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t * </td>
- <td class="paramname"><em>data_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-
-<p>Export a public key or the public part of a key pair in binary format. </p>
-<p>The output of this function can be passed to <a class="el" href="group__import__export.html#gac9f999cb4d098663d56095afe81a453a" title="Import a key in binary format. ">psa_import_key()</a> to create an object that is equivalent to the public key.</p>
-<p>This specification supports a single format for each key type. Implementations may support other formats as long as the standard format is supported. Implementations that support other formats should ensure that the formats are clearly unambiguous so as to minimize the risk that an invalid input is accidentally interpreted according to a different format.</p>
-<p>For standard key types, the output format is as follows:</p><ul>
-<li>For RSA public keys (<a class="el" href="group__crypto__types.html#ga9ba0878f56c8bcd1995ac017a74f513b">PSA_KEY_TYPE_RSA_PUBLIC_KEY</a>), the DER encoding of the representation defined by RFC 3279 §2.3.1 as <code>RSAPublicKey</code>. <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> RSAPublicKey ::= SEQUENCE {</div><div class="line"><a name="l00002"></a><span class="lineno"> 2</span>  modulus INTEGER, -- n</div><div class="line"><a name="l00003"></a><span class="lineno"> 3</span>  publicExponent INTEGER } -- e</div></div><!-- fragment --></li>
-<li>For elliptic curve public keys (key types for which <a class="el" href="group__crypto__types.html#ga5af146a173b0c84d7e737e2fb6a3c0a7">PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY</a> is true), the format is the uncompressed representation defined by SEC1 §2.3.3 as the content of an ECPoint. Let <code>m</code> be the bit size associated with the curve, i.e. the bit size of <code>q</code> for a curve over <code>F_q</code>. The representation consists of:<ul>
-<li>The byte 0x04;</li>
-<li><code>x_P</code> as a <code>ceiling(m/8)</code>-byte string, big-endian;</li>
-<li><code>y_P</code> as a <code>ceiling(m/8)</code>-byte string, big-endian.</li>
-</ul>
-</li>
-<li>For DSA public keys (<a class="el" href="group__crypto__types.html#ga5e7439c2905136366c3a876e62e5ddfc">PSA_KEY_TYPE_DSA_PUBLIC_KEY</a>), the format is the representation of the public key <code>y = g^x mod p</code> as a big-endian byte string. The length of the byte string is the length of the base prime <code>p</code> in bytes.</li>
-<li>For Diffie-Hellman key exchange public keys (<a class="el" href="group__crypto__types.html#ga325a340d7c72d99d3a678eb210bf6e0a">PSA_KEY_TYPE_DH_PUBLIC_KEY</a>), the format is the representation of the public key <code>y = g^x mod p</code> as a big-endian byte string. The length of the byte string is the length of the base prime <code>p</code> in bytes.</li>
-</ul>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir"></td><td class="paramname">handle</td><td>Handle to the key to export. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">data</td><td>Buffer where the key data is to be written. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">data_size</td><td>Size of the <code>data</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">data_length</td><td>On success, the number of bytes that make up the key data.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040">PSA_ERROR_EMPTY_SLOT</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td>The key is neither a public key nor a key pair. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga695025f4ec11249aee7ea3d0f65e01c8">PSA_ERROR_BUFFER_TOO_SMALL</a></td><td>The size of the <code>data</code> buffer is too small. You can determine a sufficient buffer size by calling <a class="el" href="crypto__sizes_8h.html#a0aae885cc8ff92e00fb5248420b939c3">PSA_KEY_EXPORT_MAX_SIZE</a>(<a class="el" href="group__crypto__types.html#gace08e46dd7cbf642d50d982a25d02bec">PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR</a>(<code>type</code>), <code>bits</code>) where <code>type</code> is the key type and <code>bits</code> is the key size in bits. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The library has not been previously initialized by <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a>. It is implementation-dependent whether a failure to initialize results in this error code. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="gae260b92e32ac5d63f7dfc6ffdf6536f7"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_get_key_domain_parameters </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">uint8_t * </td>
- <td class="paramname"><em>data</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>data_size</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t * </td>
- <td class="paramname"><em>data_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-
-<p>Get domain parameters for a key. </p>
-<p>Get the domain parameters for a key with this function, if any. The format of the domain parameters written to <code>data</code> is specified in the documentation for <a class="el" href="group__import__export.html#ga091da8d3d39137fd6ad59f2b10234300" title="Set domain parameters for a key. ">psa_set_key_domain_parameters()</a>.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir"></td><td class="paramname">handle</td><td>Handle to the key to get domain parameters from. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">data</td><td>On success, the key domain parameters. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">data_size</td><td>Size of the <code>data</code> buffer in bytes. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">data_length</td><td>On success, the number of bytes that make up the key domain parameters data.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040">PSA_ERROR_EMPTY_SLOT</a></td><td>There is no key in the specified slot. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The library has not been previously initialized by <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a>. It is implementation-dependent whether a failure to initialize results in this error code. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="gae8939902d6977ea8ad13eb7b4db9a042"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_get_key_information </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a> * </td>
- <td class="paramname"><em>type</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t * </td>
- <td class="paramname"><em>bits</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-
-<p>Get basic metadata about a key. </p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir"></td><td class="paramname">handle</td><td>Handle to the key slot to query. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">type</td><td>On success, the key type (a <code>PSA_KEY_TYPE_XXX</code> value). This may be a null pointer, in which case the key type is not written. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">bits</td><td>On success, the key size in bits. This may be a null pointer, in which case the key size is not written.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040">PSA_ERROR_EMPTY_SLOT</a></td><td>The handle is to a key slot which does not contain key material yet. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The library has not been previously initialized by <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a>. It is implementation-dependent whether a failure to initialize results in this error code. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="gac9f999cb4d098663d56095afe81a453a"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_import_key </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a> </td>
- <td class="paramname"><em>type</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>data</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>data_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-
-<p>Import a key in binary format. </p>
-<p>This function supports any output from <a class="el" href="group__import__export.html#ga902b9a7a6cf34d6111668be777b05eaf" title="Export a key in binary format. ">psa_export_key()</a>. Refer to the documentation of <a class="el" href="group__import__export.html#gad760d1f0d4e60972c78cbb4c8a528256" title="Export a public key or the public part of a key pair in binary format. ">psa_export_public_key()</a> for the format of public keys and to the documentation of <a class="el" href="group__import__export.html#ga902b9a7a6cf34d6111668be777b05eaf" title="Export a key in binary format. ">psa_export_key()</a> for the format for other key types.</p>
-<p>This specification supports a single format for each key type. Implementations may support other formats as long as the standard format is supported. Implementations that support other formats should ensure that the formats are clearly unambiguous so as to minimize the risk that an invalid input is accidentally interpreted according to a different format.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir"></td><td class="paramname">handle</td><td>Handle to the slot where the key will be stored. It must have been obtained by calling <a class="el" href="group__key__management.html#ga40094b77b7a42b9c8e158395113f1a35">psa_allocate_key()</a> or <a class="el" href="group__key__management.html#ga4108f255d3eaa6d23a7a14b684af8d7c">psa_create_key()</a> and must not contain key material yet. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">type</td><td>Key type (a <code>PSA_KEY_TYPE_XXX</code> value). On a successful import, the key slot will contain a key of this type. </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">data</td><td>Buffer containing the key data. The content of this buffer is interpreted according to <code>type</code>. It must contain the format described in the documentation of <a class="el" href="group__import__export.html#ga902b9a7a6cf34d6111668be777b05eaf" title="Export a key in binary format. ">psa_export_key()</a> or <a class="el" href="group__import__export.html#gad760d1f0d4e60972c78cbb4c8a528256" title="Export a public key or the public part of a key pair in binary format. ">psa_export_public_key()</a> for the chosen type. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">data_length</td><td>Size of the <code>data</code> buffer in bytes.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. If the key is persistent, the key material and the key's metadata have been saved to persistent storage. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td>The key type or key size is not supported, either by the implementation in general or in this particular slot. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td>The key slot is invalid, or the key data is not correctly formatted. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gac2fee3a51249fbea45360aaa911f3e58">PSA_ERROR_OCCUPIED_SLOT</a></td><td>There is already a key in the specified slot. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga897a45eb206a6f6b7be7ffbe36f0d766">PSA_ERROR_INSUFFICIENT_STORAGE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadd169a1af2707862b95fb9df91dfc37d">PSA_ERROR_STORAGE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The library has not been previously initialized by <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a>. It is implementation-dependent whether a failure to initialize results in this error code. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga091da8d3d39137fd6ad59f2b10234300"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_set_key_domain_parameters </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a> </td>
- <td class="paramname"><em>type</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const uint8_t * </td>
- <td class="paramname"><em>data</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>data_length</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-
-<p>Set domain parameters for a key. </p>
-<p>Some key types require additional domain parameters to be set before import or generation of the key. The domain parameters can be set with this function or, for key generation, through the <code>extra</code> parameter of <a class="el" href="group__random.html#ga72921520494b4f007a3afb904cd9ecdd" title="Generate a key or key pair. ">psa_generate_key()</a>.</p>
-<p>The format for the required domain parameters varies by the key type.</p><ul>
-<li>For DSA public keys (<a class="el" href="group__crypto__types.html#ga5e7439c2905136366c3a876e62e5ddfc">PSA_KEY_TYPE_DSA_PUBLIC_KEY</a>), the <code>Dss-Parms</code> format as defined by RFC 3279 §2.3.2. <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> Dss-Parms ::= SEQUENCE {</div><div class="line"><a name="l00002"></a><span class="lineno"> 2</span>  p INTEGER,</div><div class="line"><a name="l00003"></a><span class="lineno"> 3</span>  q INTEGER,</div><div class="line"><a name="l00004"></a><span class="lineno"> 4</span>  g INTEGER</div><div class="line"><a name="l00005"></a><span class="lineno"> 5</span> }</div></div><!-- fragment --></li>
-<li>For Diffie-Hellman key exchange keys (<a class="el" href="group__crypto__types.html#ga325a340d7c72d99d3a678eb210bf6e0a">PSA_KEY_TYPE_DH_PUBLIC_KEY</a>), the <code>DomainParameters</code> format as defined by RFC 3279 §2.3.3. <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> DomainParameters ::= SEQUENCE {</div><div class="line"><a name="l00002"></a><span class="lineno"> 2</span>  p INTEGER, -- odd prime, p=jq +1</div><div class="line"><a name="l00003"></a><span class="lineno"> 3</span>  g INTEGER, -- generator, g</div><div class="line"><a name="l00004"></a><span class="lineno"> 4</span>  q INTEGER, -- factor of p-1</div><div class="line"><a name="l00005"></a><span class="lineno"> 5</span>  j INTEGER OPTIONAL, -- subgroup factor</div><div class="line"><a name="l00006"></a><span class="lineno"> 6</span>  validationParms ValidationParms OPTIONAL</div><div class="line"><a name="l00007"></a><span class="lineno"> 7</span> }</div><div class="line"><a name="l00008"></a><span class="lineno"> 8</span> ValidationParms ::= SEQUENCE {</div><div class="line"><a name="l00009"></a><span class="lineno"> 9</span>  seed BIT STRING,</div><div class="line"><a name="l00010"></a><span class="lineno"> 10</span>  pgenCounter INTEGER</div><div class="line"><a name="l00011"></a><span class="lineno"> 11</span> }</div></div><!-- fragment --></li>
-</ul>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir"></td><td class="paramname">handle</td><td>Handle to the slot where the key will be stored. This must be a valid slot for a key of the chosen type: it must have been obtained by calling <a class="el" href="group__key__management.html#ga40094b77b7a42b9c8e158395113f1a35">psa_allocate_key()</a> or <a class="el" href="group__key__management.html#ga4108f255d3eaa6d23a7a14b684af8d7c">psa_create_key()</a> with the correct <code>type</code> and with a maximum size that is compatible with <code>data</code>. It must not contain key material yet. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">type</td><td>Key type (a <code>PSA_KEY_TYPE_XXX</code> value). When subsequently creating key material into <code>handle</code>, the type must be compatible. </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">data</td><td>Buffer containing the key domain parameters. The content of this buffer is interpreted according to <code>type</code>. of <a class="el" href="group__import__export.html#ga902b9a7a6cf34d6111668be777b05eaf" title="Export a key in binary format. ">psa_export_key()</a> or <a class="el" href="group__import__export.html#gad760d1f0d4e60972c78cbb4c8a528256" title="Export a public key or the public part of a key pair in binary format. ">psa_export_public_key()</a> for the chosen type. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">data_length</td><td>Size of the <code>data</code> buffer in bytes.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gac2fee3a51249fbea45360aaa911f3e58">PSA_ERROR_OCCUPIED_SLOT</a></td><td>There is already a key in the specified slot. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The library has not been previously initialized by <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a>. It is implementation-dependent whether a failure to initialize results in this error code. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/group__initialization.html b/docs/html/group__initialization.html
deleted file mode 100644
index 613eb46..0000000
--- a/docs/html/group__initialization.html
+++ /dev/null
@@ -1,134 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: Library initialization</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li class="current"><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
-</div><!-- top -->
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div class="header">
- <div class="summary">
-<a href="#func-members">Functions</a> </div>
- <div class="headertitle">
-<div class="title">Library initialization</div> </div>
-</div><!--header-->
-<div class="contents">
-<table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="func-members"></a>
-Functions</h2></td></tr>
-<tr class="memitem:ga2de150803fc2f7dc6101d5af7e921dd9"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9">psa_crypto_init</a> (void)</td></tr>
-<tr class="memdesc:ga2de150803fc2f7dc6101d5af7e921dd9"><td class="mdescLeft"> </td><td class="mdescRight">Library initialization. <a href="#ga2de150803fc2f7dc6101d5af7e921dd9">More...</a><br /></td></tr>
-<tr class="separator:ga2de150803fc2f7dc6101d5af7e921dd9"><td class="memSeparator" colspan="2"> </td></tr>
-</table>
-<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
-<h2 class="groupheader">Function Documentation</h2>
-<a class="anchor" id="ga2de150803fc2f7dc6101d5af7e921dd9"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_crypto_init </td>
- <td>(</td>
- <td class="paramtype">void </td>
- <td class="paramname"></td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-
-<p>Library initialization. </p>
-<p>Applications must call this function before calling any other function in this module.</p>
-<p>Applications may call this function more than once. Once a call succeeds, subsequent calls are guaranteed to succeed.</p>
-<p>If the application calls other functions before calling <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a>, the behavior is undefined. Implementations are encouraged to either perform the operation as if the library had been initialized or to return <a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a> or some other applicable error. In particular, implementations should not return a success status if the lack of initialization may have security implications, for example due to improper seeding of the random number generator.</p>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4deb59fec02297ec5d8b42178323f675">PSA_ERROR_INSUFFICIENT_ENTROPY</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/group__key__lifetimes.html b/docs/html/group__key__lifetimes.html
deleted file mode 100644
index 9ede76c..0000000
--- a/docs/html/group__key__lifetimes.html
+++ /dev/null
@@ -1,166 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: Key lifetimes</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li class="current"><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
-</div><!-- top -->
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div class="header">
- <div class="summary">
-<a href="#define-members">Macros</a> |
-<a href="#typedef-members">Typedefs</a> </div>
- <div class="headertitle">
-<div class="title">Key lifetimes</div> </div>
-</div><!--header-->
-<div class="contents">
-<table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="define-members"></a>
-Macros</h2></td></tr>
-<tr class="memitem:ga8b438870ba69489b685730d346455108"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__key__lifetimes.html#ga8b438870ba69489b685730d346455108">PSA_KEY_LIFETIME_VOLATILE</a>   ((<a class="el" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">psa_key_lifetime_t</a>)0x00000000)</td></tr>
-<tr class="separator:ga8b438870ba69489b685730d346455108"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga3713a01c5fcd5f7eae46ff22ceaf6d02"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__key__lifetimes.html#ga3713a01c5fcd5f7eae46ff22ceaf6d02">PSA_KEY_LIFETIME_PERSISTENT</a>   ((<a class="el" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">psa_key_lifetime_t</a>)0x00000001)</td></tr>
-<tr class="separator:ga3713a01c5fcd5f7eae46ff22ceaf6d02"><td class="memSeparator" colspan="2"> </td></tr>
-</table><table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="typedef-members"></a>
-Typedefs</h2></td></tr>
-<tr class="memitem:ga6821ff6dd39dc2bc370ded760ad8b0cf"><td class="memItemLeft" align="right" valign="top">typedef uint32_t </td><td class="memItemRight" valign="bottom"><a class="el" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">psa_key_lifetime_t</a></td></tr>
-<tr class="separator:ga6821ff6dd39dc2bc370ded760ad8b0cf"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga11e986351c65bd3dc3c0fe2cd9926e4b"><td class="memItemLeft" align="right" valign="top">typedef uint32_t </td><td class="memItemRight" valign="bottom"><a class="el" href="group__key__lifetimes.html#ga11e986351c65bd3dc3c0fe2cd9926e4b">psa_key_id_t</a></td></tr>
-<tr class="separator:ga11e986351c65bd3dc3c0fe2cd9926e4b"><td class="memSeparator" colspan="2"> </td></tr>
-</table>
-<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
-<h2 class="groupheader">Macro Definition Documentation</h2>
-<a class="anchor" id="ga3713a01c5fcd5f7eae46ff22ceaf6d02"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_LIFETIME_PERSISTENT   ((<a class="el" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">psa_key_lifetime_t</a>)0x00000001)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The default storage area for persistent keys.</p>
-<p>A persistent key remains in storage until it is explicitly destroyed or until the corresponding storage area is wiped. This specification does not define any mechanism to wipe a storage area, but implementations may provide their own mechanism (for example to perform a factory reset, to prepare for device refurbishment, or to uninstall an application).</p>
-<p>This lifetime value is the default storage area for the calling application. Implementations may offer other storage areas designated by other lifetime values as implementation-specific extensions. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga8b438870ba69489b685730d346455108"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_LIFETIME_VOLATILE   ((<a class="el" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">psa_key_lifetime_t</a>)0x00000000)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>A volatile key only exists as long as the handle to it is not closed. The key material is guaranteed to be erased on a power reset. </p>
-
-</div>
-</div>
-<h2 class="groupheader">Typedef Documentation</h2>
-<a class="anchor" id="ga11e986351c65bd3dc3c0fe2cd9926e4b"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">typedef uint32_t <a class="el" href="group__key__lifetimes.html#ga11e986351c65bd3dc3c0fe2cd9926e4b">psa_key_id_t</a></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Encoding of identifiers of persistent keys. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga6821ff6dd39dc2bc370ded760ad8b0cf"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">typedef uint32_t <a class="el" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">psa_key_lifetime_t</a></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Encoding of key lifetimes. </p>
-
-</div>
-</div>
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/group__key__management.html b/docs/html/group__key__management.html
deleted file mode 100644
index 7c02c99..0000000
--- a/docs/html/group__key__management.html
+++ /dev/null
@@ -1,330 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: Key management</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li class="current"><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
-</div><!-- top -->
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div class="header">
- <div class="summary">
-<a href="#func-members">Functions</a> </div>
- <div class="headertitle">
-<div class="title">Key management</div> </div>
-</div><!--header-->
-<div class="contents">
-<table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="func-members"></a>
-Functions</h2></td></tr>
-<tr class="memitem:ga1e4825ab59260aeb3bdbb3ff07210022"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__key__management.html#ga1e4825ab59260aeb3bdbb3ff07210022">psa_get_key_lifetime</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">psa_key_lifetime_t</a> *lifetime)</td></tr>
-<tr class="memdesc:ga1e4825ab59260aeb3bdbb3ff07210022"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the lifetime of an open key. <a href="#ga1e4825ab59260aeb3bdbb3ff07210022">More...</a><br /></td></tr>
-<tr class="separator:ga1e4825ab59260aeb3bdbb3ff07210022"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga40094b77b7a42b9c8e158395113f1a35"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__key__management.html#ga40094b77b7a42b9c8e158395113f1a35">psa_allocate_key</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> *handle)</td></tr>
-<tr class="separator:ga40094b77b7a42b9c8e158395113f1a35"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa9f1c848cf78b80fe2a7b18bb7ccec50"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__key__management.html#gaa9f1c848cf78b80fe2a7b18bb7ccec50">psa_open_key</a> (<a class="el" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">psa_key_lifetime_t</a> lifetime, <a class="el" href="group__key__lifetimes.html#ga11e986351c65bd3dc3c0fe2cd9926e4b">psa_key_id_t</a> id, <a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> *handle)</td></tr>
-<tr class="separator:gaa9f1c848cf78b80fe2a7b18bb7ccec50"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga4108f255d3eaa6d23a7a14b684af8d7c"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__key__management.html#ga4108f255d3eaa6d23a7a14b684af8d7c">psa_create_key</a> (<a class="el" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">psa_key_lifetime_t</a> lifetime, <a class="el" href="group__key__lifetimes.html#ga11e986351c65bd3dc3c0fe2cd9926e4b">psa_key_id_t</a> id, <a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> *handle)</td></tr>
-<tr class="separator:ga4108f255d3eaa6d23a7a14b684af8d7c"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaa09b720d299dfe6b9f41c36e448078eb"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__key__management.html#gaa09b720d299dfe6b9f41c36e448078eb">psa_close_key</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle)</td></tr>
-<tr class="separator:gaa09b720d299dfe6b9f41c36e448078eb"><td class="memSeparator" colspan="2"> </td></tr>
-</table>
-<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
-<h2 class="groupheader">Function Documentation</h2>
-<a class="anchor" id="ga40094b77b7a42b9c8e158395113f1a35"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_allocate_key </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> * </td>
- <td class="paramname"><em>handle</em></td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Allocate a key slot for a transient key, i.e. a key which is only stored in volatile memory.</p>
-<p>The allocated key slot and its handle remain valid until the application calls <a class="el" href="group__key__management.html#gaa09b720d299dfe6b9f41c36e448078eb">psa_close_key()</a> or <a class="el" href="group__import__export.html#ga165085fc1bc7a78b91792fdd94ae102c" title="Destroy a key. ">psa_destroy_key()</a> or until the application terminates.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[out]</td><td class="paramname">handle</td><td>On success, a handle to a volatile key slot.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. The application can now use the value of <code>*handle</code> to access the newly allocated key slot. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td>There was not enough memory, or the maximum number of key slots has been reached. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="gaa09b720d299dfe6b9f41c36e448078eb"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_close_key </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em></td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Close a key handle.</p>
-<p>If the handle designates a volatile key, destroy the key material and free all associated resources, just like <a class="el" href="group__import__export.html#ga165085fc1bc7a78b91792fdd94ae102c" title="Destroy a key. ">psa_destroy_key()</a>.</p>
-<p>If the handle designates a persistent key, free all resources associated with the key in volatile memory. The key slot in persistent storage is not affected and can be opened again later with <a class="el" href="group__key__management.html#gaa9f1c848cf78b80fe2a7b18bb7ccec50">psa_open_key()</a>.</p>
-<p>If the key is currently in use in a multipart operation, the multipart operation is aborted.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramname">handle</td><td>The key handle to close.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga4108f255d3eaa6d23a7a14b684af8d7c"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_create_key </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">psa_key_lifetime_t</a> </td>
- <td class="paramname"><em>lifetime</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__key__lifetimes.html#ga11e986351c65bd3dc3c0fe2cd9926e4b">psa_key_id_t</a> </td>
- <td class="paramname"><em>id</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> * </td>
- <td class="paramname"><em>handle</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Create a new persistent key slot.</p>
-<p>Create a new persistent key slot and return a handle to it. The handle remains valid until the application calls <a class="el" href="group__key__management.html#gaa09b720d299dfe6b9f41c36e448078eb">psa_close_key()</a> or terminates. The application can open the key again with <a class="el" href="group__key__management.html#gaa9f1c848cf78b80fe2a7b18bb7ccec50">psa_open_key()</a> until it removes the key by calling <a class="el" href="group__import__export.html#ga165085fc1bc7a78b91792fdd94ae102c" title="Destroy a key. ">psa_destroy_key()</a>.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir"></td><td class="paramname">lifetime</td><td>The lifetime of the key. This designates a storage area where the key material is stored. This must not be <a class="el" href="group__key__lifetimes.html#ga8b438870ba69489b685730d346455108">PSA_KEY_LIFETIME_VOLATILE</a>. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">id</td><td>The persistent identifier of the key. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">handle</td><td>On success, a handle to the newly created key slot. When key material is later created in this key slot, it will be saved to the specified persistent location.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. The application can now use the value of <code>*handle</code> to access the newly allocated key slot. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga897a45eb206a6f6b7be7ffbe36f0d766">PSA_ERROR_INSUFFICIENT_STORAGE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gac2fee3a51249fbea45360aaa911f3e58">PSA_ERROR_OCCUPIED_SLOT</a></td><td>There is already a key with the identifier <code>id</code> in the storage area designated by <code>lifetime</code>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td><code>lifetime</code> is invalid, for example <a class="el" href="group__key__lifetimes.html#ga8b438870ba69489b685730d346455108">PSA_KEY_LIFETIME_VOLATILE</a>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td><code>id</code> is invalid for the specified lifetime. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td><code>lifetime</code> is not supported. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4d1b8dd8526177a15a210b7afc1accb1">PSA_ERROR_NOT_PERMITTED</a></td><td><code>lifetime</code> is valid, but the application does not have the permission to create a key there. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga1e4825ab59260aeb3bdbb3ff07210022"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_get_key_lifetime </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">psa_key_lifetime_t</a> * </td>
- <td class="paramname"><em>lifetime</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-
-<p>Retrieve the lifetime of an open key. </p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir"></td><td class="paramname">handle</td><td>Handle to query. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">lifetime</td><td>On success, the lifetime value.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The library has not been previously initialized by <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a>. It is implementation-dependent whether a failure to initialize results in this error code. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="gaa9f1c848cf78b80fe2a7b18bb7ccec50"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_open_key </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf">psa_key_lifetime_t</a> </td>
- <td class="paramname"><em>lifetime</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__key__lifetimes.html#ga11e986351c65bd3dc3c0fe2cd9926e4b">psa_key_id_t</a> </td>
- <td class="paramname"><em>id</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> * </td>
- <td class="paramname"><em>handle</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Open a handle to an existing persistent key.</p>
-<p>Open a handle to a key which was previously created with <a class="el" href="group__key__management.html#ga4108f255d3eaa6d23a7a14b684af8d7c">psa_create_key()</a>.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir"></td><td class="paramname">lifetime</td><td>The lifetime of the key. This designates a storage area where the key material is stored. This must not be <a class="el" href="group__key__lifetimes.html#ga8b438870ba69489b685730d346455108">PSA_KEY_LIFETIME_VOLATILE</a>. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">id</td><td>The persistent identifier of the key. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">handle</td><td>On success, a handle to a key slot which contains the data and metadata loaded from the specified persistent location.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. The application can now use the value of <code>*handle</code> to access the newly allocated key slot. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040">PSA_ERROR_EMPTY_SLOT</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td><code>lifetime</code> is invalid, for example <a class="el" href="group__key__lifetimes.html#ga8b438870ba69489b685730d346455108">PSA_KEY_LIFETIME_VOLATILE</a>. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td><code>id</code> is invalid for the specified lifetime. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td><code>lifetime</code> is not supported. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4d1b8dd8526177a15a210b7afc1accb1">PSA_ERROR_NOT_PERMITTED</a></td><td>The specified key exists, but the application does not have the permission to access it. Note that this specification does not define any way to create such a key, but it may be possible through implementation-specific means. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/group__platform.html b/docs/html/group__platform.html
deleted file mode 100644
index 4b616b1..0000000
--- a/docs/html/group__platform.html
+++ /dev/null
@@ -1,118 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: Implementation-specific definitions</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li class="current"><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
-</div><!-- top -->
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div class="header">
- <div class="summary">
-<a href="#typedef-members">Typedefs</a> </div>
- <div class="headertitle">
-<div class="title">Implementation-specific definitions</div> </div>
-</div><!--header-->
-<div class="contents">
-<table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="typedef-members"></a>
-Typedefs</h2></td></tr>
-<tr class="memitem:gabf6d5fd4e2ea89ecd425c88f057e7f75"><td class="memItemLeft" align="right" valign="top">typedef _unsigned_integral_type_ </td><td class="memItemRight" valign="bottom"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a></td></tr>
-<tr class="memdesc:gabf6d5fd4e2ea89ecd425c88f057e7f75"><td class="mdescLeft"> </td><td class="mdescRight">Key handle. <a href="#gabf6d5fd4e2ea89ecd425c88f057e7f75">More...</a><br /></td></tr>
-<tr class="separator:gabf6d5fd4e2ea89ecd425c88f057e7f75"><td class="memSeparator" colspan="2"> </td></tr>
-</table>
-<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
-<h2 class="groupheader">Typedef Documentation</h2>
-<a class="anchor" id="gabf6d5fd4e2ea89ecd425c88f057e7f75"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">typedef _unsigned_integral_type_ <a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a></td>
- </tr>
- </table>
-</div><div class="memdoc">
-
-<p>Key handle. </p>
-<p>This type represents open handles to keys. It must be an unsigned integral type. The choice of type is implementation-dependent.</p>
-<p>0 is not a valid key handle. How other handle values are assigned is implementation-dependent. </p>
-
-</div>
-</div>
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/group__policy.html b/docs/html/group__policy.html
deleted file mode 100644
index 2036b3c..0000000
--- a/docs/html/group__policy.html
+++ /dev/null
@@ -1,455 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: Key policies</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li class="current"><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
-</div><!-- top -->
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div class="header">
- <div class="summary">
-<a href="#define-members">Macros</a> |
-<a href="#typedef-members">Typedefs</a> |
-<a href="#func-members">Functions</a> </div>
- <div class="headertitle">
-<div class="title">Key policies</div> </div>
-</div><!--header-->
-<div class="contents">
-<table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="define-members"></a>
-Macros</h2></td></tr>
-<tr class="memitem:ga5e6bc5f550e88fdc7790f2a75e79f7c5"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#ga5e6bc5f550e88fdc7790f2a75e79f7c5">PSA_KEY_POLICY_INIT</a>   {0}</td></tr>
-<tr class="separator:ga5e6bc5f550e88fdc7790f2a75e79f7c5"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga7dddccdd1303176e87a4d20c87b589ed"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#ga7dddccdd1303176e87a4d20c87b589ed">PSA_KEY_USAGE_EXPORT</a>   ((<a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a>)0x00000001)</td></tr>
-<tr class="separator:ga7dddccdd1303176e87a4d20c87b589ed"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga75153b296d045d529d97203a6a995dad"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#ga75153b296d045d529d97203a6a995dad">PSA_KEY_USAGE_ENCRYPT</a>   ((<a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a>)0x00000100)</td></tr>
-<tr class="separator:ga75153b296d045d529d97203a6a995dad"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gac3f2d2e5983db1edde9f142ca9bf8e6a"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#gac3f2d2e5983db1edde9f142ca9bf8e6a">PSA_KEY_USAGE_DECRYPT</a>   ((<a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a>)0x00000200)</td></tr>
-<tr class="separator:gac3f2d2e5983db1edde9f142ca9bf8e6a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga99b9f456cf59efc4b5579465407aef5a"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#ga99b9f456cf59efc4b5579465407aef5a">PSA_KEY_USAGE_SIGN</a>   ((<a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a>)0x00000400)</td></tr>
-<tr class="separator:ga99b9f456cf59efc4b5579465407aef5a"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga39b54ffd5958b69634607924fa53cea6"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#ga39b54ffd5958b69634607924fa53cea6">PSA_KEY_USAGE_VERIFY</a>   ((<a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a>)0x00000800)</td></tr>
-<tr class="separator:ga39b54ffd5958b69634607924fa53cea6"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaf19022acc5ef23cf12477f632b48a0b2"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#gaf19022acc5ef23cf12477f632b48a0b2">PSA_KEY_USAGE_DERIVE</a>   ((<a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a>)0x00001000)</td></tr>
-<tr class="separator:gaf19022acc5ef23cf12477f632b48a0b2"><td class="memSeparator" colspan="2"> </td></tr>
-</table><table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="typedef-members"></a>
-Typedefs</h2></td></tr>
-<tr class="memitem:gaf553efd409845b6d09ff25ce2ba36607"><td class="memItemLeft" align="right" valign="top">typedef struct psa_key_policy_s </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a></td></tr>
-<tr class="separator:gaf553efd409845b6d09ff25ce2ba36607"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga7bb9de71337e0e98de843aa7f9b55f25"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ga7bb9de71337e0e98de843aa7f9b55f25"></a>
-typedef uint32_t </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a></td></tr>
-<tr class="memdesc:ga7bb9de71337e0e98de843aa7f9b55f25"><td class="mdescLeft"> </td><td class="mdescRight">Encoding of permitted usage on a key. <br /></td></tr>
-<tr class="separator:ga7bb9de71337e0e98de843aa7f9b55f25"><td class="memSeparator" colspan="2"> </td></tr>
-</table><table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="func-members"></a>
-Functions</h2></td></tr>
-<tr class="memitem:gac16792fd6d375a5f76d372090df40607"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#gac16792fd6d375a5f76d372090df40607">psa_key_policy_set_usage</a> (<a class="el" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a> *policy, <a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a> usage, <a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> alg)</td></tr>
-<tr class="memdesc:gac16792fd6d375a5f76d372090df40607"><td class="mdescLeft"> </td><td class="mdescRight">Set the standard fields of a policy structure. <a href="#gac16792fd6d375a5f76d372090df40607">More...</a><br /></td></tr>
-<tr class="separator:gac16792fd6d375a5f76d372090df40607"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga7746662b7503e484774d0ecb5d8ac2ab"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#ga7746662b7503e484774d0ecb5d8ac2ab">psa_key_policy_get_usage</a> (const <a class="el" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a> *policy)</td></tr>
-<tr class="memdesc:ga7746662b7503e484774d0ecb5d8ac2ab"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the usage field of a policy structure. <a href="#ga7746662b7503e484774d0ecb5d8ac2ab">More...</a><br /></td></tr>
-<tr class="separator:ga7746662b7503e484774d0ecb5d8ac2ab"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaadf16b89ace53e1d2cb5bcb0aef24c86"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#gaadf16b89ace53e1d2cb5bcb0aef24c86">psa_key_policy_get_algorithm</a> (const <a class="el" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a> *policy)</td></tr>
-<tr class="memdesc:gaadf16b89ace53e1d2cb5bcb0aef24c86"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the algorithm field of a policy structure. <a href="#gaadf16b89ace53e1d2cb5bcb0aef24c86">More...</a><br /></td></tr>
-<tr class="separator:gaadf16b89ace53e1d2cb5bcb0aef24c86"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga1e2a6e50b621864f95d438222a3c640b"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#ga1e2a6e50b621864f95d438222a3c640b">psa_set_key_policy</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, const <a class="el" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a> *policy)</td></tr>
-<tr class="memdesc:ga1e2a6e50b621864f95d438222a3c640b"><td class="mdescLeft"> </td><td class="mdescRight">Set the usage policy on a key slot. <a href="#ga1e2a6e50b621864f95d438222a3c640b">More...</a><br /></td></tr>
-<tr class="separator:ga1e2a6e50b621864f95d438222a3c640b"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:gaed087d1386b807edee66b2e445ba9111"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__policy.html#gaed087d1386b807edee66b2e445ba9111">psa_get_key_policy</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a> *policy)</td></tr>
-<tr class="memdesc:gaed087d1386b807edee66b2e445ba9111"><td class="mdescLeft"> </td><td class="mdescRight">Get the usage policy for a key slot. <a href="#gaed087d1386b807edee66b2e445ba9111">More...</a><br /></td></tr>
-<tr class="separator:gaed087d1386b807edee66b2e445ba9111"><td class="memSeparator" colspan="2"> </td></tr>
-</table>
-<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
-<h2 class="groupheader">Macro Definition Documentation</h2>
-<a class="anchor" id="ga5e6bc5f550e88fdc7790f2a75e79f7c5"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_POLICY_INIT   {0}</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>This macro returns a suitable initializer for a key policy object of type <a class="el" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a>. </p>
-
-</div>
-</div>
-<a class="anchor" id="gac3f2d2e5983db1edde9f142ca9bf8e6a"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_USAGE_DECRYPT   ((<a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a>)0x00000200)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Whether the key may be used to decrypt a message.</p>
-<p>This flag allows the key to be used for a symmetric decryption operation, for an AEAD decryption-and-verification operation, or for an asymmetric decryption operation, if otherwise permitted by the key's type and policy.</p>
-<p>For a key pair, this concerns the private key. </p>
-
-</div>
-</div>
-<a class="anchor" id="gaf19022acc5ef23cf12477f632b48a0b2"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_USAGE_DERIVE   ((<a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a>)0x00001000)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Whether the key may be used to derive other keys. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga75153b296d045d529d97203a6a995dad"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_USAGE_ENCRYPT   ((<a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a>)0x00000100)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Whether the key may be used to encrypt a message.</p>
-<p>This flag allows the key to be used for a symmetric encryption operation, for an AEAD encryption-and-authentication operation, or for an asymmetric encryption operation, if otherwise permitted by the key's type and policy.</p>
-<p>For a key pair, this concerns the public key. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga7dddccdd1303176e87a4d20c87b589ed"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_USAGE_EXPORT   ((<a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a>)0x00000001)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Whether the key may be exported.</p>
-<p>A public key or the public part of a key pair may always be exported regardless of the value of this permission flag.</p>
-<p>If a key does not have export permission, implementations shall not allow the key to be exported in plain form from the cryptoprocessor, whether through <a class="el" href="group__import__export.html#ga902b9a7a6cf34d6111668be777b05eaf" title="Export a key in binary format. ">psa_export_key()</a> or through a proprietary interface. The key may however be exportable in a wrapped form, i.e. in a form where it is encrypted by another key. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga99b9f456cf59efc4b5579465407aef5a"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_USAGE_SIGN   ((<a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a>)0x00000400)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Whether the key may be used to sign a message.</p>
-<p>This flag allows the key to be used for a MAC calculation operation or for an asymmetric signature operation, if otherwise permitted by the key's type and policy.</p>
-<p>For a key pair, this concerns the private key. </p>
-
-</div>
-</div>
-<a class="anchor" id="ga39b54ffd5958b69634607924fa53cea6"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">#define PSA_KEY_USAGE_VERIFY   ((<a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a>)0x00000800)</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Whether the key may be used to verify a message signature.</p>
-<p>This flag allows the key to be used for a MAC verification operation or for an asymmetric signature verification operation, if otherwise permitted by by the key's type and policy.</p>
-<p>For a key pair, this concerns the public key. </p>
-
-</div>
-</div>
-<h2 class="groupheader">Typedef Documentation</h2>
-<a class="anchor" id="gaf553efd409845b6d09ff25ce2ba36607"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">typedef struct psa_key_policy_s <a class="el" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a></td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>The type of the key policy data structure.</p>
-<p>Before calling any function on a key policy, the application must initialize it by any of the following means:</p><ul>
-<li>Set the structure to all-bits-zero, for example: <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> psa_key_policy_t policy;</div><div class="line"><a name="l00002"></a><span class="lineno"> 2</span> memset(&policy, 0, sizeof(policy));</div></div><!-- fragment --></li>
-<li>Initialize the structure to logical zero values, for example: <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> psa_key_policy_t policy = {0};</div></div><!-- fragment --></li>
-<li>Initialize the structure to the initializer <a class="el" href="group__policy.html#ga5e6bc5f550e88fdc7790f2a75e79f7c5">PSA_KEY_POLICY_INIT</a>, for example: <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> psa_key_policy_t policy = PSA_KEY_POLICY_INIT;</div></div><!-- fragment --></li>
-<li>Assign the result of the function psa_key_policy_init() to the structure, for example: <div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span> psa_key_policy_t policy;</div><div class="line"><a name="l00002"></a><span class="lineno"> 2</span> policy = psa_key_policy_init();</div></div><!-- fragment --></li>
-</ul>
-<p>This is an implementation-defined <code>struct</code>. Applications should not make any assumptions about the content of this structure except as directed by the documentation of a specific implementation. </p>
-
-</div>
-</div>
-<h2 class="groupheader">Function Documentation</h2>
-<a class="anchor" id="gaed087d1386b807edee66b2e445ba9111"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_get_key_policy </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a> * </td>
- <td class="paramname"><em>policy</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-
-<p>Get the usage policy for a key slot. </p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir"></td><td class="paramname">handle</td><td>Handle to the key slot whose policy is being queried. </td></tr>
- <tr><td class="paramdir">[out]</td><td class="paramname">policy</td><td>On success, the key's policy.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The library has not been previously initialized by <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a>. It is implementation-dependent whether a failure to initialize results in this error code. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="gaadf16b89ace53e1d2cb5bcb0aef24c86"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> psa_key_policy_get_algorithm </td>
- <td>(</td>
- <td class="paramtype">const <a class="el" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a> * </td>
- <td class="paramname"><em>policy</em></td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-
-<p>Retrieve the algorithm field of a policy structure. </p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in]</td><td class="paramname">policy</td><td>The policy object to query.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>The permitted algorithm for a key with this policy. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="ga7746662b7503e484774d0ecb5d8ac2ab"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a> psa_key_policy_get_usage </td>
- <td>(</td>
- <td class="paramtype">const <a class="el" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a> * </td>
- <td class="paramname"><em>policy</em></td><td>)</td>
- <td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-
-<p>Retrieve the usage field of a policy structure. </p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in]</td><td class="paramname">policy</td><td>The policy object to query.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="section return"><dt>Returns</dt><dd>The permitted uses for a key with this policy. </dd></dl>
-
-</div>
-</div>
-<a class="anchor" id="gac16792fd6d375a5f76d372090df40607"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">void psa_key_policy_set_usage </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a> * </td>
- <td class="paramname"><em>policy</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25">psa_key_usage_t</a> </td>
- <td class="paramname"><em>usage</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69">psa_algorithm_t</a> </td>
- <td class="paramname"><em>alg</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-
-<p>Set the standard fields of a policy structure. </p>
-<p>Note that this function does not make any consistency check of the parameters. The values are only checked when applying the policy to a key slot with <a class="el" href="group__policy.html#ga1e2a6e50b621864f95d438222a3c640b" title="Set the usage policy on a key slot. ">psa_set_key_policy()</a>.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[in,out]</td><td class="paramname">policy</td><td>The key policy to modify. It must have been initialized as per the documentation for <a class="el" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a>. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">usage</td><td>The permitted uses for the key. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">alg</td><td>The algorithm that the key may be used for. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga1e2a6e50b621864f95d438222a3c640b"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_set_key_policy </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const <a class="el" href="group__policy.html#gaf553efd409845b6d09ff25ce2ba36607">psa_key_policy_t</a> * </td>
- <td class="paramname"><em>policy</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-
-<p>Set the usage policy on a key slot. </p>
-<p>This function must be called on an empty key slot, before importing, generating or creating a key in the slot. Changing the policy of an existing key is not permitted.</p>
-<p>Implementations may set restrictions on supported key policies depending on the key type and the key slot.</p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir"></td><td class="paramname">handle</td><td>Handle to the key whose policy is to be changed. </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">policy</td><td>The policy object to query.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. If the key is persistent, it is implementation-defined whether the policy has been saved to persistent storage. Implementations may defer saving the policy until the key material is created. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gac2fee3a51249fbea45360aaa911f3e58">PSA_ERROR_OCCUPIED_SLOT</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The library has not been previously initialized by <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a>. It is implementation-dependent whether a failure to initialize results in this error code. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/group__random.html b/docs/html/group__random.html
deleted file mode 100644
index 48173f2..0000000
--- a/docs/html/group__random.html
+++ /dev/null
@@ -1,239 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: Random generation</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li class="current"><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
-</div><!-- top -->
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div class="header">
- <div class="summary">
-<a href="#nested-classes">Classes</a> |
-<a href="#func-members">Functions</a> </div>
- <div class="headertitle">
-<div class="title">Random generation</div> </div>
-</div><!--header-->
-<div class="contents">
-<table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
-Classes</h2></td></tr>
-<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structpsa__generate__key__extra__rsa.html">psa_generate_key_extra_rsa</a></td></tr>
-<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
-</table><table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="func-members"></a>
-Functions</h2></td></tr>
-<tr class="memitem:ga1985eae417dfbccedf50d5fff54ea8c5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__random.html#ga1985eae417dfbccedf50d5fff54ea8c5">psa_generate_random</a> (uint8_t *output, size_t output_size)</td></tr>
-<tr class="memdesc:ga1985eae417dfbccedf50d5fff54ea8c5"><td class="mdescLeft"> </td><td class="mdescRight">Generate random bytes. <a href="#ga1985eae417dfbccedf50d5fff54ea8c5">More...</a><br /></td></tr>
-<tr class="separator:ga1985eae417dfbccedf50d5fff54ea8c5"><td class="memSeparator" colspan="2"> </td></tr>
-<tr class="memitem:ga72921520494b4f007a3afb904cd9ecdd"><td class="memItemLeft" align="right" valign="top"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__random.html#ga72921520494b4f007a3afb904cd9ecdd">psa_generate_key</a> (<a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> handle, <a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a> type, size_t bits, const void *extra, size_t extra_size)</td></tr>
-<tr class="memdesc:ga72921520494b4f007a3afb904cd9ecdd"><td class="mdescLeft"> </td><td class="mdescRight">Generate a key or key pair. <a href="#ga72921520494b4f007a3afb904cd9ecdd">More...</a><br /></td></tr>
-<tr class="separator:ga72921520494b4f007a3afb904cd9ecdd"><td class="memSeparator" colspan="2"> </td></tr>
-</table>
-<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
-<h2 class="groupheader">Function Documentation</h2>
-<a class="anchor" id="ga72921520494b4f007a3afb904cd9ecdd"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_generate_key </td>
- <td>(</td>
- <td class="paramtype"><a class="el" href="group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75">psa_key_handle_t</a> </td>
- <td class="paramname"><em>handle</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype"><a class="el" href="group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628">psa_key_type_t</a> </td>
- <td class="paramname"><em>type</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>bits</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">const void * </td>
- <td class="paramname"><em>extra</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>extra_size</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-
-<p>Generate a key or key pair. </p>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir"></td><td class="paramname">handle</td><td>Handle to the slot where the key will be stored. It must have been obtained by calling <a class="el" href="group__key__management.html#ga40094b77b7a42b9c8e158395113f1a35">psa_allocate_key()</a> or <a class="el" href="group__key__management.html#ga4108f255d3eaa6d23a7a14b684af8d7c">psa_create_key()</a> and must not contain key material yet. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">type</td><td>Key type (a <code>PSA_KEY_TYPE_XXX</code> value). </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">bits</td><td>Key size in bits. </td></tr>
- <tr><td class="paramdir">[in]</td><td class="paramname">extra</td><td>Extra parameters for key generation. The interpretation of this parameter depends on <code>type</code>. All types support <code>NULL</code> to use default parameters. Implementation that support the generation of vendor-specific key types that allow extra parameters shall document the format of these extra parameters and the default values. For standard parameters, the meaning of <code>extra</code> is as follows:<ul>
-<li>For a symmetric key type (a type such that <a class="el" href="group__crypto__types.html#gab138ae2ebf2905dfbaf4154db2620939">PSA_KEY_TYPE_IS_ASYMMETRIC</a>(<code>type</code>) is false), <code>extra</code> must be <code>NULL</code>.</li>
-<li>For an elliptic curve key type (a type such that <a class="el" href="group__crypto__types.html#ga88e01fa06b585654689a99bcc06bbe66">PSA_KEY_TYPE_IS_ECC</a>(<code>type</code>) is false), <code>extra</code> must be <code>NULL</code>.</li>
-<li>For an RSA key (<code>type</code> is <a class="el" href="group__crypto__types.html#ga581f50687f5d650456925278948f2799">PSA_KEY_TYPE_RSA_KEYPAIR</a>), <code>extra</code> is an optional <a class="el" href="structpsa__generate__key__extra__rsa.html">psa_generate_key_extra_rsa</a> structure specifying the public exponent. The default public exponent used when <code>extra</code> is <code>NULL</code> is 65537.</li>
-<li>For an DSA key (<code>type</code> is <a class="el" href="group__crypto__types.html#ga011010ee28c20388f3d89fb27088ed62">PSA_KEY_TYPE_DSA_KEYPAIR</a>), <code>extra</code> is an optional structure specifying the key domain parameters. The key domain parameters can also be provided by <a class="el" href="group__import__export.html#ga091da8d3d39137fd6ad59f2b10234300" title="Set domain parameters for a key. ">psa_set_key_domain_parameters()</a>, which documents the format of the structure.</li>
-<li>For a DH key (<code>type</code> is <a class="el" href="group__crypto__types.html#ga39b63c6b97a62a316c0660bf72b2fdd5">PSA_KEY_TYPE_DH_KEYPAIR</a>), the <code>extra</code> is an optional structure specifying the key domain parameters. The key domain parameters can also be provided by <a class="el" href="group__import__export.html#ga091da8d3d39137fd6ad59f2b10234300" title="Set domain parameters for a key. ">psa_set_key_domain_parameters()</a>, which documents the format of the structure. </li>
-</ul>
-</td></tr>
- <tr><td class="paramdir"></td><td class="paramname">extra_size</td><td>Size of the buffer that <code>extra</code> points to, in bytes. Note that if <code>extra</code> is <code>NULL</code> then <code>extra_size</code> must be zero.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td>Success. If the key is persistent, the key material and the key's metadata have been saved to persistent storage. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gadf22718935657c2c3168c228204085f9">PSA_ERROR_INVALID_HANDLE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#gac2fee3a51249fbea45360aaa911f3e58">PSA_ERROR_OCCUPIED_SLOT</a></td><td>There is already a key in the specified slot. </td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga798df25a505ebf931f7bec1f80f1f85f">PSA_ERROR_INVALID_ARGUMENT</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga91b2ad8a867517a2651f1b076c5216e5">PSA_ERROR_INSUFFICIENT_MEMORY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4deb59fec02297ec5d8b42178323f675">PSA_ERROR_INSUFFICIENT_ENTROPY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The library has not been previously initialized by <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a>. It is implementation-dependent whether a failure to initialize results in this error code. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-<a class="anchor" id="ga1985eae417dfbccedf50d5fff54ea8c5"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname"><a class="el" href="group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9">psa_status_t</a> psa_generate_random </td>
- <td>(</td>
- <td class="paramtype">uint8_t * </td>
- <td class="paramname"><em>output</em>, </td>
- </tr>
- <tr>
- <td class="paramkey"></td>
- <td></td>
- <td class="paramtype">size_t </td>
- <td class="paramname"><em>output_size</em> </td>
- </tr>
- <tr>
- <td></td>
- <td>)</td>
- <td></td><td></td>
- </tr>
- </table>
-</div><div class="memdoc">
-
-<p>Generate random bytes. </p>
-<dl class="section warning"><dt>Warning</dt><dd>This function <b>can</b> fail! Callers MUST check the return status and MUST NOT use the content of the output buffer if the return status is not <a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a>.</dd></dl>
-<dl class="section note"><dt>Note</dt><dd>To generate a key, use <a class="el" href="group__random.html#ga72921520494b4f007a3afb904cd9ecdd" title="Generate a key or key pair. ">psa_generate_key()</a> instead.</dd></dl>
-<dl class="params"><dt>Parameters</dt><dd>
- <table class="params">
- <tr><td class="paramdir">[out]</td><td class="paramname">output</td><td>Output buffer for the generated data. </td></tr>
- <tr><td class="paramdir"></td><td class="paramname">output_size</td><td>Number of bytes to generate and output.</td></tr>
- </table>
- </dd>
-</dl>
-<dl class="retval"><dt>Return values</dt><dd>
- <table class="retval">
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4cc859e2c66ca381c7418db3527a65e1">PSA_SUCCESS</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga1dcc6d130633ed5db8942257581b55dd">PSA_ERROR_NOT_SUPPORTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga4deb59fec02297ec5d8b42178323f675">PSA_ERROR_INSUFFICIENT_ENTROPY</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga5cdb6948371d49e916106249020ea3f7">PSA_ERROR_COMMUNICATION_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b">PSA_ERROR_HARDWARE_FAILURE</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004">PSA_ERROR_TAMPERING_DETECTED</a></td><td></td></tr>
- <tr><td class="paramname"><a class="el" href="group__error.html#ga933d40fa2a591004f2e93aa91e11db84">PSA_ERROR_BAD_STATE</a></td><td>The library has not been previously initialized by <a class="el" href="group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9" title="Library initialization. ">psa_crypto_init()</a>. It is implementation-dependent whether a failure to initialize results in this error code. </td></tr>
- </table>
- </dd>
-</dl>
-
-</div>
-</div>
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/index.html b/docs/html/index.html
index 3fb1ac1..6d47087 100644
--- a/docs/html/index.html
+++ b/docs/html/index.html
@@ -1,91 +1,834 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: Main Page</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
+ <head>
+ <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+ <title>PSA Cryptography API Specification — psa_crypto_api 1.0 beta3 documentation</title>
+ <link rel="stylesheet" href="_static/alabaster.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+ <script type="text/javascript" id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
+ <script type="text/javascript" src="_static/jquery.js"></script>
+ <script type="text/javascript" src="_static/underscore.js"></script>
+ <script type="text/javascript" src="_static/doctools.js"></script>
+ <script type="text/javascript" src="_static/language_data.js"></script>
+ <link rel="index" title="Index" href="genindex.html" />
+ <link rel="search" title="Search" href="search.html" />
+ <link rel="next" title="Introduction" href="general.html" />
+
+ <link rel="stylesheet" href="_static/custom.css" type="text/css" />
+
+
+ <meta name="viewport" content="width=device-width, initial-scale=0.9, maximum-scale=0.9" />
+
+ </head><body>
+
+
+ <div class="document">
+ <div class="documentwrapper">
+ <div class="bodywrapper">
+
+
+ <div class="body" role="main">
+
+ <div class="section" id="psa-cryptography-api-specification">
+<h1>PSA Cryptography API Specification</h1>
+<div class="toctree-wrapper compound">
+<ul>
+<li class="toctree-l1"><a class="reference internal" href="general.html">Introduction</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#design-goals">Design goals</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="general.html#suitable-for-constrained-devices">Suitable for constrained devices</a></li>
+<li class="toctree-l2"><a class="reference internal" href="general.html#a-keystore-interface">A keystore interface</a></li>
+<li class="toctree-l2"><a class="reference internal" href="general.html#optional-isolation">Optional isolation</a></li>
+<li class="toctree-l2"><a class="reference internal" href="general.html#choice-of-algorithms">Choice of algorithms</a></li>
+<li class="toctree-l2"><a class="reference internal" href="general.html#ease-of-use">Ease of use</a></li>
+<li class="toctree-l2"><a class="reference internal" href="general.html#example-use-cases">Example use cases</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="general.html#network-security-tls">Network Security (TLS)</a></li>
+<li class="toctree-l3"><a class="reference internal" href="general.html#secure-storage">Secure Storage</a></li>
+<li class="toctree-l3"><a class="reference internal" href="general.html#network-credentials">Network Credentials</a></li>
+<li class="toctree-l3"><a class="reference internal" href="general.html#device-pairing">Device Pairing</a></li>
+<li class="toctree-l3"><a class="reference internal" href="general.html#secure-boot">Secure Boot</a></li>
+<li class="toctree-l3"><a class="reference internal" href="general.html#attestation">Attestation</a></li>
+<li class="toctree-l3"><a class="reference internal" href="general.html#factory-provisioning">Factory Provisioning</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#functionality-overview">Functionality overview</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="general.html#library-management">Library management</a></li>
+<li class="toctree-l2"><a class="reference internal" href="general.html#key-management">Key management</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="general.html#volatile-keys">Volatile keys</a></li>
+<li class="toctree-l3"><a class="reference internal" href="general.html#persistent-keys">Persistent keys</a></li>
+<li class="toctree-l3"><a class="reference internal" href="general.html#recommendations-of-minimum-standards-for-key-management">Recommendations of minimum standards for key management</a></li>
+</ul>
+</li>
+<li class="toctree-l2"><a class="reference internal" href="general.html#usage-policies">Usage policies</a></li>
+<li class="toctree-l2"><a class="reference internal" href="general.html#symmetric-cryptography">Symmetric cryptography</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="general.html#multipart-operations">Multipart operations</a></li>
+<li class="toctree-l3"><a class="reference internal" href="general.html#authenticated-encryption">Authenticated encryption</a></li>
+</ul>
+</li>
+<li class="toctree-l2"><a class="reference internal" href="general.html#key-derivation">Key derivation</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="general.html#key-derivation-operations">Key derivation operations</a></li>
+<li class="toctree-l3"><a class="reference internal" href="general.html#key-derivation-function">Key derivation function</a></li>
+</ul>
+</li>
+<li class="toctree-l2"><a class="reference internal" href="general.html#asymmetric-cryptography">Asymmetric cryptography</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="general.html#asymmetric-encryption">Asymmetric encryption</a></li>
+<li class="toctree-l3"><a class="reference internal" href="general.html#hash-and-sign">Hash-and-sign</a></li>
+<li class="toctree-l3"><a class="reference internal" href="general.html#key-agreement">Key agreement</a></li>
+</ul>
+</li>
+<li class="toctree-l2"><a class="reference internal" href="general.html#randomness-and-key-generation">Randomness and key generation</a></li>
+<li class="toctree-l2"><a class="reference internal" href="general.html#future-additions">Future additions</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#sample-architectures">Sample architectures</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="general.html#single-partition-architecture">Single-partition architecture</a></li>
+<li class="toctree-l2"><a class="reference internal" href="general.html#cryptographic-token-and-single-application-processor">Cryptographic token and single-application processor</a></li>
+<li class="toctree-l2"><a class="reference internal" href="general.html#cryptoprocessor-with-no-key-storage">Cryptoprocessor with no key storage</a></li>
+<li class="toctree-l2"><a class="reference internal" href="general.html#multi-client-cryptoprocessor">Multi-client cryptoprocessor</a></li>
+<li class="toctree-l2"><a class="reference internal" href="general.html#multi-cryptoprocessor-architecture">Multi-cryptoprocessor architecture</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#library-conventions">Library conventions</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="general.html#error-handling">Error handling</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="general.html#return-status">Return status</a></li>
+<li class="toctree-l3"><a class="reference internal" href="general.html#behavior-on-error">Behavior on error</a></li>
+</ul>
+</li>
+<li class="toctree-l2"><a class="reference internal" href="general.html#parameter-conventions">Parameter conventions</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="general.html#pointer-conventions">Pointer conventions</a></li>
+<li class="toctree-l3"><a class="reference internal" href="general.html#input-buffer-sizes">Input buffer sizes</a></li>
+<li class="toctree-l3"><a class="reference internal" href="general.html#output-buffer-sizes">Output buffer sizes</a></li>
+<li class="toctree-l3"><a class="reference internal" href="general.html#overlap-between-parameters">Overlap between parameters</a></li>
+<li class="toctree-l3"><a class="reference internal" href="general.html#stability-of-parameters">Stability of parameters</a></li>
+</ul>
+</li>
+<li class="toctree-l2"><a class="reference internal" href="general.html#key-types-and-algorithms">Key types and algorithms</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="general.html#structure-of-key-and-algorithm-types">Structure of key and algorithm types</a></li>
+</ul>
+</li>
+<li class="toctree-l2"><a class="reference internal" href="general.html#concurrent-calls">Concurrent calls</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#implementation-considerations">Implementation considerations</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="general.html#implementation-specific-aspects-of-the-interface">Implementation-specific aspects of the interface</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="general.html#implementation-profile">Implementation profile</a></li>
+<li class="toctree-l3"><a class="reference internal" href="general.html#implementation-specific-types">Implementation-specific types</a></li>
+<li class="toctree-l3"><a class="reference internal" href="general.html#implementation-specific-macros">Implementation-specific macros</a></li>
+</ul>
+</li>
+<li class="toctree-l2"><a class="reference internal" href="general.html#porting-to-a-platform">Porting to a platform</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="general.html#platform-assumptions">Platform assumptions</a></li>
+<li class="toctree-l3"><a class="reference internal" href="general.html#platform-specific-types">Platform-specific types</a></li>
+<li class="toctree-l3"><a class="reference internal" href="general.html#cryptographic-hardware-support">Cryptographic hardware support</a></li>
+</ul>
+</li>
+<li class="toctree-l2"><a class="reference internal" href="general.html#security-requirements-and-recommendations">Security requirements and recommendations</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="general.html#error-detection">Error detection</a></li>
+<li class="toctree-l3"><a class="reference internal" href="general.html#memory-cleanup">Memory cleanup</a></li>
+<li class="toctree-l3"><a class="reference internal" href="general.html#safe-outputs-on-error">Safe outputs on error</a></li>
+<li class="toctree-l3"><a class="reference internal" href="general.html#attack-resistance">Attack resistance</a></li>
+</ul>
+</li>
+<li class="toctree-l2"><a class="reference internal" href="general.html#other-implementation-considerations">Other implementation considerations</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="general.html#philosophy-of-resource-management">Philosophy of resource management</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#usage-considerations">Usage considerations</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="general.html#security-recommendations">Security recommendations</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="general.html#always-check-for-errors">Always check for errors</a></li>
+<li class="toctree-l3"><a class="reference internal" href="general.html#shared-memory-and-concurrency">Shared memory and concurrency</a></li>
+<li class="toctree-l3"><a class="reference internal" href="general.html#cleaning-up-after-use">Cleaning up after use</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html">Implementation-specific definitions</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_key_handle_t"><code class="docutils literal notranslate"><span class="pre">psa_key_handle_t</span></code> (type)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#library-initialization">Library initialization</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_crypto_init"><code class="docutils literal notranslate"><span class="pre">psa_crypto_init</span></code> (function)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-attributes">Key attributes</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_key_attributes_t"><code class="docutils literal notranslate"><span class="pre">psa_key_attributes_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_ATTRIBUTES_INIT"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_ATTRIBUTES_INIT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_key_attributes_init"><code class="docutils literal notranslate"><span class="pre">psa_key_attributes_init</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_set_key_id"><code class="docutils literal notranslate"><span class="pre">psa_set_key_id</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_set_key_lifetime"><code class="docutils literal notranslate"><span class="pre">psa_set_key_lifetime</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_get_key_id"><code class="docutils literal notranslate"><span class="pre">psa_get_key_id</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_get_key_lifetime"><code class="docutils literal notranslate"><span class="pre">psa_get_key_lifetime</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_set_key_usage_flags"><code class="docutils literal notranslate"><span class="pre">psa_set_key_usage_flags</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_get_key_usage_flags"><code class="docutils literal notranslate"><span class="pre">psa_get_key_usage_flags</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_set_key_algorithm"><code class="docutils literal notranslate"><span class="pre">psa_set_key_algorithm</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_get_key_algorithm"><code class="docutils literal notranslate"><span class="pre">psa_get_key_algorithm</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_set_key_type"><code class="docutils literal notranslate"><span class="pre">psa_set_key_type</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_set_key_bits"><code class="docutils literal notranslate"><span class="pre">psa_set_key_bits</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_get_key_type"><code class="docutils literal notranslate"><span class="pre">psa_get_key_type</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_get_key_bits"><code class="docutils literal notranslate"><span class="pre">psa_get_key_bits</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_get_key_attributes"><code class="docutils literal notranslate"><span class="pre">psa_get_key_attributes</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_reset_key_attributes"><code class="docutils literal notranslate"><span class="pre">psa_reset_key_attributes</span></code> (function)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-management">Key management</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_open_key"><code class="docutils literal notranslate"><span class="pre">psa_open_key</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_close_key"><code class="docutils literal notranslate"><span class="pre">psa_close_key</span></code> (function)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-import-and-export">Key import and export</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_import_key"><code class="docutils literal notranslate"><span class="pre">psa_import_key</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_destroy_key"><code class="docutils literal notranslate"><span class="pre">psa_destroy_key</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_export_key"><code class="docutils literal notranslate"><span class="pre">psa_export_key</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_export_public_key"><code class="docutils literal notranslate"><span class="pre">psa_export_public_key</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_copy_key"><code class="docutils literal notranslate"><span class="pre">psa_copy_key</span></code> (function)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#message-digests">Message digests</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_hash_operation_t"><code class="docutils literal notranslate"><span class="pre">psa_hash_operation_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_HASH_OPERATION_INIT"><code class="docutils literal notranslate"><span class="pre">PSA_HASH_OPERATION_INIT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_hash_compute"><code class="docutils literal notranslate"><span class="pre">psa_hash_compute</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_hash_compare"><code class="docutils literal notranslate"><span class="pre">psa_hash_compare</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_hash_operation_init"><code class="docutils literal notranslate"><span class="pre">psa_hash_operation_init</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_hash_setup"><code class="docutils literal notranslate"><span class="pre">psa_hash_setup</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_hash_update"><code class="docutils literal notranslate"><span class="pre">psa_hash_update</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_hash_finish"><code class="docutils literal notranslate"><span class="pre">psa_hash_finish</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_hash_verify"><code class="docutils literal notranslate"><span class="pre">psa_hash_verify</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_hash_abort"><code class="docutils literal notranslate"><span class="pre">psa_hash_abort</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_hash_clone"><code class="docutils literal notranslate"><span class="pre">psa_hash_clone</span></code> (function)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#message-authentication-codes">Message authentication codes</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_mac_operation_t"><code class="docutils literal notranslate"><span class="pre">psa_mac_operation_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_MAC_OPERATION_INIT"><code class="docutils literal notranslate"><span class="pre">PSA_MAC_OPERATION_INIT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_mac_compute"><code class="docutils literal notranslate"><span class="pre">psa_mac_compute</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_mac_verify"><code class="docutils literal notranslate"><span class="pre">psa_mac_verify</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_mac_operation_init"><code class="docutils literal notranslate"><span class="pre">psa_mac_operation_init</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_mac_sign_setup"><code class="docutils literal notranslate"><span class="pre">psa_mac_sign_setup</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_mac_verify_setup"><code class="docutils literal notranslate"><span class="pre">psa_mac_verify_setup</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_mac_update"><code class="docutils literal notranslate"><span class="pre">psa_mac_update</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_mac_sign_finish"><code class="docutils literal notranslate"><span class="pre">psa_mac_sign_finish</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_mac_verify_finish"><code class="docutils literal notranslate"><span class="pre">psa_mac_verify_finish</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_mac_abort"><code class="docutils literal notranslate"><span class="pre">psa_mac_abort</span></code> (function)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#symmetric-ciphers">Symmetric ciphers</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_cipher_operation_t"><code class="docutils literal notranslate"><span class="pre">psa_cipher_operation_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_CIPHER_OPERATION_INIT"><code class="docutils literal notranslate"><span class="pre">PSA_CIPHER_OPERATION_INIT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_cipher_encrypt"><code class="docutils literal notranslate"><span class="pre">psa_cipher_encrypt</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_cipher_decrypt"><code class="docutils literal notranslate"><span class="pre">psa_cipher_decrypt</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_cipher_operation_init"><code class="docutils literal notranslate"><span class="pre">psa_cipher_operation_init</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_cipher_encrypt_setup"><code class="docutils literal notranslate"><span class="pre">psa_cipher_encrypt_setup</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_cipher_decrypt_setup"><code class="docutils literal notranslate"><span class="pre">psa_cipher_decrypt_setup</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_cipher_generate_iv"><code class="docutils literal notranslate"><span class="pre">psa_cipher_generate_iv</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_cipher_set_iv"><code class="docutils literal notranslate"><span class="pre">psa_cipher_set_iv</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_cipher_update"><code class="docutils literal notranslate"><span class="pre">psa_cipher_update</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_cipher_finish"><code class="docutils literal notranslate"><span class="pre">psa_cipher_finish</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_cipher_abort"><code class="docutils literal notranslate"><span class="pre">psa_cipher_abort</span></code> (function)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#authenticated-encryption-with-associated-data-aead">Authenticated encryption with associated data (AEAD)</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_aead_operation_t"><code class="docutils literal notranslate"><span class="pre">psa_aead_operation_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_AEAD_OPERATION_INIT"><code class="docutils literal notranslate"><span class="pre">PSA_AEAD_OPERATION_INIT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_aead_encrypt"><code class="docutils literal notranslate"><span class="pre">psa_aead_encrypt</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_aead_decrypt"><code class="docutils literal notranslate"><span class="pre">psa_aead_decrypt</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_aead_operation_init"><code class="docutils literal notranslate"><span class="pre">psa_aead_operation_init</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_aead_encrypt_setup"><code class="docutils literal notranslate"><span class="pre">psa_aead_encrypt_setup</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_aead_decrypt_setup"><code class="docutils literal notranslate"><span class="pre">psa_aead_decrypt_setup</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_aead_generate_nonce"><code class="docutils literal notranslate"><span class="pre">psa_aead_generate_nonce</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_aead_set_nonce"><code class="docutils literal notranslate"><span class="pre">psa_aead_set_nonce</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_aead_set_lengths"><code class="docutils literal notranslate"><span class="pre">psa_aead_set_lengths</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_aead_update_ad"><code class="docutils literal notranslate"><span class="pre">psa_aead_update_ad</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_aead_update"><code class="docutils literal notranslate"><span class="pre">psa_aead_update</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_aead_finish"><code class="docutils literal notranslate"><span class="pre">psa_aead_finish</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_aead_verify"><code class="docutils literal notranslate"><span class="pre">psa_aead_verify</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_aead_abort"><code class="docutils literal notranslate"><span class="pre">psa_aead_abort</span></code> (function)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#asymmetric-cryptography">Asymmetric cryptography</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_asymmetric_sign"><code class="docutils literal notranslate"><span class="pre">psa_asymmetric_sign</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_asymmetric_verify"><code class="docutils literal notranslate"><span class="pre">psa_asymmetric_verify</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_asymmetric_encrypt"><code class="docutils literal notranslate"><span class="pre">psa_asymmetric_encrypt</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_asymmetric_decrypt"><code class="docutils literal notranslate"><span class="pre">psa_asymmetric_decrypt</span></code> (function)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-derivation-and-pseudorandom-generation">Key derivation and pseudorandom generation</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_key_derivation_operation_t"><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_operation_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_DERIVATION_OPERATION_INIT"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_OPERATION_INIT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_DERIVATION_UNLIMITED_CAPACITY"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_UNLIMITED_CAPACITY</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_key_derivation_operation_init"><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_operation_init</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_key_derivation_setup"><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_setup</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_key_derivation_get_capacity"><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_get_capacity</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_key_derivation_set_capacity"><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_set_capacity</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_key_derivation_input_bytes"><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_input_bytes</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_key_derivation_input_key"><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_input_key</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_key_derivation_key_agreement"><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_key_agreement</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_key_derivation_output_bytes"><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_output_bytes</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_key_derivation_output_key"><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_output_key</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_key_derivation_abort"><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_abort</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_raw_key_agreement"><code class="docutils literal notranslate"><span class="pre">psa_raw_key_agreement</span></code> (function)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#random-generation">Random generation</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_generate_random"><code class="docutils literal notranslate"><span class="pre">psa_generate_random</span></code> (function)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_generate_key"><code class="docutils literal notranslate"><span class="pre">psa_generate_key</span></code> (function)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#error-codes">Error codes</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_status_t"><code class="docutils literal notranslate"><span class="pre">psa_status_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_SUCCESS"><code class="docutils literal notranslate"><span class="pre">PSA_SUCCESS</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ERROR_GENERIC_ERROR"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_GENERIC_ERROR</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ERROR_NOT_SUPPORTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_SUPPORTED</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ERROR_NOT_PERMITTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_NOT_PERMITTED</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ERROR_BUFFER_TOO_SMALL"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BUFFER_TOO_SMALL</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ERROR_ALREADY_EXISTS"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_ALREADY_EXISTS</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ERROR_DOES_NOT_EXIST"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_DOES_NOT_EXIST</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ERROR_BAD_STATE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_BAD_STATE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ERROR_INVALID_ARGUMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_ARGUMENT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ERROR_INSUFFICIENT_MEMORY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_MEMORY</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ERROR_INSUFFICIENT_STORAGE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_STORAGE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ERROR_COMMUNICATION_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_COMMUNICATION_FAILURE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ERROR_STORAGE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_STORAGE_FAILURE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ERROR_HARDWARE_FAILURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_HARDWARE_FAILURE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ERROR_CORRUPTION_DETECTED"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ERROR_INSUFFICIENT_ENTROPY"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_ENTROPY</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ERROR_INVALID_SIGNATURE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_SIGNATURE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ERROR_INVALID_PADDING"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_PADDING</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ERROR_INSUFFICIENT_DATA"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_DATA</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ERROR_INVALID_HANDLE"><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INVALID_HANDLE</span></code> (macro)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-and-algorithm-types">Key and algorithm types</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_key_type_t"><code class="docutils literal notranslate"><span class="pre">psa_key_type_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_ecc_curve_t"><code class="docutils literal notranslate"><span class="pre">psa_ecc_curve_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_dh_group_t"><code class="docutils literal notranslate"><span class="pre">psa_dh_group_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_algorithm_t"><code class="docutils literal notranslate"><span class="pre">psa_algorithm_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_NONE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_NONE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_VENDOR_FLAG"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_VENDOR_FLAG</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_CATEGORY_MASK"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_CATEGORY_MASK</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_CATEGORY_SYMMETRIC"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_CATEGORY_SYMMETRIC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_CATEGORY_RAW"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_CATEGORY_RAW</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_CATEGORY_KEY_PAIR"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_CATEGORY_KEY_PAIR</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_CATEGORY_FLAG_PAIR"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_CATEGORY_FLAG_PAIR</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_IS_VENDOR_DEFINED"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_VENDOR_DEFINED</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_IS_UNSTRUCTURED"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_UNSTRUCTURED</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_IS_ASYMMETRIC"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_ASYMMETRIC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_IS_PUBLIC_KEY"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_PUBLIC_KEY</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_IS_KEY_PAIR"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_KEY_PAIR</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_KEY_PAIR_OF_PUBLIC_KEY"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_KEY_PAIR_OF_PUBLIC_KEY</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_RAW_DATA"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_RAW_DATA</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_HMAC"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_HMAC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_DERIVE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_DERIVE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_AES"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_AES</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_DES"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_DES</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_CAMELLIA"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_CAMELLIA</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_ARC4"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_ARC4</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_CHACHA20"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_CHACHA20</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_RSA_PUBLIC_KEY"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_RSA_PUBLIC_KEY</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_RSA_KEY_PAIR"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_RSA_KEY_PAIR</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_IS_RSA"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_RSA</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_ECC_KEY_PAIR_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_ECC_KEY_PAIR_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_ECC_CURVE_MASK"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_ECC_CURVE_MASK</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_ECC_KEY_PAIR"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_ECC_KEY_PAIR</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_ECC_PUBLIC_KEY"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_ECC_PUBLIC_KEY</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_IS_ECC"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_ECC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_IS_ECC_KEY_PAIR"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_ECC_KEY_PAIR</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_GET_CURVE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_GET_CURVE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_SECT163K1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT163K1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_SECT163R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT163R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_SECT163R2"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT163R2</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_SECT193R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT193R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_SECT193R2"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT193R2</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_SECT233K1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT233K1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_SECT233R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT233R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_SECT239K1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT239K1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_SECT283K1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT283K1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_SECT283R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT283R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_SECT409K1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT409K1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_SECT409R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT409R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_SECT571K1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT571K1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_SECT571R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECT571R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_SECP160K1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP160K1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_SECP160R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP160R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_SECP160R2"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP160R2</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_SECP192K1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP192K1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_SECP192R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP192R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_SECP224K1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP224K1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_SECP224R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP224R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_SECP256K1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP256K1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_SECP256R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP256R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_SECP384R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP384R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_SECP521R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_SECP521R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_BRAINPOOL_P256R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_BRAINPOOL_P256R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_BRAINPOOL_P384R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_BRAINPOOL_P384R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_BRAINPOOL_P512R1"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_BRAINPOOL_P512R1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_CURVE25519"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_CURVE25519</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_CURVE448"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_CURVE448</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_DH_PUBLIC_KEY_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_DH_PUBLIC_KEY_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_DH_KEY_PAIR_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_DH_KEY_PAIR_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_DH_GROUP_MASK"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_DH_GROUP_MASK</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_DH_KEY_PAIR"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_DH_KEY_PAIR</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_DH_PUBLIC_KEY"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_DH_PUBLIC_KEY</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_IS_DH"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_DH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_IS_DH_KEY_PAIR"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_DH_KEY_PAIR</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_IS_DH_PUBLIC_KEY"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_IS_DH_PUBLIC_KEY</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_TYPE_GET_GROUP"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_TYPE_GET_GROUP</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_DH_GROUP_FFDHE2048"><code class="docutils literal notranslate"><span class="pre">PSA_DH_GROUP_FFDHE2048</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_DH_GROUP_FFDHE3072"><code class="docutils literal notranslate"><span class="pre">PSA_DH_GROUP_FFDHE3072</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_DH_GROUP_FFDHE4096"><code class="docutils literal notranslate"><span class="pre">PSA_DH_GROUP_FFDHE4096</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_DH_GROUP_FFDHE6144"><code class="docutils literal notranslate"><span class="pre">PSA_DH_GROUP_FFDHE6144</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_DH_GROUP_FFDHE8192"><code class="docutils literal notranslate"><span class="pre">PSA_DH_GROUP_FFDHE8192</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_BLOCK_CIPHER_BLOCK_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_BLOCK_CIPHER_BLOCK_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_VENDOR_FLAG"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_VENDOR_FLAG</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_CATEGORY_MASK"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CATEGORY_MASK</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_CATEGORY_HASH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CATEGORY_HASH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_CATEGORY_MAC"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CATEGORY_MAC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_CATEGORY_CIPHER"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CATEGORY_CIPHER</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_CATEGORY_AEAD"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CATEGORY_AEAD</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_CATEGORY_SIGN"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CATEGORY_SIGN</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_CATEGORY_KEY_DERIVATION"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CATEGORY_KEY_DERIVATION</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_CATEGORY_KEY_AGREEMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CATEGORY_KEY_AGREEMENT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_IS_VENDOR_DEFINED"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_VENDOR_DEFINED</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_IS_HASH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_HASH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_IS_MAC"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_MAC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_IS_CIPHER"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_CIPHER</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_IS_AEAD"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_AEAD</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_IS_SIGN"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_SIGN</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_IS_ASYMMETRIC_ENCRYPTION"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_ASYMMETRIC_ENCRYPTION</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_IS_KEY_AGREEMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_KEY_AGREEMENT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_IS_KEY_DERIVATION"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_KEY_DERIVATION</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_HASH_MASK"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_HASH_MASK</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_MD2"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_MD2</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_MD4"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_MD4</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_MD5"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_MD5</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_RIPEMD160"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RIPEMD160</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_SHA_1"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA_1</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_SHA_224"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA_224</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_SHA_256"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA_256</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_SHA_384"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA_384</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_SHA_512"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA_512</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_SHA_512_224"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA_512_224</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_SHA_512_256"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA_512_256</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_SHA3_224"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA3_224</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_SHA3_256"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA3_256</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_SHA3_384"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA3_384</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_SHA3_512"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SHA3_512</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_ANY_HASH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_ANY_HASH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_MAC_SUBCATEGORY_MASK"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_MAC_SUBCATEGORY_MASK</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_HMAC_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_HMAC_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_HMAC"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_HMAC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_HMAC_GET_HASH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_HMAC_GET_HASH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_IS_HMAC"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_HMAC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_MAC_TRUNCATION_MASK"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_MAC_TRUNCATION_MASK</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_MAC_TRUNCATION_OFFSET"><code class="docutils literal notranslate"><span class="pre">PSA_MAC_TRUNCATION_OFFSET</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_TRUNCATED_MAC"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_TRUNCATED_MAC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_FULL_LENGTH_MAC"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_FULL_LENGTH_MAC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_MAC_TRUNCATED_LENGTH"><code class="docutils literal notranslate"><span class="pre">PSA_MAC_TRUNCATED_LENGTH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_CIPHER_MAC_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CIPHER_MAC_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_CBC_MAC"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CBC_MAC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_CMAC"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CMAC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_GMAC"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_GMAC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_IS_BLOCK_CIPHER_MAC"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_BLOCK_CIPHER_MAC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_CIPHER_STREAM_FLAG"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CIPHER_STREAM_FLAG</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_CIPHER_FROM_BLOCK_FLAG"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CIPHER_FROM_BLOCK_FLAG</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_IS_STREAM_CIPHER"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_STREAM_CIPHER</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_ARC4"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_ARC4</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_CHACHA20"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CHACHA20</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_CTR"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CTR</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_CFB"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CFB</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_OFB"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_OFB</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_XTS"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_XTS</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_CBC_NO_PADDING"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CBC_NO_PADDING</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_CBC_PKCS7"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CBC_PKCS7</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_AEAD_FROM_BLOCK_FLAG"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_AEAD_FROM_BLOCK_FLAG</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_IS_AEAD_ON_BLOCK_CIPHER"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_AEAD_ON_BLOCK_CIPHER</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_CCM"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CCM</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_GCM"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_GCM</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_CHACHA20_POLY1305"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_CHACHA20_POLY1305</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_AEAD_TAG_LENGTH_MASK"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_AEAD_TAG_LENGTH_MASK</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_AEAD_TAG_LENGTH_OFFSET"><code class="docutils literal notranslate"><span class="pre">PSA_AEAD_TAG_LENGTH_OFFSET</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_AEAD_WITH_TAG_LENGTH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_AEAD_WITH_TAG_LENGTH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_AEAD_WITH_DEFAULT_TAG_LENGTH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_AEAD_WITH_DEFAULT_TAG_LENGTH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE"><code class="docutils literal notranslate"><span class="pre">PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_RSA_PKCS1V15_SIGN_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RSA_PKCS1V15_SIGN_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_RSA_PKCS1V15_SIGN"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RSA_PKCS1V15_SIGN</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_RSA_PKCS1V15_SIGN_RAW"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RSA_PKCS1V15_SIGN_RAW</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_IS_RSA_PKCS1V15_SIGN"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_RSA_PKCS1V15_SIGN</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_RSA_PSS_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RSA_PSS_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_RSA_PSS"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RSA_PSS</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_IS_RSA_PSS"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_RSA_PSS</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_ECDSA_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_ECDSA_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_ECDSA"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_ECDSA</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_ECDSA_ANY"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_ECDSA_ANY</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_DETERMINISTIC_ECDSA_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_DETERMINISTIC_ECDSA_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_DETERMINISTIC_ECDSA"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_DETERMINISTIC_ECDSA</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_IS_ECDSA"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_ECDSA</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_ECDSA_IS_DETERMINISTIC"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_ECDSA_IS_DETERMINISTIC</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_IS_DETERMINISTIC_ECDSA"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_DETERMINISTIC_ECDSA</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_IS_RANDOMIZED_ECDSA"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_RANDOMIZED_ECDSA</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_IS_HASH_AND_SIGN"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_HASH_AND_SIGN</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_SIGN_GET_HASH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_SIGN_GET_HASH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_RSA_PKCS1V15_CRYPT"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RSA_PKCS1V15_CRYPT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_RSA_OAEP_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RSA_OAEP_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_RSA_OAEP"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RSA_OAEP</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_IS_RSA_OAEP"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_RSA_OAEP</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_RSA_OAEP_GET_HASH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_RSA_OAEP_GET_HASH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_HKDF_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_HKDF_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_HKDF"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_HKDF</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_IS_HKDF"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_HKDF</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_HKDF_GET_HASH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_HKDF_GET_HASH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_TLS12_PRF_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_TLS12_PRF_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_TLS12_PRF"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_TLS12_PRF</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_IS_TLS12_PRF"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_TLS12_PRF</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_TLS12_PRF_GET_HASH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_TLS12_PRF_GET_HASH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_TLS12_PSK_TO_MS_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_TLS12_PSK_TO_MS_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_TLS12_PSK_TO_MS"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_TLS12_PSK_TO_MS</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_IS_TLS12_PSK_TO_MS"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_TLS12_PSK_TO_MS</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_TLS12_PSK_TO_MS_GET_HASH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_TLS12_PSK_TO_MS_GET_HASH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_KEY_DERIVATION_MASK"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_KEY_DERIVATION_MASK</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_KEY_AGREEMENT_MASK"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_KEY_AGREEMENT_MASK</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_KEY_AGREEMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_KEY_AGREEMENT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_KEY_AGREEMENT_GET_KDF"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_KEY_AGREEMENT_GET_KDF</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_KEY_AGREEMENT_GET_BASE"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_KEY_AGREEMENT_GET_BASE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_IS_RAW_KEY_AGREEMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_RAW_KEY_AGREEMENT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_IS_KEY_DERIVATION_OR_AGREEMENT"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_KEY_DERIVATION_OR_AGREEMENT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_FFDH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_FFDH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_IS_FFDH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_FFDH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_ECDH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_ECDH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_IS_ECDH"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_ECDH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_IS_WILDCARD"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_WILDCARD</span></code> (macro)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-lifetimes">Key lifetimes</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_key_lifetime_t"><code class="docutils literal notranslate"><span class="pre">psa_key_lifetime_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_key_id_t"><code class="docutils literal notranslate"><span class="pre">psa_key_id_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_LIFETIME_VOLATILE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_LIFETIME_VOLATILE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_LIFETIME_PERSISTENT"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_LIFETIME_PERSISTENT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_ID_USER_MIN"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_ID_USER_MIN</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_ID_USER_MAX"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_ID_USER_MAX</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_ID_VENDOR_MIN"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_ID_VENDOR_MIN</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_ID_VENDOR_MAX"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_ID_VENDOR_MAX</span></code> (macro)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-policies">Key policies</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_key_usage_t"><code class="docutils literal notranslate"><span class="pre">psa_key_usage_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_USAGE_EXPORT"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_EXPORT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_USAGE_COPY"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_COPY</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_USAGE_ENCRYPT"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_ENCRYPT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_USAGE_DECRYPT"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_DECRYPT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_USAGE_SIGN"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_SIGN</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_USAGE_VERIFY"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_VERIFY</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_USAGE_DERIVE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_USAGE_DERIVE</span></code> (macro)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-derivation">Key derivation</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#psa_key_derivation_step_t"><code class="docutils literal notranslate"><span class="pre">psa_key_derivation_step_t</span></code> (type)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_DERIVATION_INPUT_SECRET"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_SECRET</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_DERIVATION_INPUT_LABEL"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_LABEL</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_DERIVATION_INPUT_SALT"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_SALT</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_DERIVATION_INPUT_INFO"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_INFO</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_DERIVATION_INPUT_SEED"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_SEED</span></code> (macro)</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#other-definitions">Other definitions</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_BITS_TO_BYTES"><code class="docutils literal notranslate"><span class="pre">PSA_BITS_TO_BYTES</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_BYTES_TO_BITS"><code class="docutils literal notranslate"><span class="pre">PSA_BYTES_TO_BITS</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ROUND_UP_TO_MULTIPLE"><code class="docutils literal notranslate"><span class="pre">PSA_ROUND_UP_TO_MULTIPLE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_HASH_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_HASH_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_HASH_MAX_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_HASH_MAX_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_HMAC_MAX_HASH_BLOCK_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_HMAC_MAX_HASH_BLOCK_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_MAC_MAX_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_MAC_MAX_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_AEAD_TAG_LENGTH"><code class="docutils literal notranslate"><span class="pre">PSA_AEAD_TAG_LENGTH</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_VENDOR_RSA_MAX_KEY_BITS"><code class="docutils literal notranslate"><span class="pre">PSA_VENDOR_RSA_MAX_KEY_BITS</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_VENDOR_ECC_MAX_CURVE_BITS"><code class="docutils literal notranslate"><span class="pre">PSA_VENDOR_ECC_MAX_CURVE_BITS</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECC_CURVE_BITS"><code class="docutils literal notranslate"><span class="pre">PSA_ECC_CURVE_BITS</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ALG_TLS12_PSK_TO_MS_MAX_PSK_LEN"><code class="docutils literal notranslate"><span class="pre">PSA_ALG_TLS12_PSK_TO_MS_MAX_PSK_LEN</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ASYMMETRIC_SIGNATURE_MAX_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_ASYMMETRIC_SIGNATURE_MAX_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_MAX_BLOCK_CIPHER_BLOCK_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_MAX_BLOCK_CIPHER_BLOCK_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_MAC_FINAL_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_MAC_FINAL_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_AEAD_ENCRYPT_OUTPUT_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_AEAD_ENCRYPT_OUTPUT_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_AEAD_DECRYPT_OUTPUT_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_AEAD_DECRYPT_OUTPUT_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_AEAD_UPDATE_OUTPUT_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_AEAD_UPDATE_OUTPUT_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_AEAD_FINISH_OUTPUT_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_AEAD_FINISH_OUTPUT_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_AEAD_VERIFY_OUTPUT_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_AEAD_VERIFY_OUTPUT_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_RSA_MINIMUM_PADDING_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_RSA_MINIMUM_PADDING_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ECDSA_SIGNATURE_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_ECDSA_SIGNATURE_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_EXPORT_RSA_PUBLIC_KEY_MAX_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_EXPORT_RSA_PUBLIC_KEY_MAX_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_EXPORT_RSA_KEY_PAIR_MAX_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_EXPORT_RSA_KEY_PAIR_MAX_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_EXPORT_DSA_PUBLIC_KEY_MAX_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_EXPORT_DSA_PUBLIC_KEY_MAX_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_EXPORT_DSA_KEY_PAIR_MAX_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_EXPORT_DSA_KEY_PAIR_MAX_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_EXPORT_ECC_KEY_PAIR_MAX_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_EXPORT_ECC_KEY_PAIR_MAX_SIZE</span></code> (macro)</a></li>
+<li class="toctree-l2"><a class="reference internal" href="from_doxygen.html#PSA_KEY_EXPORT_MAX_SIZE"><code class="docutils literal notranslate"><span class="pre">PSA_KEY_EXPORT_MAX_SIZE</span></code> (macro)</a></li>
+</ul>
+</li>
+</ul>
+</div>
+<div class="section" id="document-history">
+<h2>Document history</h2>
+<table border="1" class="docutils">
+<colgroup>
+<col width="11%" />
+<col width="89%" />
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">Date</th>
+<th class="head">Changes</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>2019-01-21</td>
+<td><em>Release 1.0 beta 1</em></td>
+</tr>
+<tr class="row-odd"><td>2019-02-08</td>
+<td><ul class="first last simple">
+<li>Remove obsolete definition <code class="docutils literal notranslate"><span class="pre">PSA_ALG_IS_KEY_SELECTION</span></code>.</li>
+<li><code class="docutils literal notranslate"><span class="pre">psa_key_agreement</span></code>: document <code class="docutils literal notranslate"><span class="pre">alg</span></code> parameter.</li>
+<li><a class="reference internal" href="from_doxygen.html#c.PSA_AEAD_FINISH_OUTPUT_SIZE" title="PSA_AEAD_FINISH_OUTPUT_SIZE"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_AEAD_FINISH_OUTPUT_SIZE</span></code></a>: remove spurious parameter <code class="docutils literal notranslate"><span class="pre">plaintext_length</span></code>.</li>
+</ul>
+</td>
+</tr>
+<tr class="row-even"><td>2019-02-08</td>
+<td>Document formatting improvements</td>
+</tr>
+<tr class="row-odd"><td>2019-02-22</td>
+<td><em>Release 1.0 beta 2</em></td>
+</tr>
+<tr class="row-even"><td>2019-03-12</td>
+<td><ul class="first last simple">
+<li>Specify <code class="docutils literal notranslate"><span class="pre">psa_generator_import_key</span></code> for most key types.</li>
+</ul>
+</td>
+</tr>
+<tr class="row-odd"><td>2019-04-09</td>
+<td><p class="first">Change the value of error codes, and some names, to align
+with other PSA specifications. The name changes are:</p>
+<ul class="last simple">
+<li><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_UNKNOWN_ERROR</span></code> → <a class="reference internal" href="from_doxygen.html#c.PSA_ERROR_GENERIC_ERROR" title="PSA_ERROR_GENERIC_ERROR"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ERROR_GENERIC_ERROR</span></code></a></li>
+<li><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_OCCUPIED_SLOT</span></code> → <a class="reference internal" href="from_doxygen.html#c.PSA_ERROR_ALREADY_EXISTS" title="PSA_ERROR_ALREADY_EXISTS"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ERROR_ALREADY_EXISTS</span></code></a></li>
+<li><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_EMPTY_SLOT</span></code> → <a class="reference internal" href="from_doxygen.html#c.PSA_ERROR_DOES_NOT_EXIST" title="PSA_ERROR_DOES_NOT_EXIST"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ERROR_DOES_NOT_EXIST</span></code></a></li>
+<li><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_CAPACITY</span></code> → <a class="reference internal" href="from_doxygen.html#c.PSA_ERROR_INSUFFICIENT_DATA" title="PSA_ERROR_INSUFFICIENT_DATA"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ERROR_INSUFFICIENT_DATA</span></code></a></li>
+<li><code class="docutils literal notranslate"><span class="pre">PSA_ERROR_TAMPERING_DETECTED</span></code> → <a class="reference internal" href="from_doxygen.html#c.PSA_ERROR_CORRUPTION_DETECTED" title="PSA_ERROR_CORRUPTION_DETECTED"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_ERROR_CORRUPTION_DETECTED</span></code></a></li>
+</ul>
+</td>
+</tr>
+<tr class="row-even"><td>2019-05-02</td>
+<td><p class="first">Change the way keys are created to avoid “half-filled” handles
+that contained key metadata, but no key material.
+Now, to create a key, first fill in a data structure containing
+its attributes, then pass this structure to a function that
+both allocates resources for the key and fills in the key
+material. This affects the following functions:</p>
+<ul class="last simple">
+<li><a class="reference internal" href="from_doxygen.html#c.psa_import_key" title="psa_import_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_import_key</span></code></a>, <a class="reference internal" href="from_doxygen.html#c.psa_generate_key" title="psa_generate_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_generate_key</span></code></a>, <code class="docutils literal notranslate"><span class="pre">psa_generator_import_key</span></code>
+and <a class="reference internal" href="from_doxygen.html#c.psa_copy_key" title="psa_copy_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_copy_key</span></code></a> now take an attribute structure (specifically,
+a pointer to <a class="reference internal" href="from_doxygen.html#c.psa_key_attributes_t" title="psa_key_attributes_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_key_attributes_t</span></code></a>) to specify key metadata.
+This replaces the previous method of passing arguments to
+<code class="docutils literal notranslate"><span class="pre">psa_create_key</span></code> or to the key material creation function
+or calling <code class="docutils literal notranslate"><span class="pre">psa_set_key_policy</span></code>.</li>
+<li><code class="docutils literal notranslate"><span class="pre">psa_key_policy_t</span></code> and functions operating on that type
+no longer exist. A key’s policy is now accessible as part of
+its attributes.</li>
+<li><code class="docutils literal notranslate"><span class="pre">psa_get_key_information</span></code> is also replaced by accessing the
+key’s attributes (retrieved with <a class="reference internal" href="from_doxygen.html#c.psa_get_key_attributes" title="psa_get_key_attributes"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_get_key_attributes</span></code></a>).</li>
+<li><code class="docutils literal notranslate"><span class="pre">psa_create_key</span></code> no longer exists. Instead, set the key id
+attribute and the lifetime attribute before creating the
+key material.</li>
+</ul>
+</td>
+</tr>
+<tr class="row-odd"><td>2019-05-14</td>
+<td><ul class="first last simple">
+<li>Allow <a class="reference internal" href="from_doxygen.html#c.psa_aead_update" title="psa_aead_update"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_aead_update</span></code></a> to buffer data.</li>
+<li>New buffer size calculation macros.</li>
+</ul>
+</td>
+</tr>
+<tr class="row-even"><td>2019-05-16</td>
+<td><ul class="first last simple">
+<li>Key identifiers are no longer specific to a given lifetime
+value. <a class="reference internal" href="from_doxygen.html#c.psa_open_key" title="psa_open_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_open_key</span></code></a> no longer takes a <code class="docutils literal notranslate"><span class="pre">lifetime</span></code> parameter.</li>
+<li>Define a range of key identifiers for use by applications
+and a separate range for use by implementations.</li>
+</ul>
+</td>
+</tr>
+<tr class="row-odd"><td>2019-05-16</td>
+<td><p class="first">Avoid the unusual terminology “generator”: call them
+“key derivation operations” instead. Rename a number of functions
+and other identifiers related to for clarity and consistency:</p>
+<ul class="last simple">
+<li><code class="docutils literal notranslate"><span class="pre">psa_crypto_generator_t</span></code> → <a class="reference internal" href="from_doxygen.html#c.psa_key_derivation_operation_t" title="psa_key_derivation_operation_t"><code class="xref any c c-type docutils literal notranslate"><span class="pre">psa_key_derivation_operation_t</span></code></a></li>
+<li><code class="docutils literal notranslate"><span class="pre">PSA_CRYPTO_GENERATOR_INIT</span></code> → <a class="reference internal" href="from_doxygen.html#c.PSA_KEY_DERIVATION_OPERATION_INIT" title="PSA_KEY_DERIVATION_OPERATION_INIT"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_OPERATION_INIT</span></code></a></li>
+<li><code class="docutils literal notranslate"><span class="pre">psa_crypto_generator_init</span></code> → <a class="reference internal" href="from_doxygen.html#c.psa_key_derivation_operation_init" title="psa_key_derivation_operation_init"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_derivation_operation_init</span></code></a></li>
+<li><code class="docutils literal notranslate"><span class="pre">PSA_GENERATOR_UNBRIDLED_CAPACITY</span></code> → <a class="reference internal" href="from_doxygen.html#c.PSA_KEY_DERIVATION_UNLIMITED_CAPACITY" title="PSA_KEY_DERIVATION_UNLIMITED_CAPACITY"><code class="xref any c c-macro docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_UNLIMITED_CAPACITY</span></code></a></li>
+<li><code class="docutils literal notranslate"><span class="pre">psa_set_generator_capacity</span></code> → <a class="reference internal" href="from_doxygen.html#c.psa_key_derivation_set_capacity" title="psa_key_derivation_set_capacity"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_derivation_set_capacity</span></code></a></li>
+<li><code class="docutils literal notranslate"><span class="pre">psa_get_generator_capacity</span></code> → <a class="reference internal" href="from_doxygen.html#c.psa_key_derivation_get_capacity" title="psa_key_derivation_get_capacity"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_derivation_get_capacity</span></code></a></li>
+<li><code class="docutils literal notranslate"><span class="pre">psa_key_agreement</span></code> → <a class="reference internal" href="from_doxygen.html#c.psa_key_derivation_key_agreement" title="psa_key_derivation_key_agreement"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_derivation_key_agreement</span></code></a></li>
+<li><code class="docutils literal notranslate"><span class="pre">psa_generator_read</span></code> → <a class="reference internal" href="from_doxygen.html#c.psa_key_derivation_output_bytes" title="psa_key_derivation_output_bytes"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_derivation_output_bytes</span></code></a></li>
+<li><code class="docutils literal notranslate"><span class="pre">psa_generate_derived_key</span></code> → <a class="reference internal" href="from_doxygen.html#c.psa_key_derivation_output_key" title="psa_key_derivation_output_key"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_derivation_output_key</span></code></a></li>
+<li><code class="docutils literal notranslate"><span class="pre">psa_generator_abort</span></code> → <a class="reference internal" href="from_doxygen.html#c.psa_key_derivation_abort" title="psa_key_derivation_abort"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_key_derivation_abort</span></code></a></li>
+<li><code class="docutils literal notranslate"><span class="pre">psa_key_agreement_raw_shared_secret</span></code> → <a class="reference internal" href="from_doxygen.html#c.psa_raw_key_agreement" title="psa_raw_key_agreement"><code class="xref any c c-func docutils literal notranslate"><span class="pre">psa_raw_key_agreement</span></code></a></li>
+<li><code class="docutils literal notranslate"><span class="pre">PSA_KDF_STEP_xxx</span></code> → <code class="docutils literal notranslate"><span class="pre">PSA_KEY_DERIVATION_INPUT_xxx</span></code></li>
+<li><code class="docutils literal notranslate"><span class="pre">PSA_xxx_KEYPAIR</span></code> → <code class="docutils literal notranslate"><span class="pre">PSA_xxx_KEY_PAIR</span></code></li>
+</ul>
+</td>
+</tr>
+<tr class="row-even"><td>2019-05-16</td>
+<td><ul class="first last simple">
+<li>Clarify the behavior in various corner cases.</li>
+<li>Document more error conditions.</li>
+</ul>
+</td>
+</tr>
+<tr class="row-odd"><td>2019-05-20</td>
+<td><em>Release 1.0 beta 3</em></td>
+</tr>
+</tbody>
</table>
</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li class="current"><a href="index.html"><span>Main Page</span></a></li>
- <li><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
+<div class="section" id="planned-changes-for-version-1-0">
+<h2>Planned changes for version 1.0</h2>
+<p>Here is a summary of the changes we are currently planning to make to
+this specification for version 1.0.</p>
+<ul class="simple">
+<li>Add missing macros to calculate output buffer sizes, IV/nonce sizes,
+and maximum supported data sizes.</li>
+<li>Remove the definition of most macros, to give implementations free
+choice regarding how these macros are implemented, as long as the
+implementation meets the English-language specification.</li>
+<li>Remove certain auxiliary macros that are not directly useful to
+applications, but are currently used as building blocks to define
+other macros.</li>
+<li>Correct lists of documented error codes for several functions, and
+clarify error conditions for many functions.</li>
+<li>Constrain whether and when an application may have the same persistent key
+open multiple times.</li>
+<li>Constrain the permitted implementation behavior when calling a function on
+an operation object in a state where this function does not make sense,
+and when a key is destroyed while in use.</li>
+<li>Declare identifiers for additional cryptographic algorithms.</li>
+<li>Forbid zero-length keys.</li>
+<li>Use a standard import/export format for EC keys on Montgomery curves.</li>
+<li>Mandate certain checks when importing some types of asymmetric keys.</li>
+<li>Clarifications and improvements to the description of some API elements
+and to the structure of the document.</li>
+</ul>
+<h2 id="indices">Indices</h2>
+
+<ul>
+ <li><a class="reference internal" href="genindex.html">General index</a></li>
+ <li><a class="reference internal" href="psa_c-identifiers.html">Index of identifiers</a></li>
+ <li><a class="reference internal" href="search.html">Search</a></li>
+</ul></div>
+</div>
+
+
+ </div>
+
</div>
- </li>
- </ul>
- </div>
-</div><!-- top -->
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
+ </div>
+ <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
+ <div class="sphinxsidebarwrapper">
+<h1 class="logo"><a href="#">psa_crypto_api</a></h1>
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-<div class="header">
- <div class="headertitle">
-<div class="title">Platform Security Architecture — cryptography and keystore interface Documentation</div> </div>
-</div><!--header-->
-<div class="contents">
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
+
+
+
+
+
+
+<h3>Navigation</h3>
+<ul>
+<li class="toctree-l1"><a class="reference internal" href="general.html">Introduction</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#design-goals">Design goals</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#functionality-overview">Functionality overview</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#sample-architectures">Sample architectures</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#library-conventions">Library conventions</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#implementation-considerations">Implementation considerations</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#usage-considerations">Usage considerations</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html">Implementation-specific definitions</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#library-initialization">Library initialization</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-attributes">Key attributes</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-management">Key management</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-import-and-export">Key import and export</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#message-digests">Message digests</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#message-authentication-codes">Message authentication codes</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#symmetric-ciphers">Symmetric ciphers</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#authenticated-encryption-with-associated-data-aead">Authenticated encryption with associated data (AEAD)</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#asymmetric-cryptography">Asymmetric cryptography</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-derivation-and-pseudorandom-generation">Key derivation and pseudorandom generation</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#random-generation">Random generation</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#error-codes">Error codes</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-and-algorithm-types">Key and algorithm types</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-lifetimes">Key lifetimes</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-policies">Key policies</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-derivation">Key derivation</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#other-definitions">Other definitions</a></li>
+</ul>
+
+<div class="relations">
+<h3>Related Topics</h3>
+<ul>
+ <li><a href="#">Documentation overview</a><ul>
+ <li>Next: <a href="general.html" title="next chapter">Introduction</a></li>
+ </ul></li>
+</ul>
+</div>
+<div id="searchbox" style="display: none" role="search">
+ <h3>Quick search</h3>
+ <div class="searchformwrapper">
+ <form class="search" action="search.html" method="get">
+ <input type="text" name="q" />
+ <input type="submit" value="Go" />
+ <input type="hidden" name="check_keywords" value="yes" />
+ <input type="hidden" name="area" value="default" />
+ </form>
+ </div>
+</div>
+<script type="text/javascript">$('#searchbox').show(0);</script>
+
+
+
+
+
+
+
+
+ </div>
+ </div>
+ <div class="clearer"></div>
+ </div>
+ <div class="footer">
+ ©2019, Arm.
+
+ |
+ Powered by <a href="http://sphinx-doc.org/">Sphinx 1.8.5</a>
+ & <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
+
+ |
+ <a href="_sources/index.rst.txt"
+ rel="nofollow">Page source</a>
+ </div>
+
+
+
+
+ </body>
+</html>
\ No newline at end of file
diff --git a/docs/html/jquery.js b/docs/html/jquery.js
deleted file mode 100644
index d52a1c7..0000000
--- a/docs/html/jquery.js
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * jQuery JavaScript Library v1.7.1
- * http://jquery.com/
- *
- * Copyright 2011, John Resig
- * Dual licensed under the MIT or GPL Version 2 licenses.
- * http://jquery.org/license
- *
- * Includes Sizzle.js
- * http://sizzlejs.com/
- * Copyright 2011, The Dojo Foundation
- * Released under the MIT, BSD, and GPL Licenses.
- *
- * Date: Mon Nov 21 21:11:03 2011 -0500
- */
-(function(bb,L){var av=bb.document,bu=bb.navigator,bl=bb.location;var b=(function(){var bF=function(b0,b1){return new bF.fn.init(b0,b1,bD)},bU=bb.jQuery,bH=bb.$,bD,bY=/^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,bM=/\S/,bI=/^\s+/,bE=/\s+$/,bA=/^<(\w+)\s*\/?>(?:<\/\1>)?$/,bN=/^[\],:{}\s]*$/,bW=/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,bP=/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,bJ=/(?:^|:|,)(?:\s*\[)+/g,by=/(webkit)[ \/]([\w.]+)/,bR=/(opera)(?:.*version)?[ \/]([\w.]+)/,bQ=/(msie) ([\w.]+)/,bS=/(mozilla)(?:.*? rv:([\w.]+))?/,bB=/-([a-z]|[0-9])/ig,bZ=/^-ms-/,bT=function(b0,b1){return(b1+"").toUpperCase()},bX=bu.userAgent,bV,bC,e,bL=Object.prototype.toString,bG=Object.prototype.hasOwnProperty,bz=Array.prototype.push,bK=Array.prototype.slice,bO=String.prototype.trim,bv=Array.prototype.indexOf,bx={};bF.fn=bF.prototype={constructor:bF,init:function(b0,b4,b3){var b2,b5,b1,b6;if(!b0){return this}if(b0.nodeType){this.context=this[0]=b0;this.length=1;return this}if(b0==="body"&&!b4&&av.body){this.context=av;this[0]=av.body;this.selector=b0;this.length=1;return this}if(typeof b0==="string"){if(b0.charAt(0)==="<"&&b0.charAt(b0.length-1)===">"&&b0.length>=3){b2=[null,b0,null]}else{b2=bY.exec(b0)}if(b2&&(b2[1]||!b4)){if(b2[1]){b4=b4 instanceof bF?b4[0]:b4;b6=(b4?b4.ownerDocument||b4:av);b1=bA.exec(b0);if(b1){if(bF.isPlainObject(b4)){b0=[av.createElement(b1[1])];bF.fn.attr.call(b0,b4,true)}else{b0=[b6.createElement(b1[1])]}}else{b1=bF.buildFragment([b2[1]],[b6]);b0=(b1.cacheable?bF.clone(b1.fragment):b1.fragment).childNodes}return bF.merge(this,b0)}else{b5=av.getElementById(b2[2]);if(b5&&b5.parentNode){if(b5.id!==b2[2]){return b3.find(b0)}this.length=1;this[0]=b5}this.context=av;this.selector=b0;return this}}else{if(!b4||b4.jquery){return(b4||b3).find(b0)}else{return this.constructor(b4).find(b0)}}}else{if(bF.isFunction(b0)){return b3.ready(b0)}}if(b0.selector!==L){this.selector=b0.selector;this.context=b0.context}return bF.makeArray(b0,this)},selector:"",jquery:"1.7.1",length:0,size:function(){return this.length},toArray:function(){return bK.call(this,0)},get:function(b0){return b0==null?this.toArray():(b0<0?this[this.length+b0]:this[b0])},pushStack:function(b1,b3,b0){var b2=this.constructor();if(bF.isArray(b1)){bz.apply(b2,b1)}else{bF.merge(b2,b1)}b2.prevObject=this;b2.context=this.context;if(b3==="find"){b2.selector=this.selector+(this.selector?" ":"")+b0}else{if(b3){b2.selector=this.selector+"."+b3+"("+b0+")"}}return b2},each:function(b1,b0){return bF.each(this,b1,b0)},ready:function(b0){bF.bindReady();bC.add(b0);return this},eq:function(b0){b0=+b0;return b0===-1?this.slice(b0):this.slice(b0,b0+1)},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},slice:function(){return this.pushStack(bK.apply(this,arguments),"slice",bK.call(arguments).join(","))},map:function(b0){return this.pushStack(bF.map(this,function(b2,b1){return b0.call(b2,b1,b2)}))},end:function(){return this.prevObject||this.constructor(null)},push:bz,sort:[].sort,splice:[].splice};bF.fn.init.prototype=bF.fn;bF.extend=bF.fn.extend=function(){var b9,b2,b0,b1,b6,b7,b5=arguments[0]||{},b4=1,b3=arguments.length,b8=false;if(typeof b5==="boolean"){b8=b5;b5=arguments[1]||{};b4=2}if(typeof b5!=="object"&&!bF.isFunction(b5)){b5={}}if(b3===b4){b5=this;--b4}for(;b4<b3;b4++){if((b9=arguments[b4])!=null){for(b2 in b9){b0=b5[b2];b1=b9[b2];if(b5===b1){continue}if(b8&&b1&&(bF.isPlainObject(b1)||(b6=bF.isArray(b1)))){if(b6){b6=false;b7=b0&&bF.isArray(b0)?b0:[]}else{b7=b0&&bF.isPlainObject(b0)?b0:{}}b5[b2]=bF.extend(b8,b7,b1)}else{if(b1!==L){b5[b2]=b1}}}}}return b5};bF.extend({noConflict:function(b0){if(bb.$===bF){bb.$=bH}if(b0&&bb.jQuery===bF){bb.jQuery=bU}return bF},isReady:false,readyWait:1,holdReady:function(b0){if(b0){bF.readyWait++}else{bF.ready(true)}},ready:function(b0){if((b0===true&&!--bF.readyWait)||(b0!==true&&!bF.isReady)){if(!av.body){return setTimeout(bF.ready,1)}bF.isReady=true;if(b0!==true&&--bF.readyWait>0){return}bC.fireWith(av,[bF]);if(bF.fn.trigger){bF(av).trigger("ready").off("ready")}}},bindReady:function(){if(bC){return}bC=bF.Callbacks("once memory");if(av.readyState==="complete"){return setTimeout(bF.ready,1)}if(av.addEventListener){av.addEventListener("DOMContentLoaded",e,false);bb.addEventListener("load",bF.ready,false)}else{if(av.attachEvent){av.attachEvent("onreadystatechange",e);bb.attachEvent("onload",bF.ready);var b0=false;try{b0=bb.frameElement==null}catch(b1){}if(av.documentElement.doScroll&&b0){bw()}}}},isFunction:function(b0){return bF.type(b0)==="function"},isArray:Array.isArray||function(b0){return bF.type(b0)==="array"},isWindow:function(b0){return b0&&typeof b0==="object"&&"setInterval" in b0},isNumeric:function(b0){return !isNaN(parseFloat(b0))&&isFinite(b0)},type:function(b0){return b0==null?String(b0):bx[bL.call(b0)]||"object"},isPlainObject:function(b2){if(!b2||bF.type(b2)!=="object"||b2.nodeType||bF.isWindow(b2)){return false}try{if(b2.constructor&&!bG.call(b2,"constructor")&&!bG.call(b2.constructor.prototype,"isPrototypeOf")){return false}}catch(b1){return false}var b0;for(b0 in b2){}return b0===L||bG.call(b2,b0)},isEmptyObject:function(b1){for(var b0 in b1){return false}return true},error:function(b0){throw new Error(b0)},parseJSON:function(b0){if(typeof b0!=="string"||!b0){return null}b0=bF.trim(b0);if(bb.JSON&&bb.JSON.parse){return bb.JSON.parse(b0)}if(bN.test(b0.replace(bW,"@").replace(bP,"]").replace(bJ,""))){return(new Function("return "+b0))()}bF.error("Invalid JSON: "+b0)},parseXML:function(b2){var b0,b1;try{if(bb.DOMParser){b1=new DOMParser();b0=b1.parseFromString(b2,"text/xml")}else{b0=new ActiveXObject("Microsoft.XMLDOM");b0.async="false";b0.loadXML(b2)}}catch(b3){b0=L}if(!b0||!b0.documentElement||b0.getElementsByTagName("parsererror").length){bF.error("Invalid XML: "+b2)}return b0},noop:function(){},globalEval:function(b0){if(b0&&bM.test(b0)){(bb.execScript||function(b1){bb["eval"].call(bb,b1)})(b0)}},camelCase:function(b0){return b0.replace(bZ,"ms-").replace(bB,bT)},nodeName:function(b1,b0){return b1.nodeName&&b1.nodeName.toUpperCase()===b0.toUpperCase()},each:function(b3,b6,b2){var b1,b4=0,b5=b3.length,b0=b5===L||bF.isFunction(b3);if(b2){if(b0){for(b1 in b3){if(b6.apply(b3[b1],b2)===false){break}}}else{for(;b4<b5;){if(b6.apply(b3[b4++],b2)===false){break}}}}else{if(b0){for(b1 in b3){if(b6.call(b3[b1],b1,b3[b1])===false){break}}}else{for(;b4<b5;){if(b6.call(b3[b4],b4,b3[b4++])===false){break}}}}return b3},trim:bO?function(b0){return b0==null?"":bO.call(b0)}:function(b0){return b0==null?"":b0.toString().replace(bI,"").replace(bE,"")},makeArray:function(b3,b1){var b0=b1||[];if(b3!=null){var b2=bF.type(b3);if(b3.length==null||b2==="string"||b2==="function"||b2==="regexp"||bF.isWindow(b3)){bz.call(b0,b3)}else{bF.merge(b0,b3)}}return b0},inArray:function(b2,b3,b1){var b0;if(b3){if(bv){return bv.call(b3,b2,b1)}b0=b3.length;b1=b1?b1<0?Math.max(0,b0+b1):b1:0;for(;b1<b0;b1++){if(b1 in b3&&b3[b1]===b2){return b1}}}return -1},merge:function(b4,b2){var b3=b4.length,b1=0;if(typeof b2.length==="number"){for(var b0=b2.length;b1<b0;b1++){b4[b3++]=b2[b1]}}else{while(b2[b1]!==L){b4[b3++]=b2[b1++]}}b4.length=b3;return b4},grep:function(b1,b6,b0){var b2=[],b5;b0=!!b0;for(var b3=0,b4=b1.length;b3<b4;b3++){b5=!!b6(b1[b3],b3);if(b0!==b5){b2.push(b1[b3])}}return b2},map:function(b0,b7,b8){var b5,b6,b4=[],b2=0,b1=b0.length,b3=b0 instanceof bF||b1!==L&&typeof b1==="number"&&((b1>0&&b0[0]&&b0[b1-1])||b1===0||bF.isArray(b0));if(b3){for(;b2<b1;b2++){b5=b7(b0[b2],b2,b8);if(b5!=null){b4[b4.length]=b5}}}else{for(b6 in b0){b5=b7(b0[b6],b6,b8);if(b5!=null){b4[b4.length]=b5}}}return b4.concat.apply([],b4)},guid:1,proxy:function(b4,b3){if(typeof b3==="string"){var b2=b4[b3];b3=b4;b4=b2}if(!bF.isFunction(b4)){return L}var b0=bK.call(arguments,2),b1=function(){return b4.apply(b3,b0.concat(bK.call(arguments)))};b1.guid=b4.guid=b4.guid||b1.guid||bF.guid++;return b1},access:function(b0,b8,b6,b2,b5,b7){var b1=b0.length;if(typeof b8==="object"){for(var b3 in b8){bF.access(b0,b3,b8[b3],b2,b5,b6)}return b0}if(b6!==L){b2=!b7&&b2&&bF.isFunction(b6);for(var b4=0;b4<b1;b4++){b5(b0[b4],b8,b2?b6.call(b0[b4],b4,b5(b0[b4],b8)):b6,b7)}return b0}return b1?b5(b0[0],b8):L},now:function(){return(new Date()).getTime()},uaMatch:function(b1){b1=b1.toLowerCase();var b0=by.exec(b1)||bR.exec(b1)||bQ.exec(b1)||b1.indexOf("compatible")<0&&bS.exec(b1)||[];return{browser:b0[1]||"",version:b0[2]||"0"}},sub:function(){function b0(b3,b4){return new b0.fn.init(b3,b4)}bF.extend(true,b0,this);b0.superclass=this;b0.fn=b0.prototype=this();b0.fn.constructor=b0;b0.sub=this.sub;b0.fn.init=function b2(b3,b4){if(b4&&b4 instanceof bF&&!(b4 instanceof b0)){b4=b0(b4)}return bF.fn.init.call(this,b3,b4,b1)};b0.fn.init.prototype=b0.fn;var b1=b0(av);return b0},browser:{}});bF.each("Boolean Number String Function Array Date RegExp Object".split(" "),function(b1,b0){bx["[object "+b0+"]"]=b0.toLowerCase()});bV=bF.uaMatch(bX);if(bV.browser){bF.browser[bV.browser]=true;bF.browser.version=bV.version}if(bF.browser.webkit){bF.browser.safari=true}if(bM.test("\xA0")){bI=/^[\s\xA0]+/;bE=/[\s\xA0]+$/}bD=bF(av);if(av.addEventListener){e=function(){av.removeEventListener("DOMContentLoaded",e,false);bF.ready()}}else{if(av.attachEvent){e=function(){if(av.readyState==="complete"){av.detachEvent("onreadystatechange",e);bF.ready()}}}}function bw(){if(bF.isReady){return}try{av.documentElement.doScroll("left")}catch(b0){setTimeout(bw,1);return}bF.ready()}return bF})();var a2={};function X(e){var bv=a2[e]={},bw,bx;e=e.split(/\s+/);for(bw=0,bx=e.length;bw<bx;bw++){bv[e[bw]]=true}return bv}b.Callbacks=function(bw){bw=bw?(a2[bw]||X(bw)):{};var bB=[],bC=[],bx,by,bv,bz,bA,bE=function(bF){var bG,bJ,bI,bH,bK;for(bG=0,bJ=bF.length;bG<bJ;bG++){bI=bF[bG];bH=b.type(bI);if(bH==="array"){bE(bI)}else{if(bH==="function"){if(!bw.unique||!bD.has(bI)){bB.push(bI)}}}}},e=function(bG,bF){bF=bF||[];bx=!bw.memory||[bG,bF];by=true;bA=bv||0;bv=0;bz=bB.length;for(;bB&&bA<bz;bA++){if(bB[bA].apply(bG,bF)===false&&bw.stopOnFalse){bx=true;break}}by=false;if(bB){if(!bw.once){if(bC&&bC.length){bx=bC.shift();bD.fireWith(bx[0],bx[1])}}else{if(bx===true){bD.disable()}else{bB=[]}}}},bD={add:function(){if(bB){var bF=bB.length;bE(arguments);if(by){bz=bB.length}else{if(bx&&bx!==true){bv=bF;e(bx[0],bx[1])}}}return this},remove:function(){if(bB){var bF=arguments,bH=0,bI=bF.length;for(;bH<bI;bH++){for(var bG=0;bG<bB.length;bG++){if(bF[bH]===bB[bG]){if(by){if(bG<=bz){bz--;if(bG<=bA){bA--}}}bB.splice(bG--,1);if(bw.unique){break}}}}}return this},has:function(bG){if(bB){var bF=0,bH=bB.length;for(;bF<bH;bF++){if(bG===bB[bF]){return true}}}return false},empty:function(){bB=[];return this},disable:function(){bB=bC=bx=L;return this},disabled:function(){return !bB},lock:function(){bC=L;if(!bx||bx===true){bD.disable()}return this},locked:function(){return !bC},fireWith:function(bG,bF){if(bC){if(by){if(!bw.once){bC.push([bG,bF])}}else{if(!(bw.once&&bx)){e(bG,bF)}}}return this},fire:function(){bD.fireWith(this,arguments);return this},fired:function(){return !!bx}};return bD};var aJ=[].slice;b.extend({Deferred:function(by){var bx=b.Callbacks("once memory"),bw=b.Callbacks("once memory"),bv=b.Callbacks("memory"),e="pending",bA={resolve:bx,reject:bw,notify:bv},bC={done:bx.add,fail:bw.add,progress:bv.add,state:function(){return e},isResolved:bx.fired,isRejected:bw.fired,then:function(bE,bD,bF){bB.done(bE).fail(bD).progress(bF);return this},always:function(){bB.done.apply(bB,arguments).fail.apply(bB,arguments);return this},pipe:function(bF,bE,bD){return b.Deferred(function(bG){b.each({done:[bF,"resolve"],fail:[bE,"reject"],progress:[bD,"notify"]},function(bI,bL){var bH=bL[0],bK=bL[1],bJ;if(b.isFunction(bH)){bB[bI](function(){bJ=bH.apply(this,arguments);if(bJ&&b.isFunction(bJ.promise)){bJ.promise().then(bG.resolve,bG.reject,bG.notify)}else{bG[bK+"With"](this===bB?bG:this,[bJ])}})}else{bB[bI](bG[bK])}})}).promise()},promise:function(bE){if(bE==null){bE=bC}else{for(var bD in bC){bE[bD]=bC[bD]}}return bE}},bB=bC.promise({}),bz;for(bz in bA){bB[bz]=bA[bz].fire;bB[bz+"With"]=bA[bz].fireWith}bB.done(function(){e="resolved"},bw.disable,bv.lock).fail(function(){e="rejected"},bx.disable,bv.lock);if(by){by.call(bB,bB)}return bB},when:function(bA){var bx=aJ.call(arguments,0),bv=0,e=bx.length,bB=new Array(e),bw=e,by=e,bC=e<=1&&bA&&b.isFunction(bA.promise)?bA:b.Deferred(),bE=bC.promise();function bD(bF){return function(bG){bx[bF]=arguments.length>1?aJ.call(arguments,0):bG;if(!(--bw)){bC.resolveWith(bC,bx)}}}function bz(bF){return function(bG){bB[bF]=arguments.length>1?aJ.call(arguments,0):bG;bC.notifyWith(bE,bB)}}if(e>1){for(;bv<e;bv++){if(bx[bv]&&bx[bv].promise&&b.isFunction(bx[bv].promise)){bx[bv].promise().then(bD(bv),bC.reject,bz(bv))}else{--bw}}if(!bw){bC.resolveWith(bC,bx)}}else{if(bC!==bA){bC.resolveWith(bC,e?[bA]:[])}}return bE}});b.support=(function(){var bJ,bI,bF,bG,bx,bE,bA,bD,bz,bK,bB,by,bw,bv=av.createElement("div"),bH=av.documentElement;bv.setAttribute("className","t");bv.innerHTML=" <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>";bI=bv.getElementsByTagName("*");bF=bv.getElementsByTagName("a")[0];if(!bI||!bI.length||!bF){return{}}bG=av.createElement("select");bx=bG.appendChild(av.createElement("option"));bE=bv.getElementsByTagName("input")[0];bJ={leadingWhitespace:(bv.firstChild.nodeType===3),tbody:!bv.getElementsByTagName("tbody").length,htmlSerialize:!!bv.getElementsByTagName("link").length,style:/top/.test(bF.getAttribute("style")),hrefNormalized:(bF.getAttribute("href")==="/a"),opacity:/^0.55/.test(bF.style.opacity),cssFloat:!!bF.style.cssFloat,checkOn:(bE.value==="on"),optSelected:bx.selected,getSetAttribute:bv.className!=="t",enctype:!!av.createElement("form").enctype,html5Clone:av.createElement("nav").cloneNode(true).outerHTML!=="<:nav></:nav>",submitBubbles:true,changeBubbles:true,focusinBubbles:false,deleteExpando:true,noCloneEvent:true,inlineBlockNeedsLayout:false,shrinkWrapBlocks:false,reliableMarginRight:true};bE.checked=true;bJ.noCloneChecked=bE.cloneNode(true).checked;bG.disabled=true;bJ.optDisabled=!bx.disabled;try{delete bv.test}catch(bC){bJ.deleteExpando=false}if(!bv.addEventListener&&bv.attachEvent&&bv.fireEvent){bv.attachEvent("onclick",function(){bJ.noCloneEvent=false});bv.cloneNode(true).fireEvent("onclick")}bE=av.createElement("input");bE.value="t";bE.setAttribute("type","radio");bJ.radioValue=bE.value==="t";bE.setAttribute("checked","checked");bv.appendChild(bE);bD=av.createDocumentFragment();bD.appendChild(bv.lastChild);bJ.checkClone=bD.cloneNode(true).cloneNode(true).lastChild.checked;bJ.appendChecked=bE.checked;bD.removeChild(bE);bD.appendChild(bv);bv.innerHTML="";if(bb.getComputedStyle){bA=av.createElement("div");bA.style.width="0";bA.style.marginRight="0";bv.style.width="2px";bv.appendChild(bA);bJ.reliableMarginRight=(parseInt((bb.getComputedStyle(bA,null)||{marginRight:0}).marginRight,10)||0)===0}if(bv.attachEvent){for(by in {submit:1,change:1,focusin:1}){bB="on"+by;bw=(bB in bv);if(!bw){bv.setAttribute(bB,"return;");bw=(typeof bv[bB]==="function")}bJ[by+"Bubbles"]=bw}}bD.removeChild(bv);bD=bG=bx=bA=bv=bE=null;b(function(){var bM,bU,bV,bT,bN,bO,bL,bS,bR,e,bP,bQ=av.getElementsByTagName("body")[0];if(!bQ){return}bL=1;bS="position:absolute;top:0;left:0;width:1px;height:1px;margin:0;";bR="visibility:hidden;border:0;";e="style='"+bS+"border:5px solid #000;padding:0;'";bP="<div "+e+"><div></div></div><table "+e+" cellpadding='0' cellspacing='0'><tr><td></td></tr></table>";bM=av.createElement("div");bM.style.cssText=bR+"width:0;height:0;position:static;top:0;margin-top:"+bL+"px";bQ.insertBefore(bM,bQ.firstChild);bv=av.createElement("div");bM.appendChild(bv);bv.innerHTML="<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>";bz=bv.getElementsByTagName("td");bw=(bz[0].offsetHeight===0);bz[0].style.display="";bz[1].style.display="none";bJ.reliableHiddenOffsets=bw&&(bz[0].offsetHeight===0);bv.innerHTML="";bv.style.width=bv.style.paddingLeft="1px";b.boxModel=bJ.boxModel=bv.offsetWidth===2;if(typeof bv.style.zoom!=="undefined"){bv.style.display="inline";bv.style.zoom=1;bJ.inlineBlockNeedsLayout=(bv.offsetWidth===2);bv.style.display="";bv.innerHTML="<div style='width:4px;'></div>";bJ.shrinkWrapBlocks=(bv.offsetWidth!==2)}bv.style.cssText=bS+bR;bv.innerHTML=bP;bU=bv.firstChild;bV=bU.firstChild;bN=bU.nextSibling.firstChild.firstChild;bO={doesNotAddBorder:(bV.offsetTop!==5),doesAddBorderForTableAndCells:(bN.offsetTop===5)};bV.style.position="fixed";bV.style.top="20px";bO.fixedPosition=(bV.offsetTop===20||bV.offsetTop===15);bV.style.position=bV.style.top="";bU.style.overflow="hidden";bU.style.position="relative";bO.subtractsBorderForOverflowNotVisible=(bV.offsetTop===-5);bO.doesNotIncludeMarginInBodyOffset=(bQ.offsetTop!==bL);bQ.removeChild(bM);bv=bM=null;b.extend(bJ,bO)});return bJ})();var aS=/^(?:\{.*\}|\[.*\])$/,aA=/([A-Z])/g;b.extend({cache:{},uuid:0,expando:"jQuery"+(b.fn.jquery+Math.random()).replace(/\D/g,""),noData:{embed:true,object:"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",applet:true},hasData:function(e){e=e.nodeType?b.cache[e[b.expando]]:e[b.expando];return !!e&&!S(e)},data:function(bx,bv,bz,by){if(!b.acceptData(bx)){return}var bG,bA,bD,bE=b.expando,bC=typeof bv==="string",bF=bx.nodeType,e=bF?b.cache:bx,bw=bF?bx[bE]:bx[bE]&&bE,bB=bv==="events";if((!bw||!e[bw]||(!bB&&!by&&!e[bw].data))&&bC&&bz===L){return}if(!bw){if(bF){bx[bE]=bw=++b.uuid}else{bw=bE}}if(!e[bw]){e[bw]={};if(!bF){e[bw].toJSON=b.noop}}if(typeof bv==="object"||typeof bv==="function"){if(by){e[bw]=b.extend(e[bw],bv)}else{e[bw].data=b.extend(e[bw].data,bv)}}bG=bA=e[bw];if(!by){if(!bA.data){bA.data={}}bA=bA.data}if(bz!==L){bA[b.camelCase(bv)]=bz}if(bB&&!bA[bv]){return bG.events}if(bC){bD=bA[bv];if(bD==null){bD=bA[b.camelCase(bv)]}}else{bD=bA}return bD},removeData:function(bx,bv,by){if(!b.acceptData(bx)){return}var bB,bA,bz,bC=b.expando,bD=bx.nodeType,e=bD?b.cache:bx,bw=bD?bx[bC]:bC;if(!e[bw]){return}if(bv){bB=by?e[bw]:e[bw].data;if(bB){if(!b.isArray(bv)){if(bv in bB){bv=[bv]}else{bv=b.camelCase(bv);if(bv in bB){bv=[bv]}else{bv=bv.split(" ")}}}for(bA=0,bz=bv.length;bA<bz;bA++){delete bB[bv[bA]]}if(!(by?S:b.isEmptyObject)(bB)){return}}}if(!by){delete e[bw].data;if(!S(e[bw])){return}}if(b.support.deleteExpando||!e.setInterval){delete e[bw]}else{e[bw]=null}if(bD){if(b.support.deleteExpando){delete bx[bC]}else{if(bx.removeAttribute){bx.removeAttribute(bC)}else{bx[bC]=null}}}},_data:function(bv,e,bw){return b.data(bv,e,bw,true)},acceptData:function(bv){if(bv.nodeName){var e=b.noData[bv.nodeName.toLowerCase()];if(e){return !(e===true||bv.getAttribute("classid")!==e)}}return true}});b.fn.extend({data:function(by,bA){var bB,e,bw,bz=null;if(typeof by==="undefined"){if(this.length){bz=b.data(this[0]);if(this[0].nodeType===1&&!b._data(this[0],"parsedAttrs")){e=this[0].attributes;for(var bx=0,bv=e.length;bx<bv;bx++){bw=e[bx].name;if(bw.indexOf("data-")===0){bw=b.camelCase(bw.substring(5));a5(this[0],bw,bz[bw])}}b._data(this[0],"parsedAttrs",true)}}return bz}else{if(typeof by==="object"){return this.each(function(){b.data(this,by)})}}bB=by.split(".");bB[1]=bB[1]?"."+bB[1]:"";if(bA===L){bz=this.triggerHandler("getData"+bB[1]+"!",[bB[0]]);if(bz===L&&this.length){bz=b.data(this[0],by);bz=a5(this[0],by,bz)}return bz===L&&bB[1]?this.data(bB[0]):bz}else{return this.each(function(){var bC=b(this),bD=[bB[0],bA];bC.triggerHandler("setData"+bB[1]+"!",bD);b.data(this,by,bA);bC.triggerHandler("changeData"+bB[1]+"!",bD)})}},removeData:function(e){return this.each(function(){b.removeData(this,e)})}});function a5(bx,bw,by){if(by===L&&bx.nodeType===1){var bv="data-"+bw.replace(aA,"-$1").toLowerCase();by=bx.getAttribute(bv);if(typeof by==="string"){try{by=by==="true"?true:by==="false"?false:by==="null"?null:b.isNumeric(by)?parseFloat(by):aS.test(by)?b.parseJSON(by):by}catch(bz){}b.data(bx,bw,by)}else{by=L}}return by}function S(bv){for(var e in bv){if(e==="data"&&b.isEmptyObject(bv[e])){continue}if(e!=="toJSON"){return false}}return true}function bi(by,bx,bA){var bw=bx+"defer",bv=bx+"queue",e=bx+"mark",bz=b._data(by,bw);if(bz&&(bA==="queue"||!b._data(by,bv))&&(bA==="mark"||!b._data(by,e))){setTimeout(function(){if(!b._data(by,bv)&&!b._data(by,e)){b.removeData(by,bw,true);bz.fire()}},0)}}b.extend({_mark:function(bv,e){if(bv){e=(e||"fx")+"mark";b._data(bv,e,(b._data(bv,e)||0)+1)}},_unmark:function(by,bx,bv){if(by!==true){bv=bx;bx=by;by=false}if(bx){bv=bv||"fx";var e=bv+"mark",bw=by?0:((b._data(bx,e)||1)-1);if(bw){b._data(bx,e,bw)}else{b.removeData(bx,e,true);bi(bx,bv,"mark")}}},queue:function(bv,e,bx){var bw;if(bv){e=(e||"fx")+"queue";bw=b._data(bv,e);if(bx){if(!bw||b.isArray(bx)){bw=b._data(bv,e,b.makeArray(bx))}else{bw.push(bx)}}return bw||[]}},dequeue:function(by,bx){bx=bx||"fx";var bv=b.queue(by,bx),bw=bv.shift(),e={};if(bw==="inprogress"){bw=bv.shift()}if(bw){if(bx==="fx"){bv.unshift("inprogress")}b._data(by,bx+".run",e);bw.call(by,function(){b.dequeue(by,bx)},e)}if(!bv.length){b.removeData(by,bx+"queue "+bx+".run",true);bi(by,bx,"queue")}}});b.fn.extend({queue:function(e,bv){if(typeof e!=="string"){bv=e;e="fx"}if(bv===L){return b.queue(this[0],e)}return this.each(function(){var bw=b.queue(this,e,bv);if(e==="fx"&&bw[0]!=="inprogress"){b.dequeue(this,e)}})},dequeue:function(e){return this.each(function(){b.dequeue(this,e)})},delay:function(bv,e){bv=b.fx?b.fx.speeds[bv]||bv:bv;e=e||"fx";return this.queue(e,function(bx,bw){var by=setTimeout(bx,bv);bw.stop=function(){clearTimeout(by)}})},clearQueue:function(e){return this.queue(e||"fx",[])},promise:function(bD,bw){if(typeof bD!=="string"){bw=bD;bD=L}bD=bD||"fx";var e=b.Deferred(),bv=this,by=bv.length,bB=1,bz=bD+"defer",bA=bD+"queue",bC=bD+"mark",bx;function bE(){if(!(--bB)){e.resolveWith(bv,[bv])}}while(by--){if((bx=b.data(bv[by],bz,L,true)||(b.data(bv[by],bA,L,true)||b.data(bv[by],bC,L,true))&&b.data(bv[by],bz,b.Callbacks("once memory"),true))){bB++;bx.add(bE)}}bE();return e.promise()}});var aP=/[\n\t\r]/g,af=/\s+/,aU=/\r/g,g=/^(?:button|input)$/i,D=/^(?:button|input|object|select|textarea)$/i,l=/^a(?:rea)?$/i,ao=/^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,F=b.support.getSetAttribute,be,aY,aF;b.fn.extend({attr:function(e,bv){return b.access(this,e,bv,true,b.attr)},removeAttr:function(e){return this.each(function(){b.removeAttr(this,e)})},prop:function(e,bv){return b.access(this,e,bv,true,b.prop)},removeProp:function(e){e=b.propFix[e]||e;return this.each(function(){try{this[e]=L;delete this[e]}catch(bv){}})},addClass:function(by){var bA,bw,bv,bx,bz,bB,e;if(b.isFunction(by)){return this.each(function(bC){b(this).addClass(by.call(this,bC,this.className))})}if(by&&typeof by==="string"){bA=by.split(af);for(bw=0,bv=this.length;bw<bv;bw++){bx=this[bw];if(bx.nodeType===1){if(!bx.className&&bA.length===1){bx.className=by}else{bz=" "+bx.className+" ";for(bB=0,e=bA.length;bB<e;bB++){if(!~bz.indexOf(" "+bA[bB]+" ")){bz+=bA[bB]+" "}}bx.className=b.trim(bz)}}}}return this},removeClass:function(bz){var bA,bw,bv,by,bx,bB,e;if(b.isFunction(bz)){return this.each(function(bC){b(this).removeClass(bz.call(this,bC,this.className))})}if((bz&&typeof bz==="string")||bz===L){bA=(bz||"").split(af);for(bw=0,bv=this.length;bw<bv;bw++){by=this[bw];if(by.nodeType===1&&by.className){if(bz){bx=(" "+by.className+" ").replace(aP," ");for(bB=0,e=bA.length;bB<e;bB++){bx=bx.replace(" "+bA[bB]+" "," ")}by.className=b.trim(bx)}else{by.className=""}}}}return this},toggleClass:function(bx,bv){var bw=typeof bx,e=typeof bv==="boolean";if(b.isFunction(bx)){return this.each(function(by){b(this).toggleClass(bx.call(this,by,this.className,bv),bv)})}return this.each(function(){if(bw==="string"){var bA,bz=0,by=b(this),bB=bv,bC=bx.split(af);while((bA=bC[bz++])){bB=e?bB:!by.hasClass(bA);by[bB?"addClass":"removeClass"](bA)}}else{if(bw==="undefined"||bw==="boolean"){if(this.className){b._data(this,"__className__",this.className)}this.className=this.className||bx===false?"":b._data(this,"__className__")||""}}})},hasClass:function(e){var bx=" "+e+" ",bw=0,bv=this.length;for(;bw<bv;bw++){if(this[bw].nodeType===1&&(" "+this[bw].className+" ").replace(aP," ").indexOf(bx)>-1){return true}}return false},val:function(bx){var e,bv,by,bw=this[0];if(!arguments.length){if(bw){e=b.valHooks[bw.nodeName.toLowerCase()]||b.valHooks[bw.type];if(e&&"get" in e&&(bv=e.get(bw,"value"))!==L){return bv}bv=bw.value;return typeof bv==="string"?bv.replace(aU,""):bv==null?"":bv}return}by=b.isFunction(bx);return this.each(function(bA){var bz=b(this),bB;if(this.nodeType!==1){return}if(by){bB=bx.call(this,bA,bz.val())}else{bB=bx}if(bB==null){bB=""}else{if(typeof bB==="number"){bB+=""}else{if(b.isArray(bB)){bB=b.map(bB,function(bC){return bC==null?"":bC+""})}}}e=b.valHooks[this.nodeName.toLowerCase()]||b.valHooks[this.type];if(!e||!("set" in e)||e.set(this,bB,"value")===L){this.value=bB}})}});b.extend({valHooks:{option:{get:function(e){var bv=e.attributes.value;return !bv||bv.specified?e.value:e.text}},select:{get:function(e){var bA,bv,bz,bx,by=e.selectedIndex,bB=[],bC=e.options,bw=e.type==="select-one";if(by<0){return null}bv=bw?by:0;bz=bw?by+1:bC.length;for(;bv<bz;bv++){bx=bC[bv];if(bx.selected&&(b.support.optDisabled?!bx.disabled:bx.getAttribute("disabled")===null)&&(!bx.parentNode.disabled||!b.nodeName(bx.parentNode,"optgroup"))){bA=b(bx).val();if(bw){return bA}bB.push(bA)}}if(bw&&!bB.length&&bC.length){return b(bC[by]).val()}return bB},set:function(bv,bw){var e=b.makeArray(bw);b(bv).find("option").each(function(){this.selected=b.inArray(b(this).val(),e)>=0});if(!e.length){bv.selectedIndex=-1}return e}}},attrFn:{val:true,css:true,html:true,text:true,data:true,width:true,height:true,offset:true},attr:function(bA,bx,bB,bz){var bw,e,by,bv=bA.nodeType;if(!bA||bv===3||bv===8||bv===2){return}if(bz&&bx in b.attrFn){return b(bA)[bx](bB)}if(typeof bA.getAttribute==="undefined"){return b.prop(bA,bx,bB)}by=bv!==1||!b.isXMLDoc(bA);if(by){bx=bx.toLowerCase();e=b.attrHooks[bx]||(ao.test(bx)?aY:be)}if(bB!==L){if(bB===null){b.removeAttr(bA,bx);return}else{if(e&&"set" in e&&by&&(bw=e.set(bA,bB,bx))!==L){return bw}else{bA.setAttribute(bx,""+bB);return bB}}}else{if(e&&"get" in e&&by&&(bw=e.get(bA,bx))!==null){return bw}else{bw=bA.getAttribute(bx);return bw===null?L:bw}}},removeAttr:function(bx,bz){var by,bA,bv,e,bw=0;if(bz&&bx.nodeType===1){bA=bz.toLowerCase().split(af);e=bA.length;for(;bw<e;bw++){bv=bA[bw];if(bv){by=b.propFix[bv]||bv;b.attr(bx,bv,"");bx.removeAttribute(F?bv:by);if(ao.test(bv)&&by in bx){bx[by]=false}}}}},attrHooks:{type:{set:function(e,bv){if(g.test(e.nodeName)&&e.parentNode){b.error("type property can't be changed")}else{if(!b.support.radioValue&&bv==="radio"&&b.nodeName(e,"input")){var bw=e.value;e.setAttribute("type",bv);if(bw){e.value=bw}return bv}}}},value:{get:function(bv,e){if(be&&b.nodeName(bv,"button")){return be.get(bv,e)}return e in bv?bv.value:null},set:function(bv,bw,e){if(be&&b.nodeName(bv,"button")){return be.set(bv,bw,e)}bv.value=bw}}},propFix:{tabindex:"tabIndex",readonly:"readOnly","for":"htmlFor","class":"className",maxlength:"maxLength",cellspacing:"cellSpacing",cellpadding:"cellPadding",rowspan:"rowSpan",colspan:"colSpan",usemap:"useMap",frameborder:"frameBorder",contenteditable:"contentEditable"},prop:function(bz,bx,bA){var bw,e,by,bv=bz.nodeType;if(!bz||bv===3||bv===8||bv===2){return}by=bv!==1||!b.isXMLDoc(bz);if(by){bx=b.propFix[bx]||bx;e=b.propHooks[bx]}if(bA!==L){if(e&&"set" in e&&(bw=e.set(bz,bA,bx))!==L){return bw}else{return(bz[bx]=bA)}}else{if(e&&"get" in e&&(bw=e.get(bz,bx))!==null){return bw}else{return bz[bx]}}},propHooks:{tabIndex:{get:function(bv){var e=bv.getAttributeNode("tabindex");return e&&e.specified?parseInt(e.value,10):D.test(bv.nodeName)||l.test(bv.nodeName)&&bv.href?0:L}}}});b.attrHooks.tabindex=b.propHooks.tabIndex;aY={get:function(bv,e){var bx,bw=b.prop(bv,e);return bw===true||typeof bw!=="boolean"&&(bx=bv.getAttributeNode(e))&&bx.nodeValue!==false?e.toLowerCase():L},set:function(bv,bx,e){var bw;if(bx===false){b.removeAttr(bv,e)}else{bw=b.propFix[e]||e;if(bw in bv){bv[bw]=true}bv.setAttribute(e,e.toLowerCase())}return e}};if(!F){aF={name:true,id:true};be=b.valHooks.button={get:function(bw,bv){var e;e=bw.getAttributeNode(bv);return e&&(aF[bv]?e.nodeValue!=="":e.specified)?e.nodeValue:L},set:function(bw,bx,bv){var e=bw.getAttributeNode(bv);if(!e){e=av.createAttribute(bv);bw.setAttributeNode(e)}return(e.nodeValue=bx+"")}};b.attrHooks.tabindex.set=be.set;b.each(["width","height"],function(bv,e){b.attrHooks[e]=b.extend(b.attrHooks[e],{set:function(bw,bx){if(bx===""){bw.setAttribute(e,"auto");return bx}}})});b.attrHooks.contenteditable={get:be.get,set:function(bv,bw,e){if(bw===""){bw="false"}be.set(bv,bw,e)}}}if(!b.support.hrefNormalized){b.each(["href","src","width","height"],function(bv,e){b.attrHooks[e]=b.extend(b.attrHooks[e],{get:function(bx){var bw=bx.getAttribute(e,2);return bw===null?L:bw}})})}if(!b.support.style){b.attrHooks.style={get:function(e){return e.style.cssText.toLowerCase()||L},set:function(e,bv){return(e.style.cssText=""+bv)}}}if(!b.support.optSelected){b.propHooks.selected=b.extend(b.propHooks.selected,{get:function(bv){var e=bv.parentNode;if(e){e.selectedIndex;if(e.parentNode){e.parentNode.selectedIndex}}return null}})}if(!b.support.enctype){b.propFix.enctype="encoding"}if(!b.support.checkOn){b.each(["radio","checkbox"],function(){b.valHooks[this]={get:function(e){return e.getAttribute("value")===null?"on":e.value}}})}b.each(["radio","checkbox"],function(){b.valHooks[this]=b.extend(b.valHooks[this],{set:function(e,bv){if(b.isArray(bv)){return(e.checked=b.inArray(b(e).val(),bv)>=0)}}})});var bd=/^(?:textarea|input|select)$/i,n=/^([^\.]*)?(?:\.(.+))?$/,J=/\bhover(\.\S+)?\b/,aO=/^key/,bf=/^(?:mouse|contextmenu)|click/,T=/^(?:focusinfocus|focusoutblur)$/,U=/^(\w*)(?:#([\w\-]+))?(?:\.([\w\-]+))?$/,Y=function(e){var bv=U.exec(e);if(bv){bv[1]=(bv[1]||"").toLowerCase();bv[3]=bv[3]&&new RegExp("(?:^|\\s)"+bv[3]+"(?:\\s|$)")}return bv},j=function(bw,e){var bv=bw.attributes||{};return((!e[1]||bw.nodeName.toLowerCase()===e[1])&&(!e[2]||(bv.id||{}).value===e[2])&&(!e[3]||e[3].test((bv["class"]||{}).value)))},bt=function(e){return b.event.special.hover?e:e.replace(J,"mouseenter$1 mouseleave$1")};b.event={add:function(bx,bC,bJ,bA,by){var bD,bB,bK,bI,bH,bF,e,bG,bv,bz,bw,bE;if(bx.nodeType===3||bx.nodeType===8||!bC||!bJ||!(bD=b._data(bx))){return}if(bJ.handler){bv=bJ;bJ=bv.handler}if(!bJ.guid){bJ.guid=b.guid++}bK=bD.events;if(!bK){bD.events=bK={}}bB=bD.handle;if(!bB){bD.handle=bB=function(bL){return typeof b!=="undefined"&&(!bL||b.event.triggered!==bL.type)?b.event.dispatch.apply(bB.elem,arguments):L};bB.elem=bx}bC=b.trim(bt(bC)).split(" ");for(bI=0;bI<bC.length;bI++){bH=n.exec(bC[bI])||[];bF=bH[1];e=(bH[2]||"").split(".").sort();bE=b.event.special[bF]||{};bF=(by?bE.delegateType:bE.bindType)||bF;bE=b.event.special[bF]||{};bG=b.extend({type:bF,origType:bH[1],data:bA,handler:bJ,guid:bJ.guid,selector:by,quick:Y(by),namespace:e.join(".")},bv);bw=bK[bF];if(!bw){bw=bK[bF]=[];bw.delegateCount=0;if(!bE.setup||bE.setup.call(bx,bA,e,bB)===false){if(bx.addEventListener){bx.addEventListener(bF,bB,false)}else{if(bx.attachEvent){bx.attachEvent("on"+bF,bB)}}}}if(bE.add){bE.add.call(bx,bG);if(!bG.handler.guid){bG.handler.guid=bJ.guid}}if(by){bw.splice(bw.delegateCount++,0,bG)}else{bw.push(bG)}b.event.global[bF]=true}bx=null},global:{},remove:function(bJ,bE,bv,bH,bB){var bI=b.hasData(bJ)&&b._data(bJ),bF,bx,bz,bL,bC,bA,bG,bw,by,bK,bD,e;if(!bI||!(bw=bI.events)){return}bE=b.trim(bt(bE||"")).split(" ");for(bF=0;bF<bE.length;bF++){bx=n.exec(bE[bF])||[];bz=bL=bx[1];bC=bx[2];if(!bz){for(bz in bw){b.event.remove(bJ,bz+bE[bF],bv,bH,true)}continue}by=b.event.special[bz]||{};bz=(bH?by.delegateType:by.bindType)||bz;bD=bw[bz]||[];bA=bD.length;bC=bC?new RegExp("(^|\\.)"+bC.split(".").sort().join("\\.(?:.*\\.)?")+"(\\.|$)"):null;for(bG=0;bG<bD.length;bG++){e=bD[bG];if((bB||bL===e.origType)&&(!bv||bv.guid===e.guid)&&(!bC||bC.test(e.namespace))&&(!bH||bH===e.selector||bH==="**"&&e.selector)){bD.splice(bG--,1);if(e.selector){bD.delegateCount--}if(by.remove){by.remove.call(bJ,e)}}}if(bD.length===0&&bA!==bD.length){if(!by.teardown||by.teardown.call(bJ,bC)===false){b.removeEvent(bJ,bz,bI.handle)}delete bw[bz]}}if(b.isEmptyObject(bw)){bK=bI.handle;if(bK){bK.elem=null}b.removeData(bJ,["events","handle"],true)}},customEvent:{getData:true,setData:true,changeData:true},trigger:function(bv,bD,bA,bJ){if(bA&&(bA.nodeType===3||bA.nodeType===8)){return}var bG=bv.type||bv,bx=[],e,bw,bC,bH,bz,by,bF,bE,bB,bI;if(T.test(bG+b.event.triggered)){return}if(bG.indexOf("!")>=0){bG=bG.slice(0,-1);bw=true}if(bG.indexOf(".")>=0){bx=bG.split(".");bG=bx.shift();bx.sort()}if((!bA||b.event.customEvent[bG])&&!b.event.global[bG]){return}bv=typeof bv==="object"?bv[b.expando]?bv:new b.Event(bG,bv):new b.Event(bG);bv.type=bG;bv.isTrigger=true;bv.exclusive=bw;bv.namespace=bx.join(".");bv.namespace_re=bv.namespace?new RegExp("(^|\\.)"+bx.join("\\.(?:.*\\.)?")+"(\\.|$)"):null;by=bG.indexOf(":")<0?"on"+bG:"";if(!bA){e=b.cache;for(bC in e){if(e[bC].events&&e[bC].events[bG]){b.event.trigger(bv,bD,e[bC].handle.elem,true)}}return}bv.result=L;if(!bv.target){bv.target=bA}bD=bD!=null?b.makeArray(bD):[];bD.unshift(bv);bF=b.event.special[bG]||{};if(bF.trigger&&bF.trigger.apply(bA,bD)===false){return}bB=[[bA,bF.bindType||bG]];if(!bJ&&!bF.noBubble&&!b.isWindow(bA)){bI=bF.delegateType||bG;bH=T.test(bI+bG)?bA:bA.parentNode;bz=null;for(;bH;bH=bH.parentNode){bB.push([bH,bI]);bz=bH}if(bz&&bz===bA.ownerDocument){bB.push([bz.defaultView||bz.parentWindow||bb,bI])}}for(bC=0;bC<bB.length&&!bv.isPropagationStopped();bC++){bH=bB[bC][0];bv.type=bB[bC][1];bE=(b._data(bH,"events")||{})[bv.type]&&b._data(bH,"handle");if(bE){bE.apply(bH,bD)}bE=by&&bH[by];if(bE&&b.acceptData(bH)&&bE.apply(bH,bD)===false){bv.preventDefault()}}bv.type=bG;if(!bJ&&!bv.isDefaultPrevented()){if((!bF._default||bF._default.apply(bA.ownerDocument,bD)===false)&&!(bG==="click"&&b.nodeName(bA,"a"))&&b.acceptData(bA)){if(by&&bA[bG]&&((bG!=="focus"&&bG!=="blur")||bv.target.offsetWidth!==0)&&!b.isWindow(bA)){bz=bA[by];if(bz){bA[by]=null}b.event.triggered=bG;bA[bG]();b.event.triggered=L;if(bz){bA[by]=bz}}}}return bv.result},dispatch:function(e){e=b.event.fix(e||bb.event);var bz=((b._data(this,"events")||{})[e.type]||[]),bA=bz.delegateCount,bG=[].slice.call(arguments,0),by=!e.exclusive&&!e.namespace,bH=[],bC,bB,bK,bx,bF,bE,bv,bD,bI,bw,bJ;bG[0]=e;e.delegateTarget=this;if(bA&&!e.target.disabled&&!(e.button&&e.type==="click")){bx=b(this);bx.context=this.ownerDocument||this;for(bK=e.target;bK!=this;bK=bK.parentNode||this){bE={};bD=[];bx[0]=bK;for(bC=0;bC<bA;bC++){bI=bz[bC];bw=bI.selector;if(bE[bw]===L){bE[bw]=(bI.quick?j(bK,bI.quick):bx.is(bw))}if(bE[bw]){bD.push(bI)}}if(bD.length){bH.push({elem:bK,matches:bD})}}}if(bz.length>bA){bH.push({elem:this,matches:bz.slice(bA)})}for(bC=0;bC<bH.length&&!e.isPropagationStopped();bC++){bv=bH[bC];e.currentTarget=bv.elem;for(bB=0;bB<bv.matches.length&&!e.isImmediatePropagationStopped();bB++){bI=bv.matches[bB];if(by||(!e.namespace&&!bI.namespace)||e.namespace_re&&e.namespace_re.test(bI.namespace)){e.data=bI.data;e.handleObj=bI;bF=((b.event.special[bI.origType]||{}).handle||bI.handler).apply(bv.elem,bG);if(bF!==L){e.result=bF;if(bF===false){e.preventDefault();e.stopPropagation()}}}}}return e.result},props:"attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),fixHooks:{},keyHooks:{props:"char charCode key keyCode".split(" "),filter:function(bv,e){if(bv.which==null){bv.which=e.charCode!=null?e.charCode:e.keyCode}return bv}},mouseHooks:{props:"button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),filter:function(bx,bw){var by,bz,e,bv=bw.button,bA=bw.fromElement;if(bx.pageX==null&&bw.clientX!=null){by=bx.target.ownerDocument||av;bz=by.documentElement;e=by.body;bx.pageX=bw.clientX+(bz&&bz.scrollLeft||e&&e.scrollLeft||0)-(bz&&bz.clientLeft||e&&e.clientLeft||0);bx.pageY=bw.clientY+(bz&&bz.scrollTop||e&&e.scrollTop||0)-(bz&&bz.clientTop||e&&e.clientTop||0)}if(!bx.relatedTarget&&bA){bx.relatedTarget=bA===bx.target?bw.toElement:bA}if(!bx.which&&bv!==L){bx.which=(bv&1?1:(bv&2?3:(bv&4?2:0)))}return bx}},fix:function(bw){if(bw[b.expando]){return bw}var bv,bz,e=bw,bx=b.event.fixHooks[bw.type]||{},by=bx.props?this.props.concat(bx.props):this.props;bw=b.Event(e);for(bv=by.length;bv;){bz=by[--bv];bw[bz]=e[bz]}if(!bw.target){bw.target=e.srcElement||av}if(bw.target.nodeType===3){bw.target=bw.target.parentNode}if(bw.metaKey===L){bw.metaKey=bw.ctrlKey}return bx.filter?bx.filter(bw,e):bw},special:{ready:{setup:b.bindReady},load:{noBubble:true},focus:{delegateType:"focusin"},blur:{delegateType:"focusout"},beforeunload:{setup:function(bw,bv,e){if(b.isWindow(this)){this.onbeforeunload=e}},teardown:function(bv,e){if(this.onbeforeunload===e){this.onbeforeunload=null}}}},simulate:function(bw,by,bx,bv){var bz=b.extend(new b.Event(),bx,{type:bw,isSimulated:true,originalEvent:{}});if(bv){b.event.trigger(bz,null,by)}else{b.event.dispatch.call(by,bz)}if(bz.isDefaultPrevented()){bx.preventDefault()}}};b.event.handle=b.event.dispatch;b.removeEvent=av.removeEventListener?function(bv,e,bw){if(bv.removeEventListener){bv.removeEventListener(e,bw,false)}}:function(bv,e,bw){if(bv.detachEvent){bv.detachEvent("on"+e,bw)}};b.Event=function(bv,e){if(!(this instanceof b.Event)){return new b.Event(bv,e)}if(bv&&bv.type){this.originalEvent=bv;this.type=bv.type;this.isDefaultPrevented=(bv.defaultPrevented||bv.returnValue===false||bv.getPreventDefault&&bv.getPreventDefault())?i:bk}else{this.type=bv}if(e){b.extend(this,e)}this.timeStamp=bv&&bv.timeStamp||b.now();this[b.expando]=true};function bk(){return false}function i(){return true}b.Event.prototype={preventDefault:function(){this.isDefaultPrevented=i;var bv=this.originalEvent;if(!bv){return}if(bv.preventDefault){bv.preventDefault()}else{bv.returnValue=false}},stopPropagation:function(){this.isPropagationStopped=i;var bv=this.originalEvent;if(!bv){return}if(bv.stopPropagation){bv.stopPropagation()}bv.cancelBubble=true},stopImmediatePropagation:function(){this.isImmediatePropagationStopped=i;this.stopPropagation()},isDefaultPrevented:bk,isPropagationStopped:bk,isImmediatePropagationStopped:bk};b.each({mouseenter:"mouseover",mouseleave:"mouseout"},function(bv,e){b.event.special[bv]={delegateType:e,bindType:e,handle:function(bz){var bB=this,bA=bz.relatedTarget,by=bz.handleObj,bw=by.selector,bx;if(!bA||(bA!==bB&&!b.contains(bB,bA))){bz.type=by.origType;bx=by.handler.apply(this,arguments);bz.type=e}return bx}}});if(!b.support.submitBubbles){b.event.special.submit={setup:function(){if(b.nodeName(this,"form")){return false}b.event.add(this,"click._submit keypress._submit",function(bx){var bw=bx.target,bv=b.nodeName(bw,"input")||b.nodeName(bw,"button")?bw.form:L;if(bv&&!bv._submit_attached){b.event.add(bv,"submit._submit",function(e){if(this.parentNode&&!e.isTrigger){b.event.simulate("submit",this.parentNode,e,true)}});bv._submit_attached=true}})},teardown:function(){if(b.nodeName(this,"form")){return false}b.event.remove(this,"._submit")}}}if(!b.support.changeBubbles){b.event.special.change={setup:function(){if(bd.test(this.nodeName)){if(this.type==="checkbox"||this.type==="radio"){b.event.add(this,"propertychange._change",function(e){if(e.originalEvent.propertyName==="checked"){this._just_changed=true}});b.event.add(this,"click._change",function(e){if(this._just_changed&&!e.isTrigger){this._just_changed=false;b.event.simulate("change",this,e,true)}})}return false}b.event.add(this,"beforeactivate._change",function(bw){var bv=bw.target;if(bd.test(bv.nodeName)&&!bv._change_attached){b.event.add(bv,"change._change",function(e){if(this.parentNode&&!e.isSimulated&&!e.isTrigger){b.event.simulate("change",this.parentNode,e,true)}});bv._change_attached=true}})},handle:function(bv){var e=bv.target;if(this!==e||bv.isSimulated||bv.isTrigger||(e.type!=="radio"&&e.type!=="checkbox")){return bv.handleObj.handler.apply(this,arguments)}},teardown:function(){b.event.remove(this,"._change");return bd.test(this.nodeName)}}}if(!b.support.focusinBubbles){b.each({focus:"focusin",blur:"focusout"},function(bx,e){var bv=0,bw=function(by){b.event.simulate(e,by.target,b.event.fix(by),true)};b.event.special[e]={setup:function(){if(bv++===0){av.addEventListener(bx,bw,true)}},teardown:function(){if(--bv===0){av.removeEventListener(bx,bw,true)}}}})}b.fn.extend({on:function(bw,e,bz,by,bv){var bA,bx;if(typeof bw==="object"){if(typeof e!=="string"){bz=e;e=L}for(bx in bw){this.on(bx,e,bz,bw[bx],bv)}return this}if(bz==null&&by==null){by=e;bz=e=L}else{if(by==null){if(typeof e==="string"){by=bz;bz=L}else{by=bz;bz=e;e=L}}}if(by===false){by=bk}else{if(!by){return this}}if(bv===1){bA=by;by=function(bB){b().off(bB);return bA.apply(this,arguments)};by.guid=bA.guid||(bA.guid=b.guid++)}return this.each(function(){b.event.add(this,bw,by,bz,e)})},one:function(bv,e,bx,bw){return this.on.call(this,bv,e,bx,bw,1)},off:function(bw,e,by){if(bw&&bw.preventDefault&&bw.handleObj){var bv=bw.handleObj;b(bw.delegateTarget).off(bv.namespace?bv.type+"."+bv.namespace:bv.type,bv.selector,bv.handler);return this}if(typeof bw==="object"){for(var bx in bw){this.off(bx,e,bw[bx])}return this}if(e===false||typeof e==="function"){by=e;e=L}if(by===false){by=bk}return this.each(function(){b.event.remove(this,bw,by,e)})},bind:function(e,bw,bv){return this.on(e,null,bw,bv)},unbind:function(e,bv){return this.off(e,null,bv)},live:function(e,bw,bv){b(this.context).on(e,this.selector,bw,bv);return this},die:function(e,bv){b(this.context).off(e,this.selector||"**",bv);return this},delegate:function(e,bv,bx,bw){return this.on(bv,e,bx,bw)},undelegate:function(e,bv,bw){return arguments.length==1?this.off(e,"**"):this.off(bv,e,bw)},trigger:function(e,bv){return this.each(function(){b.event.trigger(e,bv,this)})},triggerHandler:function(e,bv){if(this[0]){return b.event.trigger(e,bv,this[0],true)}},toggle:function(bx){var bv=arguments,e=bx.guid||b.guid++,bw=0,by=function(bz){var bA=(b._data(this,"lastToggle"+bx.guid)||0)%bw;b._data(this,"lastToggle"+bx.guid,bA+1);bz.preventDefault();return bv[bA].apply(this,arguments)||false};by.guid=e;while(bw<bv.length){bv[bw++].guid=e}return this.click(by)},hover:function(e,bv){return this.mouseenter(e).mouseleave(bv||e)}});b.each(("blur focus focusin focusout load resize scroll unload click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup error contextmenu").split(" "),function(bv,e){b.fn[e]=function(bx,bw){if(bw==null){bw=bx;bx=null}return arguments.length>0?this.on(e,null,bx,bw):this.trigger(e)};if(b.attrFn){b.attrFn[e]=true}if(aO.test(e)){b.event.fixHooks[e]=b.event.keyHooks}if(bf.test(e)){b.event.fixHooks[e]=b.event.mouseHooks}});
-/*
- * Sizzle CSS Selector Engine
- * Copyright 2011, The Dojo Foundation
- * Released under the MIT, BSD, and GPL Licenses.
- * More information: http://sizzlejs.com/
- */
-(function(){var bH=/((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,bC="sizcache"+(Math.random()+"").replace(".",""),bI=0,bL=Object.prototype.toString,bB=false,bA=true,bK=/\\/g,bO=/\r\n/g,bQ=/\W/;[0,0].sort(function(){bA=false;return 0});var by=function(bV,e,bY,bZ){bY=bY||[];e=e||av;var b1=e;if(e.nodeType!==1&&e.nodeType!==9){return[]}if(!bV||typeof bV!=="string"){return bY}var bS,b3,b6,bR,b2,b5,b4,bX,bU=true,bT=by.isXML(e),bW=[],b0=bV;do{bH.exec("");bS=bH.exec(b0);if(bS){b0=bS[3];bW.push(bS[1]);if(bS[2]){bR=bS[3];break}}}while(bS);if(bW.length>1&&bD.exec(bV)){if(bW.length===2&&bE.relative[bW[0]]){b3=bM(bW[0]+bW[1],e,bZ)}else{b3=bE.relative[bW[0]]?[e]:by(bW.shift(),e);while(bW.length){bV=bW.shift();if(bE.relative[bV]){bV+=bW.shift()}b3=bM(bV,b3,bZ)}}}else{if(!bZ&&bW.length>1&&e.nodeType===9&&!bT&&bE.match.ID.test(bW[0])&&!bE.match.ID.test(bW[bW.length-1])){b2=by.find(bW.shift(),e,bT);e=b2.expr?by.filter(b2.expr,b2.set)[0]:b2.set[0]}if(e){b2=bZ?{expr:bW.pop(),set:bF(bZ)}:by.find(bW.pop(),bW.length===1&&(bW[0]==="~"||bW[0]==="+")&&e.parentNode?e.parentNode:e,bT);b3=b2.expr?by.filter(b2.expr,b2.set):b2.set;if(bW.length>0){b6=bF(b3)}else{bU=false}while(bW.length){b5=bW.pop();b4=b5;if(!bE.relative[b5]){b5=""}else{b4=bW.pop()}if(b4==null){b4=e}bE.relative[b5](b6,b4,bT)}}else{b6=bW=[]}}if(!b6){b6=b3}if(!b6){by.error(b5||bV)}if(bL.call(b6)==="[object Array]"){if(!bU){bY.push.apply(bY,b6)}else{if(e&&e.nodeType===1){for(bX=0;b6[bX]!=null;bX++){if(b6[bX]&&(b6[bX]===true||b6[bX].nodeType===1&&by.contains(e,b6[bX]))){bY.push(b3[bX])}}}else{for(bX=0;b6[bX]!=null;bX++){if(b6[bX]&&b6[bX].nodeType===1){bY.push(b3[bX])}}}}}else{bF(b6,bY)}if(bR){by(bR,b1,bY,bZ);by.uniqueSort(bY)}return bY};by.uniqueSort=function(bR){if(bJ){bB=bA;bR.sort(bJ);if(bB){for(var e=1;e<bR.length;e++){if(bR[e]===bR[e-1]){bR.splice(e--,1)}}}}return bR};by.matches=function(e,bR){return by(e,null,null,bR)};by.matchesSelector=function(e,bR){return by(bR,null,null,[e]).length>0};by.find=function(bX,e,bY){var bW,bS,bU,bT,bV,bR;if(!bX){return[]}for(bS=0,bU=bE.order.length;bS<bU;bS++){bV=bE.order[bS];if((bT=bE.leftMatch[bV].exec(bX))){bR=bT[1];bT.splice(1,1);if(bR.substr(bR.length-1)!=="\\"){bT[1]=(bT[1]||"").replace(bK,"");bW=bE.find[bV](bT,e,bY);if(bW!=null){bX=bX.replace(bE.match[bV],"");break}}}}if(!bW){bW=typeof e.getElementsByTagName!=="undefined"?e.getElementsByTagName("*"):[]}return{set:bW,expr:bX}};by.filter=function(b1,b0,b4,bU){var bW,e,bZ,b6,b3,bR,bT,bV,b2,bS=b1,b5=[],bY=b0,bX=b0&&b0[0]&&by.isXML(b0[0]);while(b1&&b0.length){for(bZ in bE.filter){if((bW=bE.leftMatch[bZ].exec(b1))!=null&&bW[2]){bR=bE.filter[bZ];bT=bW[1];e=false;bW.splice(1,1);if(bT.substr(bT.length-1)==="\\"){continue}if(bY===b5){b5=[]}if(bE.preFilter[bZ]){bW=bE.preFilter[bZ](bW,bY,b4,b5,bU,bX);if(!bW){e=b6=true}else{if(bW===true){continue}}}if(bW){for(bV=0;(b3=bY[bV])!=null;bV++){if(b3){b6=bR(b3,bW,bV,bY);b2=bU^b6;if(b4&&b6!=null){if(b2){e=true}else{bY[bV]=false}}else{if(b2){b5.push(b3);e=true}}}}}if(b6!==L){if(!b4){bY=b5}b1=b1.replace(bE.match[bZ],"");if(!e){return[]}break}}}if(b1===bS){if(e==null){by.error(b1)}else{break}}bS=b1}return bY};by.error=function(e){throw new Error("Syntax error, unrecognized expression: "+e)};var bw=by.getText=function(bU){var bS,bT,e=bU.nodeType,bR="";if(e){if(e===1||e===9){if(typeof bU.textContent==="string"){return bU.textContent}else{if(typeof bU.innerText==="string"){return bU.innerText.replace(bO,"")}else{for(bU=bU.firstChild;bU;bU=bU.nextSibling){bR+=bw(bU)}}}}else{if(e===3||e===4){return bU.nodeValue}}}else{for(bS=0;(bT=bU[bS]);bS++){if(bT.nodeType!==8){bR+=bw(bT)}}}return bR};var bE=by.selectors={order:["ID","NAME","TAG"],match:{ID:/#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,CLASS:/\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,NAME:/\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,ATTR:/\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/,TAG:/^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,CHILD:/:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/,POS:/:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,PSEUDO:/:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/},leftMatch:{},attrMap:{"class":"className","for":"htmlFor"},attrHandle:{href:function(e){return e.getAttribute("href")},type:function(e){return e.getAttribute("type")}},relative:{"+":function(bW,bR){var bT=typeof bR==="string",bV=bT&&!bQ.test(bR),bX=bT&&!bV;if(bV){bR=bR.toLowerCase()}for(var bS=0,e=bW.length,bU;bS<e;bS++){if((bU=bW[bS])){while((bU=bU.previousSibling)&&bU.nodeType!==1){}bW[bS]=bX||bU&&bU.nodeName.toLowerCase()===bR?bU||false:bU===bR}}if(bX){by.filter(bR,bW,true)}},">":function(bW,bR){var bV,bU=typeof bR==="string",bS=0,e=bW.length;if(bU&&!bQ.test(bR)){bR=bR.toLowerCase();for(;bS<e;bS++){bV=bW[bS];if(bV){var bT=bV.parentNode;bW[bS]=bT.nodeName.toLowerCase()===bR?bT:false}}}else{for(;bS<e;bS++){bV=bW[bS];if(bV){bW[bS]=bU?bV.parentNode:bV.parentNode===bR}}if(bU){by.filter(bR,bW,true)}}},"":function(bT,bR,bV){var bU,bS=bI++,e=bN;if(typeof bR==="string"&&!bQ.test(bR)){bR=bR.toLowerCase();bU=bR;e=bv}e("parentNode",bR,bS,bT,bU,bV)},"~":function(bT,bR,bV){var bU,bS=bI++,e=bN;if(typeof bR==="string"&&!bQ.test(bR)){bR=bR.toLowerCase();bU=bR;e=bv}e("previousSibling",bR,bS,bT,bU,bV)}},find:{ID:function(bR,bS,bT){if(typeof bS.getElementById!=="undefined"&&!bT){var e=bS.getElementById(bR[1]);return e&&e.parentNode?[e]:[]}},NAME:function(bS,bV){if(typeof bV.getElementsByName!=="undefined"){var bR=[],bU=bV.getElementsByName(bS[1]);for(var bT=0,e=bU.length;bT<e;bT++){if(bU[bT].getAttribute("name")===bS[1]){bR.push(bU[bT])}}return bR.length===0?null:bR}},TAG:function(e,bR){if(typeof bR.getElementsByTagName!=="undefined"){return bR.getElementsByTagName(e[1])}}},preFilter:{CLASS:function(bT,bR,bS,e,bW,bX){bT=" "+bT[1].replace(bK,"")+" ";if(bX){return bT}for(var bU=0,bV;(bV=bR[bU])!=null;bU++){if(bV){if(bW^(bV.className&&(" "+bV.className+" ").replace(/[\t\n\r]/g," ").indexOf(bT)>=0)){if(!bS){e.push(bV)}}else{if(bS){bR[bU]=false}}}}return false},ID:function(e){return e[1].replace(bK,"")},TAG:function(bR,e){return bR[1].replace(bK,"").toLowerCase()},CHILD:function(e){if(e[1]==="nth"){if(!e[2]){by.error(e[0])}e[2]=e[2].replace(/^\+|\s*/g,"");var bR=/(-?)(\d*)(?:n([+\-]?\d*))?/.exec(e[2]==="even"&&"2n"||e[2]==="odd"&&"2n+1"||!/\D/.test(e[2])&&"0n+"+e[2]||e[2]);e[2]=(bR[1]+(bR[2]||1))-0;e[3]=bR[3]-0}else{if(e[2]){by.error(e[0])}}e[0]=bI++;return e},ATTR:function(bU,bR,bS,e,bV,bW){var bT=bU[1]=bU[1].replace(bK,"");if(!bW&&bE.attrMap[bT]){bU[1]=bE.attrMap[bT]}bU[4]=(bU[4]||bU[5]||"").replace(bK,"");if(bU[2]==="~="){bU[4]=" "+bU[4]+" "}return bU},PSEUDO:function(bU,bR,bS,e,bV){if(bU[1]==="not"){if((bH.exec(bU[3])||"").length>1||/^\w/.test(bU[3])){bU[3]=by(bU[3],null,null,bR)}else{var bT=by.filter(bU[3],bR,bS,true^bV);if(!bS){e.push.apply(e,bT)}return false}}else{if(bE.match.POS.test(bU[0])||bE.match.CHILD.test(bU[0])){return true}}return bU},POS:function(e){e.unshift(true);return e}},filters:{enabled:function(e){return e.disabled===false&&e.type!=="hidden"},disabled:function(e){return e.disabled===true},checked:function(e){return e.checked===true},selected:function(e){if(e.parentNode){e.parentNode.selectedIndex}return e.selected===true},parent:function(e){return !!e.firstChild},empty:function(e){return !e.firstChild},has:function(bS,bR,e){return !!by(e[3],bS).length},header:function(e){return(/h\d/i).test(e.nodeName)},text:function(bS){var e=bS.getAttribute("type"),bR=bS.type;return bS.nodeName.toLowerCase()==="input"&&"text"===bR&&(e===bR||e===null)},radio:function(e){return e.nodeName.toLowerCase()==="input"&&"radio"===e.type},checkbox:function(e){return e.nodeName.toLowerCase()==="input"&&"checkbox"===e.type},file:function(e){return e.nodeName.toLowerCase()==="input"&&"file"===e.type},password:function(e){return e.nodeName.toLowerCase()==="input"&&"password"===e.type},submit:function(bR){var e=bR.nodeName.toLowerCase();return(e==="input"||e==="button")&&"submit"===bR.type},image:function(e){return e.nodeName.toLowerCase()==="input"&&"image"===e.type},reset:function(bR){var e=bR.nodeName.toLowerCase();return(e==="input"||e==="button")&&"reset"===bR.type},button:function(bR){var e=bR.nodeName.toLowerCase();return e==="input"&&"button"===bR.type||e==="button"},input:function(e){return(/input|select|textarea|button/i).test(e.nodeName)},focus:function(e){return e===e.ownerDocument.activeElement}},setFilters:{first:function(bR,e){return e===0},last:function(bS,bR,e,bT){return bR===bT.length-1},even:function(bR,e){return e%2===0},odd:function(bR,e){return e%2===1},lt:function(bS,bR,e){return bR<e[3]-0},gt:function(bS,bR,e){return bR>e[3]-0},nth:function(bS,bR,e){return e[3]-0===bR},eq:function(bS,bR,e){return e[3]-0===bR}},filter:{PSEUDO:function(bS,bX,bW,bY){var e=bX[1],bR=bE.filters[e];if(bR){return bR(bS,bW,bX,bY)}else{if(e==="contains"){return(bS.textContent||bS.innerText||bw([bS])||"").indexOf(bX[3])>=0}else{if(e==="not"){var bT=bX[3];for(var bV=0,bU=bT.length;bV<bU;bV++){if(bT[bV]===bS){return false}}return true}else{by.error(e)}}}},CHILD:function(bS,bU){var bT,b0,bW,bZ,e,bV,bY,bX=bU[1],bR=bS;switch(bX){case"only":case"first":while((bR=bR.previousSibling)){if(bR.nodeType===1){return false}}if(bX==="first"){return true}bR=bS;case"last":while((bR=bR.nextSibling)){if(bR.nodeType===1){return false}}return true;case"nth":bT=bU[2];b0=bU[3];if(bT===1&&b0===0){return true}bW=bU[0];bZ=bS.parentNode;if(bZ&&(bZ[bC]!==bW||!bS.nodeIndex)){bV=0;for(bR=bZ.firstChild;bR;bR=bR.nextSibling){if(bR.nodeType===1){bR.nodeIndex=++bV}}bZ[bC]=bW}bY=bS.nodeIndex-b0;if(bT===0){return bY===0}else{return(bY%bT===0&&bY/bT>=0)}}},ID:function(bR,e){return bR.nodeType===1&&bR.getAttribute("id")===e},TAG:function(bR,e){return(e==="*"&&bR.nodeType===1)||!!bR.nodeName&&bR.nodeName.toLowerCase()===e},CLASS:function(bR,e){return(" "+(bR.className||bR.getAttribute("class"))+" ").indexOf(e)>-1},ATTR:function(bV,bT){var bS=bT[1],e=by.attr?by.attr(bV,bS):bE.attrHandle[bS]?bE.attrHandle[bS](bV):bV[bS]!=null?bV[bS]:bV.getAttribute(bS),bW=e+"",bU=bT[2],bR=bT[4];return e==null?bU==="!=":!bU&&by.attr?e!=null:bU==="="?bW===bR:bU==="*="?bW.indexOf(bR)>=0:bU==="~="?(" "+bW+" ").indexOf(bR)>=0:!bR?bW&&e!==false:bU==="!="?bW!==bR:bU==="^="?bW.indexOf(bR)===0:bU==="$="?bW.substr(bW.length-bR.length)===bR:bU==="|="?bW===bR||bW.substr(0,bR.length+1)===bR+"-":false},POS:function(bU,bR,bS,bV){var e=bR[2],bT=bE.setFilters[e];if(bT){return bT(bU,bS,bR,bV)}}}};var bD=bE.match.POS,bx=function(bR,e){return"\\"+(e-0+1)};for(var bz in bE.match){bE.match[bz]=new RegExp(bE.match[bz].source+(/(?![^\[]*\])(?![^\(]*\))/.source));bE.leftMatch[bz]=new RegExp(/(^(?:.|\r|\n)*?)/.source+bE.match[bz].source.replace(/\\(\d+)/g,bx))}var bF=function(bR,e){bR=Array.prototype.slice.call(bR,0);if(e){e.push.apply(e,bR);return e}return bR};try{Array.prototype.slice.call(av.documentElement.childNodes,0)[0].nodeType}catch(bP){bF=function(bU,bT){var bS=0,bR=bT||[];if(bL.call(bU)==="[object Array]"){Array.prototype.push.apply(bR,bU)}else{if(typeof bU.length==="number"){for(var e=bU.length;bS<e;bS++){bR.push(bU[bS])}}else{for(;bU[bS];bS++){bR.push(bU[bS])}}}return bR}}var bJ,bG;if(av.documentElement.compareDocumentPosition){bJ=function(bR,e){if(bR===e){bB=true;return 0}if(!bR.compareDocumentPosition||!e.compareDocumentPosition){return bR.compareDocumentPosition?-1:1}return bR.compareDocumentPosition(e)&4?-1:1}}else{bJ=function(bY,bX){if(bY===bX){bB=true;return 0}else{if(bY.sourceIndex&&bX.sourceIndex){return bY.sourceIndex-bX.sourceIndex}}var bV,bR,bS=[],e=[],bU=bY.parentNode,bW=bX.parentNode,bZ=bU;if(bU===bW){return bG(bY,bX)}else{if(!bU){return -1}else{if(!bW){return 1}}}while(bZ){bS.unshift(bZ);bZ=bZ.parentNode}bZ=bW;while(bZ){e.unshift(bZ);bZ=bZ.parentNode}bV=bS.length;bR=e.length;for(var bT=0;bT<bV&&bT<bR;bT++){if(bS[bT]!==e[bT]){return bG(bS[bT],e[bT])}}return bT===bV?bG(bY,e[bT],-1):bG(bS[bT],bX,1)};bG=function(bR,e,bS){if(bR===e){return bS}var bT=bR.nextSibling;while(bT){if(bT===e){return -1}bT=bT.nextSibling}return 1}}(function(){var bR=av.createElement("div"),bS="script"+(new Date()).getTime(),e=av.documentElement;bR.innerHTML="<a name='"+bS+"'/>";e.insertBefore(bR,e.firstChild);if(av.getElementById(bS)){bE.find.ID=function(bU,bV,bW){if(typeof bV.getElementById!=="undefined"&&!bW){var bT=bV.getElementById(bU[1]);return bT?bT.id===bU[1]||typeof bT.getAttributeNode!=="undefined"&&bT.getAttributeNode("id").nodeValue===bU[1]?[bT]:L:[]}};bE.filter.ID=function(bV,bT){var bU=typeof bV.getAttributeNode!=="undefined"&&bV.getAttributeNode("id");return bV.nodeType===1&&bU&&bU.nodeValue===bT}}e.removeChild(bR);e=bR=null})();(function(){var e=av.createElement("div");e.appendChild(av.createComment(""));if(e.getElementsByTagName("*").length>0){bE.find.TAG=function(bR,bV){var bU=bV.getElementsByTagName(bR[1]);if(bR[1]==="*"){var bT=[];for(var bS=0;bU[bS];bS++){if(bU[bS].nodeType===1){bT.push(bU[bS])}}bU=bT}return bU}}e.innerHTML="<a href='#'></a>";if(e.firstChild&&typeof e.firstChild.getAttribute!=="undefined"&&e.firstChild.getAttribute("href")!=="#"){bE.attrHandle.href=function(bR){return bR.getAttribute("href",2)}}e=null})();if(av.querySelectorAll){(function(){var e=by,bT=av.createElement("div"),bS="__sizzle__";bT.innerHTML="<p class='TEST'></p>";if(bT.querySelectorAll&&bT.querySelectorAll(".TEST").length===0){return}by=function(b4,bV,bZ,b3){bV=bV||av;if(!b3&&!by.isXML(bV)){var b2=/^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec(b4);if(b2&&(bV.nodeType===1||bV.nodeType===9)){if(b2[1]){return bF(bV.getElementsByTagName(b4),bZ)}else{if(b2[2]&&bE.find.CLASS&&bV.getElementsByClassName){return bF(bV.getElementsByClassName(b2[2]),bZ)}}}if(bV.nodeType===9){if(b4==="body"&&bV.body){return bF([bV.body],bZ)}else{if(b2&&b2[3]){var bY=bV.getElementById(b2[3]);if(bY&&bY.parentNode){if(bY.id===b2[3]){return bF([bY],bZ)}}else{return bF([],bZ)}}}try{return bF(bV.querySelectorAll(b4),bZ)}catch(b0){}}else{if(bV.nodeType===1&&bV.nodeName.toLowerCase()!=="object"){var bW=bV,bX=bV.getAttribute("id"),bU=bX||bS,b6=bV.parentNode,b5=/^\s*[+~]/.test(b4);if(!bX){bV.setAttribute("id",bU)}else{bU=bU.replace(/'/g,"\\$&")}if(b5&&b6){bV=bV.parentNode}try{if(!b5||b6){return bF(bV.querySelectorAll("[id='"+bU+"'] "+b4),bZ)}}catch(b1){}finally{if(!bX){bW.removeAttribute("id")}}}}}return e(b4,bV,bZ,b3)};for(var bR in e){by[bR]=e[bR]}bT=null})()}(function(){var e=av.documentElement,bS=e.matchesSelector||e.mozMatchesSelector||e.webkitMatchesSelector||e.msMatchesSelector;if(bS){var bU=!bS.call(av.createElement("div"),"div"),bR=false;try{bS.call(av.documentElement,"[test!='']:sizzle")}catch(bT){bR=true}by.matchesSelector=function(bW,bY){bY=bY.replace(/\=\s*([^'"\]]*)\s*\]/g,"='$1']");if(!by.isXML(bW)){try{if(bR||!bE.match.PSEUDO.test(bY)&&!/!=/.test(bY)){var bV=bS.call(bW,bY);if(bV||!bU||bW.document&&bW.document.nodeType!==11){return bV}}}catch(bX){}}return by(bY,null,null,[bW]).length>0}}})();(function(){var e=av.createElement("div");e.innerHTML="<div class='test e'></div><div class='test'></div>";if(!e.getElementsByClassName||e.getElementsByClassName("e").length===0){return}e.lastChild.className="e";if(e.getElementsByClassName("e").length===1){return}bE.order.splice(1,0,"CLASS");bE.find.CLASS=function(bR,bS,bT){if(typeof bS.getElementsByClassName!=="undefined"&&!bT){return bS.getElementsByClassName(bR[1])}};e=null})();function bv(bR,bW,bV,bZ,bX,bY){for(var bT=0,bS=bZ.length;bT<bS;bT++){var e=bZ[bT];if(e){var bU=false;e=e[bR];while(e){if(e[bC]===bV){bU=bZ[e.sizset];break}if(e.nodeType===1&&!bY){e[bC]=bV;e.sizset=bT}if(e.nodeName.toLowerCase()===bW){bU=e;break}e=e[bR]}bZ[bT]=bU}}}function bN(bR,bW,bV,bZ,bX,bY){for(var bT=0,bS=bZ.length;bT<bS;bT++){var e=bZ[bT];if(e){var bU=false;e=e[bR];while(e){if(e[bC]===bV){bU=bZ[e.sizset];break}if(e.nodeType===1){if(!bY){e[bC]=bV;e.sizset=bT}if(typeof bW!=="string"){if(e===bW){bU=true;break}}else{if(by.filter(bW,[e]).length>0){bU=e;break}}}e=e[bR]}bZ[bT]=bU}}}if(av.documentElement.contains){by.contains=function(bR,e){return bR!==e&&(bR.contains?bR.contains(e):true)}}else{if(av.documentElement.compareDocumentPosition){by.contains=function(bR,e){return !!(bR.compareDocumentPosition(e)&16)}}else{by.contains=function(){return false}}}by.isXML=function(e){var bR=(e?e.ownerDocument||e:0).documentElement;return bR?bR.nodeName!=="HTML":false};var bM=function(bS,e,bW){var bV,bX=[],bU="",bY=e.nodeType?[e]:e;while((bV=bE.match.PSEUDO.exec(bS))){bU+=bV[0];bS=bS.replace(bE.match.PSEUDO,"")}bS=bE.relative[bS]?bS+"*":bS;for(var bT=0,bR=bY.length;bT<bR;bT++){by(bS,bY[bT],bX,bW)}return by.filter(bU,bX)};by.attr=b.attr;by.selectors.attrMap={};b.find=by;b.expr=by.selectors;b.expr[":"]=b.expr.filters;b.unique=by.uniqueSort;b.text=by.getText;b.isXMLDoc=by.isXML;b.contains=by.contains})();var ab=/Until$/,aq=/^(?:parents|prevUntil|prevAll)/,a9=/,/,bp=/^.[^:#\[\.,]*$/,P=Array.prototype.slice,H=b.expr.match.POS,ay={children:true,contents:true,next:true,prev:true};b.fn.extend({find:function(e){var bw=this,by,bv;if(typeof e!=="string"){return b(e).filter(function(){for(by=0,bv=bw.length;by<bv;by++){if(b.contains(bw[by],this)){return true}}})}var bx=this.pushStack("","find",e),bA,bB,bz;for(by=0,bv=this.length;by<bv;by++){bA=bx.length;b.find(e,this[by],bx);if(by>0){for(bB=bA;bB<bx.length;bB++){for(bz=0;bz<bA;bz++){if(bx[bz]===bx[bB]){bx.splice(bB--,1);break}}}}}return bx},has:function(bv){var e=b(bv);return this.filter(function(){for(var bx=0,bw=e.length;bx<bw;bx++){if(b.contains(this,e[bx])){return true}}})},not:function(e){return this.pushStack(aG(this,e,false),"not",e)},filter:function(e){return this.pushStack(aG(this,e,true),"filter",e)},is:function(e){return !!e&&(typeof e==="string"?H.test(e)?b(e,this.context).index(this[0])>=0:b.filter(e,this).length>0:this.filter(e).length>0)},closest:function(by,bx){var bv=[],bw,e,bz=this[0];if(b.isArray(by)){var bB=1;while(bz&&bz.ownerDocument&&bz!==bx){for(bw=0;bw<by.length;bw++){if(b(bz).is(by[bw])){bv.push({selector:by[bw],elem:bz,level:bB})}}bz=bz.parentNode;bB++}return bv}var bA=H.test(by)||typeof by!=="string"?b(by,bx||this.context):0;for(bw=0,e=this.length;bw<e;bw++){bz=this[bw];while(bz){if(bA?bA.index(bz)>-1:b.find.matchesSelector(bz,by)){bv.push(bz);break}else{bz=bz.parentNode;if(!bz||!bz.ownerDocument||bz===bx||bz.nodeType===11){break}}}}bv=bv.length>1?b.unique(bv):bv;return this.pushStack(bv,"closest",by)},index:function(e){if(!e){return(this[0]&&this[0].parentNode)?this.prevAll().length:-1}if(typeof e==="string"){return b.inArray(this[0],b(e))}return b.inArray(e.jquery?e[0]:e,this)},add:function(e,bv){var bx=typeof e==="string"?b(e,bv):b.makeArray(e&&e.nodeType?[e]:e),bw=b.merge(this.get(),bx);return this.pushStack(C(bx[0])||C(bw[0])?bw:b.unique(bw))},andSelf:function(){return this.add(this.prevObject)}});function C(e){return !e||!e.parentNode||e.parentNode.nodeType===11}b.each({parent:function(bv){var e=bv.parentNode;return e&&e.nodeType!==11?e:null},parents:function(e){return b.dir(e,"parentNode")},parentsUntil:function(bv,e,bw){return b.dir(bv,"parentNode",bw)},next:function(e){return b.nth(e,2,"nextSibling")},prev:function(e){return b.nth(e,2,"previousSibling")},nextAll:function(e){return b.dir(e,"nextSibling")},prevAll:function(e){return b.dir(e,"previousSibling")},nextUntil:function(bv,e,bw){return b.dir(bv,"nextSibling",bw)},prevUntil:function(bv,e,bw){return b.dir(bv,"previousSibling",bw)},siblings:function(e){return b.sibling(e.parentNode.firstChild,e)},children:function(e){return b.sibling(e.firstChild)},contents:function(e){return b.nodeName(e,"iframe")?e.contentDocument||e.contentWindow.document:b.makeArray(e.childNodes)}},function(e,bv){b.fn[e]=function(by,bw){var bx=b.map(this,bv,by);if(!ab.test(e)){bw=by}if(bw&&typeof bw==="string"){bx=b.filter(bw,bx)}bx=this.length>1&&!ay[e]?b.unique(bx):bx;if((this.length>1||a9.test(bw))&&aq.test(e)){bx=bx.reverse()}return this.pushStack(bx,e,P.call(arguments).join(","))}});b.extend({filter:function(bw,e,bv){if(bv){bw=":not("+bw+")"}return e.length===1?b.find.matchesSelector(e[0],bw)?[e[0]]:[]:b.find.matches(bw,e)},dir:function(bw,bv,by){var e=[],bx=bw[bv];while(bx&&bx.nodeType!==9&&(by===L||bx.nodeType!==1||!b(bx).is(by))){if(bx.nodeType===1){e.push(bx)}bx=bx[bv]}return e},nth:function(by,e,bw,bx){e=e||1;var bv=0;for(;by;by=by[bw]){if(by.nodeType===1&&++bv===e){break}}return by},sibling:function(bw,bv){var e=[];for(;bw;bw=bw.nextSibling){if(bw.nodeType===1&&bw!==bv){e.push(bw)}}return e}});function aG(bx,bw,e){bw=bw||0;if(b.isFunction(bw)){return b.grep(bx,function(bz,by){var bA=!!bw.call(bz,by,bz);return bA===e})}else{if(bw.nodeType){return b.grep(bx,function(bz,by){return(bz===bw)===e})}else{if(typeof bw==="string"){var bv=b.grep(bx,function(by){return by.nodeType===1});if(bp.test(bw)){return b.filter(bw,bv,!e)}else{bw=b.filter(bw,bv)}}}}return b.grep(bx,function(bz,by){return(b.inArray(bz,bw)>=0)===e})}function a(e){var bw=aR.split("|"),bv=e.createDocumentFragment();if(bv.createElement){while(bw.length){bv.createElement(bw.pop())}}return bv}var aR="abbr|article|aside|audio|canvas|datalist|details|figcaption|figure|footer|header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",ag=/ jQuery\d+="(?:\d+|null)"/g,ar=/^\s+/,R=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,d=/<([\w:]+)/,w=/<tbody/i,W=/<|&#?\w+;/,ae=/<(?:script|style)/i,O=/<(?:script|object|embed|option|style)/i,ah=new RegExp("<(?:"+aR+")","i"),o=/checked\s*(?:[^=]|=\s*.checked.)/i,bm=/\/(java|ecma)script/i,aN=/^\s*<!(?:\[CDATA\[|\-\-)/,ax={option:[1,"<select multiple='multiple'>","</select>"],legend:[1,"<fieldset>","</fieldset>"],thead:[1,"<table>","</table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],col:[2,"<table><tbody></tbody><colgroup>","</colgroup></table>"],area:[1,"<map>","</map>"],_default:[0,"",""]},ac=a(av);ax.optgroup=ax.option;ax.tbody=ax.tfoot=ax.colgroup=ax.caption=ax.thead;ax.th=ax.td;if(!b.support.htmlSerialize){ax._default=[1,"div<div>","</div>"]}b.fn.extend({text:function(e){if(b.isFunction(e)){return this.each(function(bw){var bv=b(this);bv.text(e.call(this,bw,bv.text()))})}if(typeof e!=="object"&&e!==L){return this.empty().append((this[0]&&this[0].ownerDocument||av).createTextNode(e))}return b.text(this)},wrapAll:function(e){if(b.isFunction(e)){return this.each(function(bw){b(this).wrapAll(e.call(this,bw))})}if(this[0]){var bv=b(e,this[0].ownerDocument).eq(0).clone(true);if(this[0].parentNode){bv.insertBefore(this[0])}bv.map(function(){var bw=this;while(bw.firstChild&&bw.firstChild.nodeType===1){bw=bw.firstChild}return bw}).append(this)}return this},wrapInner:function(e){if(b.isFunction(e)){return this.each(function(bv){b(this).wrapInner(e.call(this,bv))})}return this.each(function(){var bv=b(this),bw=bv.contents();if(bw.length){bw.wrapAll(e)}else{bv.append(e)}})},wrap:function(e){var bv=b.isFunction(e);return this.each(function(bw){b(this).wrapAll(bv?e.call(this,bw):e)})},unwrap:function(){return this.parent().each(function(){if(!b.nodeName(this,"body")){b(this).replaceWith(this.childNodes)}}).end()},append:function(){return this.domManip(arguments,true,function(e){if(this.nodeType===1){this.appendChild(e)}})},prepend:function(){return this.domManip(arguments,true,function(e){if(this.nodeType===1){this.insertBefore(e,this.firstChild)}})},before:function(){if(this[0]&&this[0].parentNode){return this.domManip(arguments,false,function(bv){this.parentNode.insertBefore(bv,this)})}else{if(arguments.length){var e=b.clean(arguments);e.push.apply(e,this.toArray());return this.pushStack(e,"before",arguments)}}},after:function(){if(this[0]&&this[0].parentNode){return this.domManip(arguments,false,function(bv){this.parentNode.insertBefore(bv,this.nextSibling)})}else{if(arguments.length){var e=this.pushStack(this,"after",arguments);e.push.apply(e,b.clean(arguments));return e}}},remove:function(e,bx){for(var bv=0,bw;(bw=this[bv])!=null;bv++){if(!e||b.filter(e,[bw]).length){if(!bx&&bw.nodeType===1){b.cleanData(bw.getElementsByTagName("*"));b.cleanData([bw])}if(bw.parentNode){bw.parentNode.removeChild(bw)}}}return this},empty:function(){for(var e=0,bv;(bv=this[e])!=null;e++){if(bv.nodeType===1){b.cleanData(bv.getElementsByTagName("*"))}while(bv.firstChild){bv.removeChild(bv.firstChild)}}return this},clone:function(bv,e){bv=bv==null?false:bv;e=e==null?bv:e;return this.map(function(){return b.clone(this,bv,e)})},html:function(bx){if(bx===L){return this[0]&&this[0].nodeType===1?this[0].innerHTML.replace(ag,""):null}else{if(typeof bx==="string"&&!ae.test(bx)&&(b.support.leadingWhitespace||!ar.test(bx))&&!ax[(d.exec(bx)||["",""])[1].toLowerCase()]){bx=bx.replace(R,"<$1></$2>");try{for(var bw=0,bv=this.length;bw<bv;bw++){if(this[bw].nodeType===1){b.cleanData(this[bw].getElementsByTagName("*"));this[bw].innerHTML=bx}}}catch(by){this.empty().append(bx)}}else{if(b.isFunction(bx)){this.each(function(bz){var e=b(this);e.html(bx.call(this,bz,e.html()))})}else{this.empty().append(bx)}}}return this},replaceWith:function(e){if(this[0]&&this[0].parentNode){if(b.isFunction(e)){return this.each(function(bx){var bw=b(this),bv=bw.html();bw.replaceWith(e.call(this,bx,bv))})}if(typeof e!=="string"){e=b(e).detach()}return this.each(function(){var bw=this.nextSibling,bv=this.parentNode;b(this).remove();if(bw){b(bw).before(e)}else{b(bv).append(e)}})}else{return this.length?this.pushStack(b(b.isFunction(e)?e():e),"replaceWith",e):this}},detach:function(e){return this.remove(e,true)},domManip:function(bB,bF,bE){var bx,by,bA,bD,bC=bB[0],bv=[];if(!b.support.checkClone&&arguments.length===3&&typeof bC==="string"&&o.test(bC)){return this.each(function(){b(this).domManip(bB,bF,bE,true)})}if(b.isFunction(bC)){return this.each(function(bH){var bG=b(this);bB[0]=bC.call(this,bH,bF?bG.html():L);bG.domManip(bB,bF,bE)})}if(this[0]){bD=bC&&bC.parentNode;if(b.support.parentNode&&bD&&bD.nodeType===11&&bD.childNodes.length===this.length){bx={fragment:bD}}else{bx=b.buildFragment(bB,this,bv)}bA=bx.fragment;if(bA.childNodes.length===1){by=bA=bA.firstChild}else{by=bA.firstChild}if(by){bF=bF&&b.nodeName(by,"tr");for(var bw=0,e=this.length,bz=e-1;bw<e;bw++){bE.call(bF?ba(this[bw],by):this[bw],bx.cacheable||(e>1&&bw<bz)?b.clone(bA,true,true):bA)}}if(bv.length){b.each(bv,bo)}}return this}});function ba(e,bv){return b.nodeName(e,"table")?(e.getElementsByTagName("tbody")[0]||e.appendChild(e.ownerDocument.createElement("tbody"))):e}function t(bB,bv){if(bv.nodeType!==1||!b.hasData(bB)){return}var by,bx,e,bA=b._data(bB),bz=b._data(bv,bA),bw=bA.events;if(bw){delete bz.handle;bz.events={};for(by in bw){for(bx=0,e=bw[by].length;bx<e;bx++){b.event.add(bv,by+(bw[by][bx].namespace?".":"")+bw[by][bx].namespace,bw[by][bx],bw[by][bx].data)}}}if(bz.data){bz.data=b.extend({},bz.data)}}function ai(bv,e){var bw;if(e.nodeType!==1){return}if(e.clearAttributes){e.clearAttributes()}if(e.mergeAttributes){e.mergeAttributes(bv)}bw=e.nodeName.toLowerCase();if(bw==="object"){e.outerHTML=bv.outerHTML}else{if(bw==="input"&&(bv.type==="checkbox"||bv.type==="radio")){if(bv.checked){e.defaultChecked=e.checked=bv.checked}if(e.value!==bv.value){e.value=bv.value}}else{if(bw==="option"){e.selected=bv.defaultSelected}else{if(bw==="input"||bw==="textarea"){e.defaultValue=bv.defaultValue}}}}e.removeAttribute(b.expando)}b.buildFragment=function(bz,bx,bv){var by,e,bw,bA,bB=bz[0];if(bx&&bx[0]){bA=bx[0].ownerDocument||bx[0]}if(!bA.createDocumentFragment){bA=av}if(bz.length===1&&typeof bB==="string"&&bB.length<512&&bA===av&&bB.charAt(0)==="<"&&!O.test(bB)&&(b.support.checkClone||!o.test(bB))&&(b.support.html5Clone||!ah.test(bB))){e=true;bw=b.fragments[bB];if(bw&&bw!==1){by=bw}}if(!by){by=bA.createDocumentFragment();b.clean(bz,bA,by,bv)}if(e){b.fragments[bB]=bw?by:1}return{fragment:by,cacheable:e}};b.fragments={};b.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(e,bv){b.fn[e]=function(bw){var bz=[],bC=b(bw),bB=this.length===1&&this[0].parentNode;if(bB&&bB.nodeType===11&&bB.childNodes.length===1&&bC.length===1){bC[bv](this[0]);return this}else{for(var bA=0,bx=bC.length;bA<bx;bA++){var by=(bA>0?this.clone(true):this).get();b(bC[bA])[bv](by);bz=bz.concat(by)}return this.pushStack(bz,e,bC.selector)}}});function bg(e){if(typeof e.getElementsByTagName!=="undefined"){return e.getElementsByTagName("*")}else{if(typeof e.querySelectorAll!=="undefined"){return e.querySelectorAll("*")}else{return[]}}}function az(e){if(e.type==="checkbox"||e.type==="radio"){e.defaultChecked=e.checked}}function E(e){var bv=(e.nodeName||"").toLowerCase();if(bv==="input"){az(e)}else{if(bv!=="script"&&typeof e.getElementsByTagName!=="undefined"){b.grep(e.getElementsByTagName("input"),az)}}}function al(e){var bv=av.createElement("div");ac.appendChild(bv);bv.innerHTML=e.outerHTML;return bv.firstChild}b.extend({clone:function(by,bA,bw){var e,bv,bx,bz=b.support.html5Clone||!ah.test("<"+by.nodeName)?by.cloneNode(true):al(by);if((!b.support.noCloneEvent||!b.support.noCloneChecked)&&(by.nodeType===1||by.nodeType===11)&&!b.isXMLDoc(by)){ai(by,bz);e=bg(by);bv=bg(bz);for(bx=0;e[bx];++bx){if(bv[bx]){ai(e[bx],bv[bx])}}}if(bA){t(by,bz);if(bw){e=bg(by);bv=bg(bz);for(bx=0;e[bx];++bx){t(e[bx],bv[bx])}}}e=bv=null;return bz},clean:function(bw,by,bH,bA){var bF;by=by||av;if(typeof by.createElement==="undefined"){by=by.ownerDocument||by[0]&&by[0].ownerDocument||av}var bI=[],bB;for(var bE=0,bz;(bz=bw[bE])!=null;bE++){if(typeof bz==="number"){bz+=""}if(!bz){continue}if(typeof bz==="string"){if(!W.test(bz)){bz=by.createTextNode(bz)}else{bz=bz.replace(R,"<$1></$2>");var bK=(d.exec(bz)||["",""])[1].toLowerCase(),bx=ax[bK]||ax._default,bD=bx[0],bv=by.createElement("div");if(by===av){ac.appendChild(bv)}else{a(by).appendChild(bv)}bv.innerHTML=bx[1]+bz+bx[2];while(bD--){bv=bv.lastChild}if(!b.support.tbody){var e=w.test(bz),bC=bK==="table"&&!e?bv.firstChild&&bv.firstChild.childNodes:bx[1]==="<table>"&&!e?bv.childNodes:[];for(bB=bC.length-1;bB>=0;--bB){if(b.nodeName(bC[bB],"tbody")&&!bC[bB].childNodes.length){bC[bB].parentNode.removeChild(bC[bB])}}}if(!b.support.leadingWhitespace&&ar.test(bz)){bv.insertBefore(by.createTextNode(ar.exec(bz)[0]),bv.firstChild)}bz=bv.childNodes}}var bG;if(!b.support.appendChecked){if(bz[0]&&typeof(bG=bz.length)==="number"){for(bB=0;bB<bG;bB++){E(bz[bB])}}else{E(bz)}}if(bz.nodeType){bI.push(bz)}else{bI=b.merge(bI,bz)}}if(bH){bF=function(bL){return !bL.type||bm.test(bL.type)};for(bE=0;bI[bE];bE++){if(bA&&b.nodeName(bI[bE],"script")&&(!bI[bE].type||bI[bE].type.toLowerCase()==="text/javascript")){bA.push(bI[bE].parentNode?bI[bE].parentNode.removeChild(bI[bE]):bI[bE])}else{if(bI[bE].nodeType===1){var bJ=b.grep(bI[bE].getElementsByTagName("script"),bF);bI.splice.apply(bI,[bE+1,0].concat(bJ))}bH.appendChild(bI[bE])}}}return bI},cleanData:function(bv){var by,bw,e=b.cache,bB=b.event.special,bA=b.support.deleteExpando;for(var bz=0,bx;(bx=bv[bz])!=null;bz++){if(bx.nodeName&&b.noData[bx.nodeName.toLowerCase()]){continue}bw=bx[b.expando];if(bw){by=e[bw];if(by&&by.events){for(var bC in by.events){if(bB[bC]){b.event.remove(bx,bC)}else{b.removeEvent(bx,bC,by.handle)}}if(by.handle){by.handle.elem=null}}if(bA){delete bx[b.expando]}else{if(bx.removeAttribute){bx.removeAttribute(b.expando)}}delete e[bw]}}}});function bo(e,bv){if(bv.src){b.ajax({url:bv.src,async:false,dataType:"script"})}else{b.globalEval((bv.text||bv.textContent||bv.innerHTML||"").replace(aN,"/*$0*/"))}if(bv.parentNode){bv.parentNode.removeChild(bv)}}var ak=/alpha\([^)]*\)/i,au=/opacity=([^)]*)/,z=/([A-Z]|^ms)/g,bc=/^-?\d+(?:px)?$/i,bn=/^-?\d/,I=/^([\-+])=([\-+.\de]+)/,a7={position:"absolute",visibility:"hidden",display:"block"},an=["Left","Right"],a1=["Top","Bottom"],Z,aI,aX;b.fn.css=function(e,bv){if(arguments.length===2&&bv===L){return this}return b.access(this,e,bv,true,function(bx,bw,by){return by!==L?b.style(bx,bw,by):b.css(bx,bw)})};b.extend({cssHooks:{opacity:{get:function(bw,bv){if(bv){var e=Z(bw,"opacity","opacity");return e===""?"1":e}else{return bw.style.opacity}}}},cssNumber:{fillOpacity:true,fontWeight:true,lineHeight:true,opacity:true,orphans:true,widows:true,zIndex:true,zoom:true},cssProps:{"float":b.support.cssFloat?"cssFloat":"styleFloat"},style:function(bx,bw,bD,by){if(!bx||bx.nodeType===3||bx.nodeType===8||!bx.style){return}var bB,bC,bz=b.camelCase(bw),bv=bx.style,bE=b.cssHooks[bz];bw=b.cssProps[bz]||bz;if(bD!==L){bC=typeof bD;if(bC==="string"&&(bB=I.exec(bD))){bD=(+(bB[1]+1)*+bB[2])+parseFloat(b.css(bx,bw));bC="number"}if(bD==null||bC==="number"&&isNaN(bD)){return}if(bC==="number"&&!b.cssNumber[bz]){bD+="px"}if(!bE||!("set" in bE)||(bD=bE.set(bx,bD))!==L){try{bv[bw]=bD}catch(bA){}}}else{if(bE&&"get" in bE&&(bB=bE.get(bx,false,by))!==L){return bB}return bv[bw]}},css:function(by,bx,bv){var bw,e;bx=b.camelCase(bx);e=b.cssHooks[bx];bx=b.cssProps[bx]||bx;if(bx==="cssFloat"){bx="float"}if(e&&"get" in e&&(bw=e.get(by,true,bv))!==L){return bw}else{if(Z){return Z(by,bx)}}},swap:function(bx,bw,by){var e={};for(var bv in bw){e[bv]=bx.style[bv];bx.style[bv]=bw[bv]}by.call(bx);for(bv in bw){bx.style[bv]=e[bv]}}});b.curCSS=b.css;b.each(["height","width"],function(bv,e){b.cssHooks[e]={get:function(by,bx,bw){var bz;if(bx){if(by.offsetWidth!==0){return p(by,e,bw)}else{b.swap(by,a7,function(){bz=p(by,e,bw)})}return bz}},set:function(bw,bx){if(bc.test(bx)){bx=parseFloat(bx);if(bx>=0){return bx+"px"}}else{return bx}}}});if(!b.support.opacity){b.cssHooks.opacity={get:function(bv,e){return au.test((e&&bv.currentStyle?bv.currentStyle.filter:bv.style.filter)||"")?(parseFloat(RegExp.$1)/100)+"":e?"1":""},set:function(by,bz){var bx=by.style,bv=by.currentStyle,e=b.isNumeric(bz)?"alpha(opacity="+bz*100+")":"",bw=bv&&bv.filter||bx.filter||"";bx.zoom=1;if(bz>=1&&b.trim(bw.replace(ak,""))===""){bx.removeAttribute("filter");if(bv&&!bv.filter){return}}bx.filter=ak.test(bw)?bw.replace(ak,e):bw+" "+e}}}b(function(){if(!b.support.reliableMarginRight){b.cssHooks.marginRight={get:function(bw,bv){var e;b.swap(bw,{display:"inline-block"},function(){if(bv){e=Z(bw,"margin-right","marginRight")}else{e=bw.style.marginRight}});return e}}}});if(av.defaultView&&av.defaultView.getComputedStyle){aI=function(by,bw){var bv,bx,e;bw=bw.replace(z,"-$1").toLowerCase();if((bx=by.ownerDocument.defaultView)&&(e=bx.getComputedStyle(by,null))){bv=e.getPropertyValue(bw);if(bv===""&&!b.contains(by.ownerDocument.documentElement,by)){bv=b.style(by,bw)}}return bv}}if(av.documentElement.currentStyle){aX=function(bz,bw){var bA,e,by,bv=bz.currentStyle&&bz.currentStyle[bw],bx=bz.style;if(bv===null&&bx&&(by=bx[bw])){bv=by}if(!bc.test(bv)&&bn.test(bv)){bA=bx.left;e=bz.runtimeStyle&&bz.runtimeStyle.left;if(e){bz.runtimeStyle.left=bz.currentStyle.left}bx.left=bw==="fontSize"?"1em":(bv||0);bv=bx.pixelLeft+"px";bx.left=bA;if(e){bz.runtimeStyle.left=e}}return bv===""?"auto":bv}}Z=aI||aX;function p(by,bw,bv){var bA=bw==="width"?by.offsetWidth:by.offsetHeight,bz=bw==="width"?an:a1,bx=0,e=bz.length;if(bA>0){if(bv!=="border"){for(;bx<e;bx++){if(!bv){bA-=parseFloat(b.css(by,"padding"+bz[bx]))||0}if(bv==="margin"){bA+=parseFloat(b.css(by,bv+bz[bx]))||0}else{bA-=parseFloat(b.css(by,"border"+bz[bx]+"Width"))||0}}}return bA+"px"}bA=Z(by,bw,bw);if(bA<0||bA==null){bA=by.style[bw]||0}bA=parseFloat(bA)||0;if(bv){for(;bx<e;bx++){bA+=parseFloat(b.css(by,"padding"+bz[bx]))||0;if(bv!=="padding"){bA+=parseFloat(b.css(by,"border"+bz[bx]+"Width"))||0}if(bv==="margin"){bA+=parseFloat(b.css(by,bv+bz[bx]))||0}}}return bA+"px"}if(b.expr&&b.expr.filters){b.expr.filters.hidden=function(bw){var bv=bw.offsetWidth,e=bw.offsetHeight;return(bv===0&&e===0)||(!b.support.reliableHiddenOffsets&&((bw.style&&bw.style.display)||b.css(bw,"display"))==="none")};b.expr.filters.visible=function(e){return !b.expr.filters.hidden(e)}}var k=/%20/g,ap=/\[\]$/,bs=/\r?\n/g,bq=/#.*$/,aD=/^(.*?):[ \t]*([^\r\n]*)\r?$/mg,aZ=/^(?:color|date|datetime|datetime-local|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,aM=/^(?:about|app|app\-storage|.+\-extension|file|res|widget):$/,aQ=/^(?:GET|HEAD)$/,c=/^\/\//,M=/\?/,a6=/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,q=/^(?:select|textarea)/i,h=/\s+/,br=/([?&])_=[^&]*/,K=/^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/,A=b.fn.load,aa={},r={},aE,s,aV=["*/"]+["*"];try{aE=bl.href}catch(aw){aE=av.createElement("a");aE.href="";aE=aE.href}s=K.exec(aE.toLowerCase())||[];function f(e){return function(by,bA){if(typeof by!=="string"){bA=by;by="*"}if(b.isFunction(bA)){var bx=by.toLowerCase().split(h),bw=0,bz=bx.length,bv,bB,bC;for(;bw<bz;bw++){bv=bx[bw];bC=/^\+/.test(bv);if(bC){bv=bv.substr(1)||"*"}bB=e[bv]=e[bv]||[];bB[bC?"unshift":"push"](bA)}}}}function aW(bv,bE,bz,bD,bB,bx){bB=bB||bE.dataTypes[0];bx=bx||{};bx[bB]=true;var bA=bv[bB],bw=0,e=bA?bA.length:0,by=(bv===aa),bC;for(;bw<e&&(by||!bC);bw++){bC=bA[bw](bE,bz,bD);if(typeof bC==="string"){if(!by||bx[bC]){bC=L}else{bE.dataTypes.unshift(bC);bC=aW(bv,bE,bz,bD,bC,bx)}}}if((by||!bC)&&!bx["*"]){bC=aW(bv,bE,bz,bD,"*",bx)}return bC}function am(bw,bx){var bv,e,by=b.ajaxSettings.flatOptions||{};for(bv in bx){if(bx[bv]!==L){(by[bv]?bw:(e||(e={})))[bv]=bx[bv]}}if(e){b.extend(true,bw,e)}}b.fn.extend({load:function(bw,bz,bA){if(typeof bw!=="string"&&A){return A.apply(this,arguments)}else{if(!this.length){return this}}var by=bw.indexOf(" ");if(by>=0){var e=bw.slice(by,bw.length);bw=bw.slice(0,by)}var bx="GET";if(bz){if(b.isFunction(bz)){bA=bz;bz=L}else{if(typeof bz==="object"){bz=b.param(bz,b.ajaxSettings.traditional);bx="POST"}}}var bv=this;b.ajax({url:bw,type:bx,dataType:"html",data:bz,complete:function(bC,bB,bD){bD=bC.responseText;if(bC.isResolved()){bC.done(function(bE){bD=bE});bv.html(e?b("<div>").append(bD.replace(a6,"")).find(e):bD)}if(bA){bv.each(bA,[bD,bB,bC])}}});return this},serialize:function(){return b.param(this.serializeArray())},serializeArray:function(){return this.map(function(){return this.elements?b.makeArray(this.elements):this}).filter(function(){return this.name&&!this.disabled&&(this.checked||q.test(this.nodeName)||aZ.test(this.type))}).map(function(e,bv){var bw=b(this).val();return bw==null?null:b.isArray(bw)?b.map(bw,function(by,bx){return{name:bv.name,value:by.replace(bs,"\r\n")}}):{name:bv.name,value:bw.replace(bs,"\r\n")}}).get()}});b.each("ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "),function(e,bv){b.fn[bv]=function(bw){return this.on(bv,bw)}});b.each(["get","post"],function(e,bv){b[bv]=function(bw,by,bz,bx){if(b.isFunction(by)){bx=bx||bz;bz=by;by=L}return b.ajax({type:bv,url:bw,data:by,success:bz,dataType:bx})}});b.extend({getScript:function(e,bv){return b.get(e,L,bv,"script")},getJSON:function(e,bv,bw){return b.get(e,bv,bw,"json")},ajaxSetup:function(bv,e){if(e){am(bv,b.ajaxSettings)}else{e=bv;bv=b.ajaxSettings}am(bv,e);return bv},ajaxSettings:{url:aE,isLocal:aM.test(s[1]),global:true,type:"GET",contentType:"application/x-www-form-urlencoded",processData:true,async:true,accepts:{xml:"application/xml, text/xml",html:"text/html",text:"text/plain",json:"application/json, text/javascript","*":aV},contents:{xml:/xml/,html:/html/,json:/json/},responseFields:{xml:"responseXML",text:"responseText"},converters:{"* text":bb.String,"text html":true,"text json":b.parseJSON,"text xml":b.parseXML},flatOptions:{context:true,url:true}},ajaxPrefilter:f(aa),ajaxTransport:f(r),ajax:function(bz,bx){if(typeof bz==="object"){bx=bz;bz=L}bx=bx||{};var bD=b.ajaxSetup({},bx),bS=bD.context||bD,bG=bS!==bD&&(bS.nodeType||bS instanceof b)?b(bS):b.event,bR=b.Deferred(),bN=b.Callbacks("once memory"),bB=bD.statusCode||{},bC,bH={},bO={},bQ,by,bL,bE,bI,bA=0,bw,bK,bJ={readyState:0,setRequestHeader:function(bT,bU){if(!bA){var e=bT.toLowerCase();bT=bO[e]=bO[e]||bT;bH[bT]=bU}return this},getAllResponseHeaders:function(){return bA===2?bQ:null},getResponseHeader:function(bT){var e;if(bA===2){if(!by){by={};while((e=aD.exec(bQ))){by[e[1].toLowerCase()]=e[2]}}e=by[bT.toLowerCase()]}return e===L?null:e},overrideMimeType:function(e){if(!bA){bD.mimeType=e}return this},abort:function(e){e=e||"abort";if(bL){bL.abort(e)}bF(0,e);return this}};function bF(bZ,bU,b0,bW){if(bA===2){return}bA=2;if(bE){clearTimeout(bE)}bL=L;bQ=bW||"";bJ.readyState=bZ>0?4:0;var bT,b4,b3,bX=bU,bY=b0?bj(bD,bJ,b0):L,bV,b2;if(bZ>=200&&bZ<300||bZ===304){if(bD.ifModified){if((bV=bJ.getResponseHeader("Last-Modified"))){b.lastModified[bC]=bV}if((b2=bJ.getResponseHeader("Etag"))){b.etag[bC]=b2}}if(bZ===304){bX="notmodified";bT=true}else{try{b4=G(bD,bY);bX="success";bT=true}catch(b1){bX="parsererror";b3=b1}}}else{b3=bX;if(!bX||bZ){bX="error";if(bZ<0){bZ=0}}}bJ.status=bZ;bJ.statusText=""+(bU||bX);if(bT){bR.resolveWith(bS,[b4,bX,bJ])}else{bR.rejectWith(bS,[bJ,bX,b3])}bJ.statusCode(bB);bB=L;if(bw){bG.trigger("ajax"+(bT?"Success":"Error"),[bJ,bD,bT?b4:b3])}bN.fireWith(bS,[bJ,bX]);if(bw){bG.trigger("ajaxComplete",[bJ,bD]);if(!(--b.active)){b.event.trigger("ajaxStop")}}}bR.promise(bJ);bJ.success=bJ.done;bJ.error=bJ.fail;bJ.complete=bN.add;bJ.statusCode=function(bT){if(bT){var e;if(bA<2){for(e in bT){bB[e]=[bB[e],bT[e]]}}else{e=bT[bJ.status];bJ.then(e,e)}}return this};bD.url=((bz||bD.url)+"").replace(bq,"").replace(c,s[1]+"//");bD.dataTypes=b.trim(bD.dataType||"*").toLowerCase().split(h);if(bD.crossDomain==null){bI=K.exec(bD.url.toLowerCase());bD.crossDomain=!!(bI&&(bI[1]!=s[1]||bI[2]!=s[2]||(bI[3]||(bI[1]==="http:"?80:443))!=(s[3]||(s[1]==="http:"?80:443))))}if(bD.data&&bD.processData&&typeof bD.data!=="string"){bD.data=b.param(bD.data,bD.traditional)}aW(aa,bD,bx,bJ);if(bA===2){return false}bw=bD.global;bD.type=bD.type.toUpperCase();bD.hasContent=!aQ.test(bD.type);if(bw&&b.active++===0){b.event.trigger("ajaxStart")}if(!bD.hasContent){if(bD.data){bD.url+=(M.test(bD.url)?"&":"?")+bD.data;delete bD.data}bC=bD.url;if(bD.cache===false){var bv=b.now(),bP=bD.url.replace(br,"$1_="+bv);bD.url=bP+((bP===bD.url)?(M.test(bD.url)?"&":"?")+"_="+bv:"")}}if(bD.data&&bD.hasContent&&bD.contentType!==false||bx.contentType){bJ.setRequestHeader("Content-Type",bD.contentType)}if(bD.ifModified){bC=bC||bD.url;if(b.lastModified[bC]){bJ.setRequestHeader("If-Modified-Since",b.lastModified[bC])}if(b.etag[bC]){bJ.setRequestHeader("If-None-Match",b.etag[bC])}}bJ.setRequestHeader("Accept",bD.dataTypes[0]&&bD.accepts[bD.dataTypes[0]]?bD.accepts[bD.dataTypes[0]]+(bD.dataTypes[0]!=="*"?", "+aV+"; q=0.01":""):bD.accepts["*"]);for(bK in bD.headers){bJ.setRequestHeader(bK,bD.headers[bK])}if(bD.beforeSend&&(bD.beforeSend.call(bS,bJ,bD)===false||bA===2)){bJ.abort();return false}for(bK in {success:1,error:1,complete:1}){bJ[bK](bD[bK])}bL=aW(r,bD,bx,bJ);if(!bL){bF(-1,"No Transport")}else{bJ.readyState=1;if(bw){bG.trigger("ajaxSend",[bJ,bD])}if(bD.async&&bD.timeout>0){bE=setTimeout(function(){bJ.abort("timeout")},bD.timeout)}try{bA=1;bL.send(bH,bF)}catch(bM){if(bA<2){bF(-1,bM)}else{throw bM}}}return bJ},param:function(e,bw){var bv=[],by=function(bz,bA){bA=b.isFunction(bA)?bA():bA;bv[bv.length]=encodeURIComponent(bz)+"="+encodeURIComponent(bA)};if(bw===L){bw=b.ajaxSettings.traditional}if(b.isArray(e)||(e.jquery&&!b.isPlainObject(e))){b.each(e,function(){by(this.name,this.value)})}else{for(var bx in e){v(bx,e[bx],bw,by)}}return bv.join("&").replace(k,"+")}});function v(bw,by,bv,bx){if(b.isArray(by)){b.each(by,function(bA,bz){if(bv||ap.test(bw)){bx(bw,bz)}else{v(bw+"["+(typeof bz==="object"||b.isArray(bz)?bA:"")+"]",bz,bv,bx)}})}else{if(!bv&&by!=null&&typeof by==="object"){for(var e in by){v(bw+"["+e+"]",by[e],bv,bx)}}else{bx(bw,by)}}}b.extend({active:0,lastModified:{},etag:{}});function bj(bD,bC,bz){var bv=bD.contents,bB=bD.dataTypes,bw=bD.responseFields,by,bA,bx,e;for(bA in bw){if(bA in bz){bC[bw[bA]]=bz[bA]}}while(bB[0]==="*"){bB.shift();if(by===L){by=bD.mimeType||bC.getResponseHeader("content-type")}}if(by){for(bA in bv){if(bv[bA]&&bv[bA].test(by)){bB.unshift(bA);break}}}if(bB[0] in bz){bx=bB[0]}else{for(bA in bz){if(!bB[0]||bD.converters[bA+" "+bB[0]]){bx=bA;break}if(!e){e=bA}}bx=bx||e}if(bx){if(bx!==bB[0]){bB.unshift(bx)}return bz[bx]}}function G(bH,bz){if(bH.dataFilter){bz=bH.dataFilter(bz,bH.dataType)}var bD=bH.dataTypes,bG={},bA,bE,bw=bD.length,bB,bC=bD[0],bx,by,bF,bv,e;for(bA=1;bA<bw;bA++){if(bA===1){for(bE in bH.converters){if(typeof bE==="string"){bG[bE.toLowerCase()]=bH.converters[bE]}}}bx=bC;bC=bD[bA];if(bC==="*"){bC=bx}else{if(bx!=="*"&&bx!==bC){by=bx+" "+bC;bF=bG[by]||bG["* "+bC];if(!bF){e=L;for(bv in bG){bB=bv.split(" ");if(bB[0]===bx||bB[0]==="*"){e=bG[bB[1]+" "+bC];if(e){bv=bG[bv];if(bv===true){bF=e}else{if(e===true){bF=bv}}break}}}}if(!(bF||e)){b.error("No conversion from "+by.replace(" "," to "))}if(bF!==true){bz=bF?bF(bz):e(bv(bz))}}}}return bz}var aC=b.now(),u=/(\=)\?(&|$)|\?\?/i;b.ajaxSetup({jsonp:"callback",jsonpCallback:function(){return b.expando+"_"+(aC++)}});b.ajaxPrefilter("json jsonp",function(bD,bA,bC){var bx=bD.contentType==="application/x-www-form-urlencoded"&&(typeof bD.data==="string");if(bD.dataTypes[0]==="jsonp"||bD.jsonp!==false&&(u.test(bD.url)||bx&&u.test(bD.data))){var bB,bw=bD.jsonpCallback=b.isFunction(bD.jsonpCallback)?bD.jsonpCallback():bD.jsonpCallback,bz=bb[bw],e=bD.url,by=bD.data,bv="$1"+bw+"$2";if(bD.jsonp!==false){e=e.replace(u,bv);if(bD.url===e){if(bx){by=by.replace(u,bv)}if(bD.data===by){e+=(/\?/.test(e)?"&":"?")+bD.jsonp+"="+bw}}}bD.url=e;bD.data=by;bb[bw]=function(bE){bB=[bE]};bC.always(function(){bb[bw]=bz;if(bB&&b.isFunction(bz)){bb[bw](bB[0])}});bD.converters["script json"]=function(){if(!bB){b.error(bw+" was not called")}return bB[0]};bD.dataTypes[0]="json";return"script"}});b.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/javascript|ecmascript/},converters:{"text script":function(e){b.globalEval(e);return e}}});b.ajaxPrefilter("script",function(e){if(e.cache===L){e.cache=false}if(e.crossDomain){e.type="GET";e.global=false}});b.ajaxTransport("script",function(bw){if(bw.crossDomain){var e,bv=av.head||av.getElementsByTagName("head")[0]||av.documentElement;return{send:function(bx,by){e=av.createElement("script");e.async="async";if(bw.scriptCharset){e.charset=bw.scriptCharset}e.src=bw.url;e.onload=e.onreadystatechange=function(bA,bz){if(bz||!e.readyState||/loaded|complete/.test(e.readyState)){e.onload=e.onreadystatechange=null;if(bv&&e.parentNode){bv.removeChild(e)}e=L;if(!bz){by(200,"success")}}};bv.insertBefore(e,bv.firstChild)},abort:function(){if(e){e.onload(0,1)}}}}});var B=bb.ActiveXObject?function(){for(var e in N){N[e](0,1)}}:false,y=0,N;function aL(){try{return new bb.XMLHttpRequest()}catch(bv){}}function aj(){try{return new bb.ActiveXObject("Microsoft.XMLHTTP")}catch(bv){}}b.ajaxSettings.xhr=bb.ActiveXObject?function(){return !this.isLocal&&aL()||aj()}:aL;(function(e){b.extend(b.support,{ajax:!!e,cors:!!e&&("withCredentials" in e)})})(b.ajaxSettings.xhr());if(b.support.ajax){b.ajaxTransport(function(e){if(!e.crossDomain||b.support.cors){var bv;return{send:function(bB,bw){var bA=e.xhr(),bz,by;if(e.username){bA.open(e.type,e.url,e.async,e.username,e.password)}else{bA.open(e.type,e.url,e.async)}if(e.xhrFields){for(by in e.xhrFields){bA[by]=e.xhrFields[by]}}if(e.mimeType&&bA.overrideMimeType){bA.overrideMimeType(e.mimeType)}if(!e.crossDomain&&!bB["X-Requested-With"]){bB["X-Requested-With"]="XMLHttpRequest"}try{for(by in bB){bA.setRequestHeader(by,bB[by])}}catch(bx){}bA.send((e.hasContent&&e.data)||null);bv=function(bK,bE){var bF,bD,bC,bI,bH;try{if(bv&&(bE||bA.readyState===4)){bv=L;if(bz){bA.onreadystatechange=b.noop;if(B){delete N[bz]}}if(bE){if(bA.readyState!==4){bA.abort()}}else{bF=bA.status;bC=bA.getAllResponseHeaders();bI={};bH=bA.responseXML;if(bH&&bH.documentElement){bI.xml=bH}bI.text=bA.responseText;try{bD=bA.statusText}catch(bJ){bD=""}if(!bF&&e.isLocal&&!e.crossDomain){bF=bI.text?200:404}else{if(bF===1223){bF=204}}}}}catch(bG){if(!bE){bw(-1,bG)}}if(bI){bw(bF,bD,bI,bC)}};if(!e.async||bA.readyState===4){bv()}else{bz=++y;if(B){if(!N){N={};b(bb).unload(B)}N[bz]=bv}bA.onreadystatechange=bv}},abort:function(){if(bv){bv(0,1)}}}}})}var Q={},a8,m,aB=/^(?:toggle|show|hide)$/,aT=/^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i,a3,aH=[["height","marginTop","marginBottom","paddingTop","paddingBottom"],["width","marginLeft","marginRight","paddingLeft","paddingRight"],["opacity"]],a4;b.fn.extend({show:function(bx,bA,bz){var bw,by;if(bx||bx===0){return this.animate(a0("show",3),bx,bA,bz)}else{for(var bv=0,e=this.length;bv<e;bv++){bw=this[bv];if(bw.style){by=bw.style.display;if(!b._data(bw,"olddisplay")&&by==="none"){by=bw.style.display=""}if(by===""&&b.css(bw,"display")==="none"){b._data(bw,"olddisplay",x(bw.nodeName))}}}for(bv=0;bv<e;bv++){bw=this[bv];if(bw.style){by=bw.style.display;if(by===""||by==="none"){bw.style.display=b._data(bw,"olddisplay")||""}}}return this}},hide:function(bx,bA,bz){if(bx||bx===0){return this.animate(a0("hide",3),bx,bA,bz)}else{var bw,by,bv=0,e=this.length;for(;bv<e;bv++){bw=this[bv];if(bw.style){by=b.css(bw,"display");if(by!=="none"&&!b._data(bw,"olddisplay")){b._data(bw,"olddisplay",by)}}}for(bv=0;bv<e;bv++){if(this[bv].style){this[bv].style.display="none"}}return this}},_toggle:b.fn.toggle,toggle:function(bw,bv,bx){var e=typeof bw==="boolean";if(b.isFunction(bw)&&b.isFunction(bv)){this._toggle.apply(this,arguments)}else{if(bw==null||e){this.each(function(){var by=e?bw:b(this).is(":hidden");b(this)[by?"show":"hide"]()})}else{this.animate(a0("toggle",3),bw,bv,bx)}}return this},fadeTo:function(e,bx,bw,bv){return this.filter(":hidden").css("opacity",0).show().end().animate({opacity:bx},e,bw,bv)},animate:function(bz,bw,by,bx){var e=b.speed(bw,by,bx);if(b.isEmptyObject(bz)){return this.each(e.complete,[false])}bz=b.extend({},bz);function bv(){if(e.queue===false){b._mark(this)}var bE=b.extend({},e),bK=this.nodeType===1,bI=bK&&b(this).is(":hidden"),bB,bF,bD,bJ,bH,bC,bG,bL,bA;bE.animatedProperties={};for(bD in bz){bB=b.camelCase(bD);if(bD!==bB){bz[bB]=bz[bD];delete bz[bD]}bF=bz[bB];if(b.isArray(bF)){bE.animatedProperties[bB]=bF[1];bF=bz[bB]=bF[0]}else{bE.animatedProperties[bB]=bE.specialEasing&&bE.specialEasing[bB]||bE.easing||"swing"}if(bF==="hide"&&bI||bF==="show"&&!bI){return bE.complete.call(this)}if(bK&&(bB==="height"||bB==="width")){bE.overflow=[this.style.overflow,this.style.overflowX,this.style.overflowY];if(b.css(this,"display")==="inline"&&b.css(this,"float")==="none"){if(!b.support.inlineBlockNeedsLayout||x(this.nodeName)==="inline"){this.style.display="inline-block"}else{this.style.zoom=1}}}}if(bE.overflow!=null){this.style.overflow="hidden"}for(bD in bz){bJ=new b.fx(this,bE,bD);bF=bz[bD];if(aB.test(bF)){bA=b._data(this,"toggle"+bD)||(bF==="toggle"?bI?"show":"hide":0);if(bA){b._data(this,"toggle"+bD,bA==="show"?"hide":"show");bJ[bA]()}else{bJ[bF]()}}else{bH=aT.exec(bF);bC=bJ.cur();if(bH){bG=parseFloat(bH[2]);bL=bH[3]||(b.cssNumber[bD]?"":"px");if(bL!=="px"){b.style(this,bD,(bG||1)+bL);bC=((bG||1)/bJ.cur())*bC;b.style(this,bD,bC+bL)}if(bH[1]){bG=((bH[1]==="-="?-1:1)*bG)+bC}bJ.custom(bC,bG,bL)}else{bJ.custom(bC,bF,"")}}}return true}return e.queue===false?this.each(bv):this.queue(e.queue,bv)},stop:function(bw,bv,e){if(typeof bw!=="string"){e=bv;bv=bw;bw=L}if(bv&&bw!==false){this.queue(bw||"fx",[])}return this.each(function(){var bx,by=false,bA=b.timers,bz=b._data(this);if(!e){b._unmark(true,this)}function bB(bE,bF,bD){var bC=bF[bD];b.removeData(bE,bD,true);bC.stop(e)}if(bw==null){for(bx in bz){if(bz[bx]&&bz[bx].stop&&bx.indexOf(".run")===bx.length-4){bB(this,bz,bx)}}}else{if(bz[bx=bw+".run"]&&bz[bx].stop){bB(this,bz,bx)}}for(bx=bA.length;bx--;){if(bA[bx].elem===this&&(bw==null||bA[bx].queue===bw)){if(e){bA[bx](true)}else{bA[bx].saveState()}by=true;bA.splice(bx,1)}}if(!(e&&by)){b.dequeue(this,bw)}})}});function bh(){setTimeout(at,0);return(a4=b.now())}function at(){a4=L}function a0(bv,e){var bw={};b.each(aH.concat.apply([],aH.slice(0,e)),function(){bw[this]=bv});return bw}b.each({slideDown:a0("show",1),slideUp:a0("hide",1),slideToggle:a0("toggle",1),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(e,bv){b.fn[e]=function(bw,by,bx){return this.animate(bv,bw,by,bx)}});b.extend({speed:function(bw,bx,bv){var e=bw&&typeof bw==="object"?b.extend({},bw):{complete:bv||!bv&&bx||b.isFunction(bw)&&bw,duration:bw,easing:bv&&bx||bx&&!b.isFunction(bx)&&bx};e.duration=b.fx.off?0:typeof e.duration==="number"?e.duration:e.duration in b.fx.speeds?b.fx.speeds[e.duration]:b.fx.speeds._default;if(e.queue==null||e.queue===true){e.queue="fx"}e.old=e.complete;e.complete=function(by){if(b.isFunction(e.old)){e.old.call(this)}if(e.queue){b.dequeue(this,e.queue)}else{if(by!==false){b._unmark(this)}}};return e},easing:{linear:function(bw,bx,e,bv){return e+bv*bw},swing:function(bw,bx,e,bv){return((-Math.cos(bw*Math.PI)/2)+0.5)*bv+e}},timers:[],fx:function(bv,e,bw){this.options=e;this.elem=bv;this.prop=bw;e.orig=e.orig||{}}});b.fx.prototype={update:function(){if(this.options.step){this.options.step.call(this.elem,this.now,this)}(b.fx.step[this.prop]||b.fx.step._default)(this)},cur:function(){if(this.elem[this.prop]!=null&&(!this.elem.style||this.elem.style[this.prop]==null)){return this.elem[this.prop]}var e,bv=b.css(this.elem,this.prop);return isNaN(e=parseFloat(bv))?!bv||bv==="auto"?0:bv:e},custom:function(bz,by,bx){var e=this,bw=b.fx;this.startTime=a4||bh();this.end=by;this.now=this.start=bz;this.pos=this.state=0;this.unit=bx||this.unit||(b.cssNumber[this.prop]?"":"px");function bv(bA){return e.step(bA)}bv.queue=this.options.queue;bv.elem=this.elem;bv.saveState=function(){if(e.options.hide&&b._data(e.elem,"fxshow"+e.prop)===L){b._data(e.elem,"fxshow"+e.prop,e.start)}};if(bv()&&b.timers.push(bv)&&!a3){a3=setInterval(bw.tick,bw.interval)}},show:function(){var e=b._data(this.elem,"fxshow"+this.prop);this.options.orig[this.prop]=e||b.style(this.elem,this.prop);this.options.show=true;if(e!==L){this.custom(this.cur(),e)}else{this.custom(this.prop==="width"||this.prop==="height"?1:0,this.cur())}b(this.elem).show()},hide:function(){this.options.orig[this.prop]=b._data(this.elem,"fxshow"+this.prop)||b.style(this.elem,this.prop);this.options.hide=true;this.custom(this.cur(),0)},step:function(by){var bA,bB,bv,bx=a4||bh(),e=true,bz=this.elem,bw=this.options;if(by||bx>=bw.duration+this.startTime){this.now=this.end;this.pos=this.state=1;this.update();bw.animatedProperties[this.prop]=true;for(bA in bw.animatedProperties){if(bw.animatedProperties[bA]!==true){e=false}}if(e){if(bw.overflow!=null&&!b.support.shrinkWrapBlocks){b.each(["","X","Y"],function(bC,bD){bz.style["overflow"+bD]=bw.overflow[bC]})}if(bw.hide){b(bz).hide()}if(bw.hide||bw.show){for(bA in bw.animatedProperties){b.style(bz,bA,bw.orig[bA]);b.removeData(bz,"fxshow"+bA,true);b.removeData(bz,"toggle"+bA,true)}}bv=bw.complete;if(bv){bw.complete=false;bv.call(bz)}}return false}else{if(bw.duration==Infinity){this.now=bx}else{bB=bx-this.startTime;this.state=bB/bw.duration;this.pos=b.easing[bw.animatedProperties[this.prop]](this.state,bB,0,1,bw.duration);this.now=this.start+((this.end-this.start)*this.pos)}this.update()}return true}};b.extend(b.fx,{tick:function(){var bw,bv=b.timers,e=0;for(;e<bv.length;e++){bw=bv[e];if(!bw()&&bv[e]===bw){bv.splice(e--,1)}}if(!bv.length){b.fx.stop()}},interval:13,stop:function(){clearInterval(a3);a3=null},speeds:{slow:600,fast:200,_default:400},step:{opacity:function(e){b.style(e.elem,"opacity",e.now)},_default:function(e){if(e.elem.style&&e.elem.style[e.prop]!=null){e.elem.style[e.prop]=e.now+e.unit}else{e.elem[e.prop]=e.now}}}});b.each(["width","height"],function(e,bv){b.fx.step[bv]=function(bw){b.style(bw.elem,bv,Math.max(0,bw.now)+bw.unit)}});if(b.expr&&b.expr.filters){b.expr.filters.animated=function(e){return b.grep(b.timers,function(bv){return e===bv.elem}).length}}function x(bx){if(!Q[bx]){var e=av.body,bv=b("<"+bx+">").appendTo(e),bw=bv.css("display");bv.remove();if(bw==="none"||bw===""){if(!a8){a8=av.createElement("iframe");a8.frameBorder=a8.width=a8.height=0}e.appendChild(a8);if(!m||!a8.createElement){m=(a8.contentWindow||a8.contentDocument).document;m.write((av.compatMode==="CSS1Compat"?"<!doctype html>":"")+"<html><body>");m.close()}bv=m.createElement(bx);m.body.appendChild(bv);bw=b.css(bv,"display");e.removeChild(a8)}Q[bx]=bw}return Q[bx]}var V=/^t(?:able|d|h)$/i,ad=/^(?:body|html)$/i;if("getBoundingClientRect" in av.documentElement){b.fn.offset=function(bI){var by=this[0],bB;if(bI){return this.each(function(e){b.offset.setOffset(this,bI,e)})}if(!by||!by.ownerDocument){return null}if(by===by.ownerDocument.body){return b.offset.bodyOffset(by)}try{bB=by.getBoundingClientRect()}catch(bF){}var bH=by.ownerDocument,bw=bH.documentElement;if(!bB||!b.contains(bw,by)){return bB?{top:bB.top,left:bB.left}:{top:0,left:0}}var bC=bH.body,bD=aK(bH),bA=bw.clientTop||bC.clientTop||0,bE=bw.clientLeft||bC.clientLeft||0,bv=bD.pageYOffset||b.support.boxModel&&bw.scrollTop||bC.scrollTop,bz=bD.pageXOffset||b.support.boxModel&&bw.scrollLeft||bC.scrollLeft,bG=bB.top+bv-bA,bx=bB.left+bz-bE;return{top:bG,left:bx}}}else{b.fn.offset=function(bF){var bz=this[0];if(bF){return this.each(function(bG){b.offset.setOffset(this,bF,bG)})}if(!bz||!bz.ownerDocument){return null}if(bz===bz.ownerDocument.body){return b.offset.bodyOffset(bz)}var bC,bw=bz.offsetParent,bv=bz,bE=bz.ownerDocument,bx=bE.documentElement,bA=bE.body,bB=bE.defaultView,e=bB?bB.getComputedStyle(bz,null):bz.currentStyle,bD=bz.offsetTop,by=bz.offsetLeft;while((bz=bz.parentNode)&&bz!==bA&&bz!==bx){if(b.support.fixedPosition&&e.position==="fixed"){break}bC=bB?bB.getComputedStyle(bz,null):bz.currentStyle;bD-=bz.scrollTop;by-=bz.scrollLeft;if(bz===bw){bD+=bz.offsetTop;by+=bz.offsetLeft;if(b.support.doesNotAddBorder&&!(b.support.doesAddBorderForTableAndCells&&V.test(bz.nodeName))){bD+=parseFloat(bC.borderTopWidth)||0;by+=parseFloat(bC.borderLeftWidth)||0}bv=bw;bw=bz.offsetParent}if(b.support.subtractsBorderForOverflowNotVisible&&bC.overflow!=="visible"){bD+=parseFloat(bC.borderTopWidth)||0;by+=parseFloat(bC.borderLeftWidth)||0}e=bC}if(e.position==="relative"||e.position==="static"){bD+=bA.offsetTop;by+=bA.offsetLeft}if(b.support.fixedPosition&&e.position==="fixed"){bD+=Math.max(bx.scrollTop,bA.scrollTop);by+=Math.max(bx.scrollLeft,bA.scrollLeft)}return{top:bD,left:by}}}b.offset={bodyOffset:function(e){var bw=e.offsetTop,bv=e.offsetLeft;if(b.support.doesNotIncludeMarginInBodyOffset){bw+=parseFloat(b.css(e,"marginTop"))||0;bv+=parseFloat(b.css(e,"marginLeft"))||0}return{top:bw,left:bv}},setOffset:function(bx,bG,bA){var bB=b.css(bx,"position");if(bB==="static"){bx.style.position="relative"}var bz=b(bx),bv=bz.offset(),e=b.css(bx,"top"),bE=b.css(bx,"left"),bF=(bB==="absolute"||bB==="fixed")&&b.inArray("auto",[e,bE])>-1,bD={},bC={},bw,by;if(bF){bC=bz.position();bw=bC.top;by=bC.left}else{bw=parseFloat(e)||0;by=parseFloat(bE)||0}if(b.isFunction(bG)){bG=bG.call(bx,bA,bv)}if(bG.top!=null){bD.top=(bG.top-bv.top)+bw}if(bG.left!=null){bD.left=(bG.left-bv.left)+by}if("using" in bG){bG.using.call(bx,bD)}else{bz.css(bD)}}};b.fn.extend({position:function(){if(!this[0]){return null}var bw=this[0],bv=this.offsetParent(),bx=this.offset(),e=ad.test(bv[0].nodeName)?{top:0,left:0}:bv.offset();bx.top-=parseFloat(b.css(bw,"marginTop"))||0;bx.left-=parseFloat(b.css(bw,"marginLeft"))||0;e.top+=parseFloat(b.css(bv[0],"borderTopWidth"))||0;e.left+=parseFloat(b.css(bv[0],"borderLeftWidth"))||0;return{top:bx.top-e.top,left:bx.left-e.left}},offsetParent:function(){return this.map(function(){var e=this.offsetParent||av.body;while(e&&(!ad.test(e.nodeName)&&b.css(e,"position")==="static")){e=e.offsetParent}return e})}});b.each(["Left","Top"],function(bv,e){var bw="scroll"+e;b.fn[bw]=function(bz){var bx,by;if(bz===L){bx=this[0];if(!bx){return null}by=aK(bx);return by?("pageXOffset" in by)?by[bv?"pageYOffset":"pageXOffset"]:b.support.boxModel&&by.document.documentElement[bw]||by.document.body[bw]:bx[bw]}return this.each(function(){by=aK(this);if(by){by.scrollTo(!bv?bz:b(by).scrollLeft(),bv?bz:b(by).scrollTop())}else{this[bw]=bz}})}});function aK(e){return b.isWindow(e)?e:e.nodeType===9?e.defaultView||e.parentWindow:false}b.each(["Height","Width"],function(bv,e){var bw=e.toLowerCase();b.fn["inner"+e]=function(){var bx=this[0];return bx?bx.style?parseFloat(b.css(bx,bw,"padding")):this[bw]():null};b.fn["outer"+e]=function(by){var bx=this[0];return bx?bx.style?parseFloat(b.css(bx,bw,by?"margin":"border")):this[bw]():null};b.fn[bw]=function(bz){var bA=this[0];if(!bA){return bz==null?null:this}if(b.isFunction(bz)){return this.each(function(bE){var bD=b(this);bD[bw](bz.call(this,bE,bD[bw]()))})}if(b.isWindow(bA)){var bB=bA.document.documentElement["client"+e],bx=bA.document.body;return bA.document.compatMode==="CSS1Compat"&&bB||bx&&bx["client"+e]||bB}else{if(bA.nodeType===9){return Math.max(bA.documentElement["client"+e],bA.body["scroll"+e],bA.documentElement["scroll"+e],bA.body["offset"+e],bA.documentElement["offset"+e])}else{if(bz===L){var bC=b.css(bA,bw),by=parseFloat(bC);return b.isNumeric(by)?by:bC}else{return this.css(bw,typeof bz==="string"?bz:bz+"px")}}}}});bb.jQuery=bb.$=b;if(typeof define==="function"&&define.amd&&define.amd.jQuery){define("jquery",[],function(){return b})}})(window);/*
- * jQuery UI 1.8.18
- *
- * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
- * Dual licensed under the MIT or GPL Version 2 licenses.
- * http://jquery.org/license
- *
- * http://docs.jquery.com/UI
- */
-(function(a,d){a.ui=a.ui||{};if(a.ui.version){return}a.extend(a.ui,{version:"1.8.18",keyCode:{ALT:18,BACKSPACE:8,CAPS_LOCK:20,COMMA:188,COMMAND:91,COMMAND_LEFT:91,COMMAND_RIGHT:93,CONTROL:17,DELETE:46,DOWN:40,END:35,ENTER:13,ESCAPE:27,HOME:36,INSERT:45,LEFT:37,MENU:93,NUMPAD_ADD:107,NUMPAD_DECIMAL:110,NUMPAD_DIVIDE:111,NUMPAD_ENTER:108,NUMPAD_MULTIPLY:106,NUMPAD_SUBTRACT:109,PAGE_DOWN:34,PAGE_UP:33,PERIOD:190,RIGHT:39,SHIFT:16,SPACE:32,TAB:9,UP:38,WINDOWS:91}});a.fn.extend({propAttr:a.fn.prop||a.fn.attr,_focus:a.fn.focus,focus:function(e,f){return typeof e==="number"?this.each(function(){var g=this;setTimeout(function(){a(g).focus();if(f){f.call(g)}},e)}):this._focus.apply(this,arguments)},scrollParent:function(){var e;if((a.browser.msie&&(/(static|relative)/).test(this.css("position")))||(/absolute/).test(this.css("position"))){e=this.parents().filter(function(){return(/(relative|absolute|fixed)/).test(a.curCSS(this,"position",1))&&(/(auto|scroll)/).test(a.curCSS(this,"overflow",1)+a.curCSS(this,"overflow-y",1)+a.curCSS(this,"overflow-x",1))}).eq(0)}else{e=this.parents().filter(function(){return(/(auto|scroll)/).test(a.curCSS(this,"overflow",1)+a.curCSS(this,"overflow-y",1)+a.curCSS(this,"overflow-x",1))}).eq(0)}return(/fixed/).test(this.css("position"))||!e.length?a(document):e},zIndex:function(h){if(h!==d){return this.css("zIndex",h)}if(this.length){var f=a(this[0]),e,g;while(f.length&&f[0]!==document){e=f.css("position");if(e==="absolute"||e==="relative"||e==="fixed"){g=parseInt(f.css("zIndex"),10);if(!isNaN(g)&&g!==0){return g}}f=f.parent()}}return 0},disableSelection:function(){return this.bind((a.support.selectstart?"selectstart":"mousedown")+".ui-disableSelection",function(e){e.preventDefault()})},enableSelection:function(){return this.unbind(".ui-disableSelection")}});a.each(["Width","Height"],function(g,e){var f=e==="Width"?["Left","Right"]:["Top","Bottom"],h=e.toLowerCase(),k={innerWidth:a.fn.innerWidth,innerHeight:a.fn.innerHeight,outerWidth:a.fn.outerWidth,outerHeight:a.fn.outerHeight};function j(m,l,i,n){a.each(f,function(){l-=parseFloat(a.curCSS(m,"padding"+this,true))||0;if(i){l-=parseFloat(a.curCSS(m,"border"+this+"Width",true))||0}if(n){l-=parseFloat(a.curCSS(m,"margin"+this,true))||0}});return l}a.fn["inner"+e]=function(i){if(i===d){return k["inner"+e].call(this)}return this.each(function(){a(this).css(h,j(this,i)+"px")})};a.fn["outer"+e]=function(i,l){if(typeof i!=="number"){return k["outer"+e].call(this,i)}return this.each(function(){a(this).css(h,j(this,i,true,l)+"px")})}});function c(g,e){var j=g.nodeName.toLowerCase();if("area"===j){var i=g.parentNode,h=i.name,f;if(!g.href||!h||i.nodeName.toLowerCase()!=="map"){return false}f=a("img[usemap=#"+h+"]")[0];return !!f&&b(f)}return(/input|select|textarea|button|object/.test(j)?!g.disabled:"a"==j?g.href||e:e)&&b(g)}function b(e){return !a(e).parents().andSelf().filter(function(){return a.curCSS(this,"visibility")==="hidden"||a.expr.filters.hidden(this)}).length}a.extend(a.expr[":"],{data:function(g,f,e){return !!a.data(g,e[3])},focusable:function(e){return c(e,!isNaN(a.attr(e,"tabindex")))},tabbable:function(g){var e=a.attr(g,"tabindex"),f=isNaN(e);return(f||e>=0)&&c(g,!f)}});a(function(){var e=document.body,f=e.appendChild(f=document.createElement("div"));f.offsetHeight;a.extend(f.style,{minHeight:"100px",height:"auto",padding:0,borderWidth:0});a.support.minHeight=f.offsetHeight===100;a.support.selectstart="onselectstart" in f;e.removeChild(f).style.display="none"});a.extend(a.ui,{plugin:{add:function(f,g,j){var h=a.ui[f].prototype;for(var e in j){h.plugins[e]=h.plugins[e]||[];h.plugins[e].push([g,j[e]])}},call:function(e,g,f){var j=e.plugins[g];if(!j||!e.element[0].parentNode){return}for(var h=0;h<j.length;h++){if(e.options[j[h][0]]){j[h][1].apply(e.element,f)}}}},contains:function(f,e){return document.compareDocumentPosition?f.compareDocumentPosition(e)&16:f!==e&&f.contains(e)},hasScroll:function(h,f){if(a(h).css("overflow")==="hidden"){return false}var e=(f&&f==="left")?"scrollLeft":"scrollTop",g=false;if(h[e]>0){return true}h[e]=1;g=(h[e]>0);h[e]=0;return g},isOverAxis:function(f,e,g){return(f>e)&&(f<(e+g))},isOver:function(j,f,i,h,e,g){return a.ui.isOverAxis(j,i,e)&&a.ui.isOverAxis(f,h,g)}})})(jQuery);/*
- * jQuery UI Widget 1.8.18
- *
- * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
- * Dual licensed under the MIT or GPL Version 2 licenses.
- * http://jquery.org/license
- *
- * http://docs.jquery.com/UI/Widget
- */
-(function(b,d){if(b.cleanData){var c=b.cleanData;b.cleanData=function(f){for(var g=0,h;(h=f[g])!=null;g++){try{b(h).triggerHandler("remove")}catch(j){}}c(f)}}else{var a=b.fn.remove;b.fn.remove=function(e,f){return this.each(function(){if(!f){if(!e||b.filter(e,[this]).length){b("*",this).add([this]).each(function(){try{b(this).triggerHandler("remove")}catch(g){}})}}return a.call(b(this),e,f)})}}b.widget=function(f,h,e){var g=f.split(".")[0],j;f=f.split(".")[1];j=g+"-"+f;if(!e){e=h;h=b.Widget}b.expr[":"][j]=function(k){return !!b.data(k,f)};b[g]=b[g]||{};b[g][f]=function(k,l){if(arguments.length){this._createWidget(k,l)}};var i=new h();i.options=b.extend(true,{},i.options);b[g][f].prototype=b.extend(true,i,{namespace:g,widgetName:f,widgetEventPrefix:b[g][f].prototype.widgetEventPrefix||f,widgetBaseClass:j},e);b.widget.bridge(f,b[g][f])};b.widget.bridge=function(f,e){b.fn[f]=function(i){var g=typeof i==="string",h=Array.prototype.slice.call(arguments,1),j=this;i=!g&&h.length?b.extend.apply(null,[true,i].concat(h)):i;if(g&&i.charAt(0)==="_"){return j}if(g){this.each(function(){var k=b.data(this,f),l=k&&b.isFunction(k[i])?k[i].apply(k,h):k;if(l!==k&&l!==d){j=l;return false}})}else{this.each(function(){var k=b.data(this,f);if(k){k.option(i||{})._init()}else{b.data(this,f,new e(i,this))}})}return j}};b.Widget=function(e,f){if(arguments.length){this._createWidget(e,f)}};b.Widget.prototype={widgetName:"widget",widgetEventPrefix:"",options:{disabled:false},_createWidget:function(f,g){b.data(g,this.widgetName,this);this.element=b(g);this.options=b.extend(true,{},this.options,this._getCreateOptions(),f);var e=this;this.element.bind("remove."+this.widgetName,function(){e.destroy()});this._create();this._trigger("create");this._init()},_getCreateOptions:function(){return b.metadata&&b.metadata.get(this.element[0])[this.widgetName]},_create:function(){},_init:function(){},destroy:function(){this.element.unbind("."+this.widgetName).removeData(this.widgetName);this.widget().unbind("."+this.widgetName).removeAttr("aria-disabled").removeClass(this.widgetBaseClass+"-disabled ui-state-disabled")},widget:function(){return this.element},option:function(f,g){var e=f;if(arguments.length===0){return b.extend({},this.options)}if(typeof f==="string"){if(g===d){return this.options[f]}e={};e[f]=g}this._setOptions(e);return this},_setOptions:function(f){var e=this;b.each(f,function(g,h){e._setOption(g,h)});return this},_setOption:function(e,f){this.options[e]=f;if(e==="disabled"){this.widget()[f?"addClass":"removeClass"](this.widgetBaseClass+"-disabled ui-state-disabled").attr("aria-disabled",f)}return this},enable:function(){return this._setOption("disabled",false)},disable:function(){return this._setOption("disabled",true)},_trigger:function(e,f,g){var j,i,h=this.options[e];g=g||{};f=b.Event(f);f.type=(e===this.widgetEventPrefix?e:this.widgetEventPrefix+e).toLowerCase();f.target=this.element[0];i=f.originalEvent;if(i){for(j in i){if(!(j in f)){f[j]=i[j]}}}this.element.trigger(f,g);return !(b.isFunction(h)&&h.call(this.element[0],f,g)===false||f.isDefaultPrevented())}}})(jQuery);/*
- * jQuery UI Mouse 1.8.18
- *
- * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
- * Dual licensed under the MIT or GPL Version 2 licenses.
- * http://jquery.org/license
- *
- * http://docs.jquery.com/UI/Mouse
- *
- * Depends:
- * jquery.ui.widget.js
- */
-(function(b,c){var a=false;b(document).mouseup(function(d){a=false});b.widget("ui.mouse",{options:{cancel:":input,option",distance:1,delay:0},_mouseInit:function(){var d=this;this.element.bind("mousedown."+this.widgetName,function(e){return d._mouseDown(e)}).bind("click."+this.widgetName,function(e){if(true===b.data(e.target,d.widgetName+".preventClickEvent")){b.removeData(e.target,d.widgetName+".preventClickEvent");e.stopImmediatePropagation();return false}});this.started=false},_mouseDestroy:function(){this.element.unbind("."+this.widgetName)},_mouseDown:function(f){if(a){return}(this._mouseStarted&&this._mouseUp(f));this._mouseDownEvent=f;var e=this,g=(f.which==1),d=(typeof this.options.cancel=="string"&&f.target.nodeName?b(f.target).closest(this.options.cancel).length:false);if(!g||d||!this._mouseCapture(f)){return true}this.mouseDelayMet=!this.options.delay;if(!this.mouseDelayMet){this._mouseDelayTimer=setTimeout(function(){e.mouseDelayMet=true},this.options.delay)}if(this._mouseDistanceMet(f)&&this._mouseDelayMet(f)){this._mouseStarted=(this._mouseStart(f)!==false);if(!this._mouseStarted){f.preventDefault();return true}}if(true===b.data(f.target,this.widgetName+".preventClickEvent")){b.removeData(f.target,this.widgetName+".preventClickEvent")}this._mouseMoveDelegate=function(h){return e._mouseMove(h)};this._mouseUpDelegate=function(h){return e._mouseUp(h)};b(document).bind("mousemove."+this.widgetName,this._mouseMoveDelegate).bind("mouseup."+this.widgetName,this._mouseUpDelegate);f.preventDefault();a=true;return true},_mouseMove:function(d){if(b.browser.msie&&!(document.documentMode>=9)&&!d.button){return this._mouseUp(d)}if(this._mouseStarted){this._mouseDrag(d);return d.preventDefault()}if(this._mouseDistanceMet(d)&&this._mouseDelayMet(d)){this._mouseStarted=(this._mouseStart(this._mouseDownEvent,d)!==false);(this._mouseStarted?this._mouseDrag(d):this._mouseUp(d))}return !this._mouseStarted},_mouseUp:function(d){b(document).unbind("mousemove."+this.widgetName,this._mouseMoveDelegate).unbind("mouseup."+this.widgetName,this._mouseUpDelegate);if(this._mouseStarted){this._mouseStarted=false;if(d.target==this._mouseDownEvent.target){b.data(d.target,this.widgetName+".preventClickEvent",true)}this._mouseStop(d)}return false},_mouseDistanceMet:function(d){return(Math.max(Math.abs(this._mouseDownEvent.pageX-d.pageX),Math.abs(this._mouseDownEvent.pageY-d.pageY))>=this.options.distance)},_mouseDelayMet:function(d){return this.mouseDelayMet},_mouseStart:function(d){},_mouseDrag:function(d){},_mouseStop:function(d){},_mouseCapture:function(d){return true}})})(jQuery);(function(c,d){c.widget("ui.resizable",c.ui.mouse,{widgetEventPrefix:"resize",options:{alsoResize:false,animate:false,animateDuration:"slow",animateEasing:"swing",aspectRatio:false,autoHide:false,containment:false,ghost:false,grid:false,handles:"e,s,se",helper:false,maxHeight:null,maxWidth:null,minHeight:10,minWidth:10,zIndex:1000},_create:function(){var f=this,k=this.options;this.element.addClass("ui-resizable");c.extend(this,{_aspectRatio:!!(k.aspectRatio),aspectRatio:k.aspectRatio,originalElement:this.element,_proportionallyResizeElements:[],_helper:k.helper||k.ghost||k.animate?k.helper||"ui-resizable-helper":null});if(this.element[0].nodeName.match(/canvas|textarea|input|select|button|img/i)){this.element.wrap(c('<div class="ui-wrapper" style="overflow: hidden;"></div>').css({position:this.element.css("position"),width:this.element.outerWidth(),height:this.element.outerHeight(),top:this.element.css("top"),left:this.element.css("left")}));this.element=this.element.parent().data("resizable",this.element.data("resizable"));this.elementIsWrapper=true;this.element.css({marginLeft:this.originalElement.css("marginLeft"),marginTop:this.originalElement.css("marginTop"),marginRight:this.originalElement.css("marginRight"),marginBottom:this.originalElement.css("marginBottom")});this.originalElement.css({marginLeft:0,marginTop:0,marginRight:0,marginBottom:0});this.originalResizeStyle=this.originalElement.css("resize");this.originalElement.css("resize","none");this._proportionallyResizeElements.push(this.originalElement.css({position:"static",zoom:1,display:"block"}));this.originalElement.css({margin:this.originalElement.css("margin")});this._proportionallyResize()}this.handles=k.handles||(!c(".ui-resizable-handle",this.element).length?"e,s,se":{n:".ui-resizable-n",e:".ui-resizable-e",s:".ui-resizable-s",w:".ui-resizable-w",se:".ui-resizable-se",sw:".ui-resizable-sw",ne:".ui-resizable-ne",nw:".ui-resizable-nw"});if(this.handles.constructor==String){if(this.handles=="all"){this.handles="n,e,s,w,se,sw,ne,nw"}var l=this.handles.split(",");this.handles={};for(var g=0;g<l.length;g++){var j=c.trim(l[g]),e="ui-resizable-"+j;var h=c('<div class="ui-resizable-handle '+e+'"></div>');if(/sw|se|ne|nw/.test(j)){h.css({zIndex:++k.zIndex})}if("se"==j){h.addClass("ui-icon ui-icon-gripsmall-diagonal-se")}this.handles[j]=".ui-resizable-"+j;this.element.append(h)}}this._renderAxis=function(q){q=q||this.element;for(var n in this.handles){if(this.handles[n].constructor==String){this.handles[n]=c(this.handles[n],this.element).show()}if(this.elementIsWrapper&&this.originalElement[0].nodeName.match(/textarea|input|select|button/i)){var o=c(this.handles[n],this.element),p=0;p=/sw|ne|nw|se|n|s/.test(n)?o.outerHeight():o.outerWidth();var m=["padding",/ne|nw|n/.test(n)?"Top":/se|sw|s/.test(n)?"Bottom":/^e$/.test(n)?"Right":"Left"].join("");q.css(m,p);this._proportionallyResize()}if(!c(this.handles[n]).length){continue}}};this._renderAxis(this.element);this._handles=c(".ui-resizable-handle",this.element).disableSelection();this._handles.mouseover(function(){if(!f.resizing){if(this.className){var i=this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i)}f.axis=i&&i[1]?i[1]:"se"}});if(k.autoHide){this._handles.hide();c(this.element).addClass("ui-resizable-autohide").hover(function(){if(k.disabled){return}c(this).removeClass("ui-resizable-autohide");f._handles.show()},function(){if(k.disabled){return}if(!f.resizing){c(this).addClass("ui-resizable-autohide");f._handles.hide()}})}this._mouseInit()},destroy:function(){this._mouseDestroy();var e=function(g){c(g).removeClass("ui-resizable ui-resizable-disabled ui-resizable-resizing").removeData("resizable").unbind(".resizable").find(".ui-resizable-handle").remove()};if(this.elementIsWrapper){e(this.element);var f=this.element;f.after(this.originalElement.css({position:f.css("position"),width:f.outerWidth(),height:f.outerHeight(),top:f.css("top"),left:f.css("left")})).remove()}this.originalElement.css("resize",this.originalResizeStyle);e(this.originalElement);return this},_mouseCapture:function(f){var g=false;for(var e in this.handles){if(c(this.handles[e])[0]==f.target){g=true}}return !this.options.disabled&&g},_mouseStart:function(g){var j=this.options,f=this.element.position(),e=this.element;this.resizing=true;this.documentScroll={top:c(document).scrollTop(),left:c(document).scrollLeft()};if(e.is(".ui-draggable")||(/absolute/).test(e.css("position"))){e.css({position:"absolute",top:f.top,left:f.left})}this._renderProxy();var k=b(this.helper.css("left")),h=b(this.helper.css("top"));if(j.containment){k+=c(j.containment).scrollLeft()||0;h+=c(j.containment).scrollTop()||0}this.offset=this.helper.offset();this.position={left:k,top:h};this.size=this._helper?{width:e.outerWidth(),height:e.outerHeight()}:{width:e.width(),height:e.height()};this.originalSize=this._helper?{width:e.outerWidth(),height:e.outerHeight()}:{width:e.width(),height:e.height()};this.originalPosition={left:k,top:h};this.sizeDiff={width:e.outerWidth()-e.width(),height:e.outerHeight()-e.height()};this.originalMousePosition={left:g.pageX,top:g.pageY};this.aspectRatio=(typeof j.aspectRatio=="number")?j.aspectRatio:((this.originalSize.width/this.originalSize.height)||1);var i=c(".ui-resizable-"+this.axis).css("cursor");c("body").css("cursor",i=="auto"?this.axis+"-resize":i);e.addClass("ui-resizable-resizing");this._propagate("start",g);return true},_mouseDrag:function(e){var h=this.helper,g=this.options,m={},q=this,j=this.originalMousePosition,n=this.axis;var r=(e.pageX-j.left)||0,p=(e.pageY-j.top)||0;var i=this._change[n];if(!i){return false}var l=i.apply(this,[e,r,p]),k=c.browser.msie&&c.browser.version<7,f=this.sizeDiff;this._updateVirtualBoundaries(e.shiftKey);if(this._aspectRatio||e.shiftKey){l=this._updateRatio(l,e)}l=this._respectSize(l,e);this._propagate("resize",e);h.css({top:this.position.top+"px",left:this.position.left+"px",width:this.size.width+"px",height:this.size.height+"px"});if(!this._helper&&this._proportionallyResizeElements.length){this._proportionallyResize()}this._updateCache(l);this._trigger("resize",e,this.ui());return false},_mouseStop:function(h){this.resizing=false;var i=this.options,m=this;if(this._helper){var g=this._proportionallyResizeElements,e=g.length&&(/textarea/i).test(g[0].nodeName),f=e&&c.ui.hasScroll(g[0],"left")?0:m.sizeDiff.height,k=e?0:m.sizeDiff.width;var n={width:(m.helper.width()-k),height:(m.helper.height()-f)},j=(parseInt(m.element.css("left"),10)+(m.position.left-m.originalPosition.left))||null,l=(parseInt(m.element.css("top"),10)+(m.position.top-m.originalPosition.top))||null;if(!i.animate){this.element.css(c.extend(n,{top:l,left:j}))}m.helper.height(m.size.height);m.helper.width(m.size.width);if(this._helper&&!i.animate){this._proportionallyResize()}}c("body").css("cursor","auto");this.element.removeClass("ui-resizable-resizing");this._propagate("stop",h);if(this._helper){this.helper.remove()}return false},_updateVirtualBoundaries:function(g){var j=this.options,i,h,f,k,e;e={minWidth:a(j.minWidth)?j.minWidth:0,maxWidth:a(j.maxWidth)?j.maxWidth:Infinity,minHeight:a(j.minHeight)?j.minHeight:0,maxHeight:a(j.maxHeight)?j.maxHeight:Infinity};if(this._aspectRatio||g){i=e.minHeight*this.aspectRatio;f=e.minWidth/this.aspectRatio;h=e.maxHeight*this.aspectRatio;k=e.maxWidth/this.aspectRatio;if(i>e.minWidth){e.minWidth=i}if(f>e.minHeight){e.minHeight=f}if(h<e.maxWidth){e.maxWidth=h}if(k<e.maxHeight){e.maxHeight=k}}this._vBoundaries=e},_updateCache:function(e){var f=this.options;this.offset=this.helper.offset();if(a(e.left)){this.position.left=e.left}if(a(e.top)){this.position.top=e.top}if(a(e.height)){this.size.height=e.height}if(a(e.width)){this.size.width=e.width}},_updateRatio:function(h,g){var i=this.options,j=this.position,f=this.size,e=this.axis;if(a(h.height)){h.width=(h.height*this.aspectRatio)}else{if(a(h.width)){h.height=(h.width/this.aspectRatio)}}if(e=="sw"){h.left=j.left+(f.width-h.width);h.top=null}if(e=="nw"){h.top=j.top+(f.height-h.height);h.left=j.left+(f.width-h.width)}return h},_respectSize:function(l,g){var j=this.helper,i=this._vBoundaries,r=this._aspectRatio||g.shiftKey,q=this.axis,t=a(l.width)&&i.maxWidth&&(i.maxWidth<l.width),m=a(l.height)&&i.maxHeight&&(i.maxHeight<l.height),h=a(l.width)&&i.minWidth&&(i.minWidth>l.width),s=a(l.height)&&i.minHeight&&(i.minHeight>l.height);if(h){l.width=i.minWidth}if(s){l.height=i.minHeight}if(t){l.width=i.maxWidth}if(m){l.height=i.maxHeight}var f=this.originalPosition.left+this.originalSize.width,p=this.position.top+this.size.height;var k=/sw|nw|w/.test(q),e=/nw|ne|n/.test(q);if(h&&k){l.left=f-i.minWidth}if(t&&k){l.left=f-i.maxWidth}if(s&&e){l.top=p-i.minHeight}if(m&&e){l.top=p-i.maxHeight}var n=!l.width&&!l.height;if(n&&!l.left&&l.top){l.top=null}else{if(n&&!l.top&&l.left){l.left=null}}return l},_proportionallyResize:function(){var k=this.options;if(!this._proportionallyResizeElements.length){return}var g=this.helper||this.element;for(var f=0;f<this._proportionallyResizeElements.length;f++){var h=this._proportionallyResizeElements[f];if(!this.borderDif){var e=[h.css("borderTopWidth"),h.css("borderRightWidth"),h.css("borderBottomWidth"),h.css("borderLeftWidth")],j=[h.css("paddingTop"),h.css("paddingRight"),h.css("paddingBottom"),h.css("paddingLeft")];this.borderDif=c.map(e,function(l,n){var m=parseInt(l,10)||0,o=parseInt(j[n],10)||0;return m+o})}if(c.browser.msie&&!(!(c(g).is(":hidden")||c(g).parents(":hidden").length))){continue}h.css({height:(g.height()-this.borderDif[0]-this.borderDif[2])||0,width:(g.width()-this.borderDif[1]-this.borderDif[3])||0})}},_renderProxy:function(){var f=this.element,i=this.options;this.elementOffset=f.offset();if(this._helper){this.helper=this.helper||c('<div style="overflow:hidden;"></div>');var e=c.browser.msie&&c.browser.version<7,g=(e?1:0),h=(e?2:-1);this.helper.addClass(this._helper).css({width:this.element.outerWidth()+h,height:this.element.outerHeight()+h,position:"absolute",left:this.elementOffset.left-g+"px",top:this.elementOffset.top-g+"px",zIndex:++i.zIndex});this.helper.appendTo("body").disableSelection()}else{this.helper=this.element}},_change:{e:function(g,f,e){return{width:this.originalSize.width+f}},w:function(h,f,e){var j=this.options,g=this.originalSize,i=this.originalPosition;return{left:i.left+f,width:g.width-f}},n:function(h,f,e){var j=this.options,g=this.originalSize,i=this.originalPosition;return{top:i.top+e,height:g.height-e}},s:function(g,f,e){return{height:this.originalSize.height+e}},se:function(g,f,e){return c.extend(this._change.s.apply(this,arguments),this._change.e.apply(this,[g,f,e]))},sw:function(g,f,e){return c.extend(this._change.s.apply(this,arguments),this._change.w.apply(this,[g,f,e]))},ne:function(g,f,e){return c.extend(this._change.n.apply(this,arguments),this._change.e.apply(this,[g,f,e]))},nw:function(g,f,e){return c.extend(this._change.n.apply(this,arguments),this._change.w.apply(this,[g,f,e]))}},_propagate:function(f,e){c.ui.plugin.call(this,f,[e,this.ui()]);(f!="resize"&&this._trigger(f,e,this.ui()))},plugins:{},ui:function(){return{originalElement:this.originalElement,element:this.element,helper:this.helper,position:this.position,size:this.size,originalSize:this.originalSize,originalPosition:this.originalPosition}}});c.extend(c.ui.resizable,{version:"1.8.18"});c.ui.plugin.add("resizable","alsoResize",{start:function(f,g){var e=c(this).data("resizable"),i=e.options;var h=function(j){c(j).each(function(){var k=c(this);k.data("resizable-alsoresize",{width:parseInt(k.width(),10),height:parseInt(k.height(),10),left:parseInt(k.css("left"),10),top:parseInt(k.css("top"),10)})})};if(typeof(i.alsoResize)=="object"&&!i.alsoResize.parentNode){if(i.alsoResize.length){i.alsoResize=i.alsoResize[0];h(i.alsoResize)}else{c.each(i.alsoResize,function(j){h(j)})}}else{h(i.alsoResize)}},resize:function(g,i){var f=c(this).data("resizable"),j=f.options,h=f.originalSize,l=f.originalPosition;var k={height:(f.size.height-h.height)||0,width:(f.size.width-h.width)||0,top:(f.position.top-l.top)||0,left:(f.position.left-l.left)||0},e=function(m,n){c(m).each(function(){var q=c(this),r=c(this).data("resizable-alsoresize"),p={},o=n&&n.length?n:q.parents(i.originalElement[0]).length?["width","height"]:["width","height","top","left"];c.each(o,function(s,u){var t=(r[u]||0)+(k[u]||0);if(t&&t>=0){p[u]=t||null}});q.css(p)})};if(typeof(j.alsoResize)=="object"&&!j.alsoResize.nodeType){c.each(j.alsoResize,function(m,n){e(m,n)})}else{e(j.alsoResize)}},stop:function(e,f){c(this).removeData("resizable-alsoresize")}});c.ui.plugin.add("resizable","animate",{stop:function(i,n){var p=c(this).data("resizable"),j=p.options;var h=p._proportionallyResizeElements,e=h.length&&(/textarea/i).test(h[0].nodeName),f=e&&c.ui.hasScroll(h[0],"left")?0:p.sizeDiff.height,l=e?0:p.sizeDiff.width;var g={width:(p.size.width-l),height:(p.size.height-f)},k=(parseInt(p.element.css("left"),10)+(p.position.left-p.originalPosition.left))||null,m=(parseInt(p.element.css("top"),10)+(p.position.top-p.originalPosition.top))||null;p.element.animate(c.extend(g,m&&k?{top:m,left:k}:{}),{duration:j.animateDuration,easing:j.animateEasing,step:function(){var o={width:parseInt(p.element.css("width"),10),height:parseInt(p.element.css("height"),10),top:parseInt(p.element.css("top"),10),left:parseInt(p.element.css("left"),10)};if(h&&h.length){c(h[0]).css({width:o.width,height:o.height})}p._updateCache(o);p._propagate("resize",i)}})}});c.ui.plugin.add("resizable","containment",{start:function(f,r){var t=c(this).data("resizable"),j=t.options,l=t.element;var g=j.containment,k=(g instanceof c)?g.get(0):(/parent/.test(g))?l.parent().get(0):g;if(!k){return}t.containerElement=c(k);if(/document/.test(g)||g==document){t.containerOffset={left:0,top:0};t.containerPosition={left:0,top:0};t.parentData={element:c(document),left:0,top:0,width:c(document).width(),height:c(document).height()||document.body.parentNode.scrollHeight}}else{var n=c(k),i=[];c(["Top","Right","Left","Bottom"]).each(function(p,o){i[p]=b(n.css("padding"+o))});t.containerOffset=n.offset();t.containerPosition=n.position();t.containerSize={height:(n.innerHeight()-i[3]),width:(n.innerWidth()-i[1])};var q=t.containerOffset,e=t.containerSize.height,m=t.containerSize.width,h=(c.ui.hasScroll(k,"left")?k.scrollWidth:m),s=(c.ui.hasScroll(k)?k.scrollHeight:e);t.parentData={element:k,left:q.left,top:q.top,width:h,height:s}}},resize:function(g,q){var t=c(this).data("resizable"),i=t.options,f=t.containerSize,p=t.containerOffset,m=t.size,n=t.position,r=t._aspectRatio||g.shiftKey,e={top:0,left:0},h=t.containerElement;if(h[0]!=document&&(/static/).test(h.css("position"))){e=p}if(n.left<(t._helper?p.left:0)){t.size.width=t.size.width+(t._helper?(t.position.left-p.left):(t.position.left-e.left));if(r){t.size.height=t.size.width/i.aspectRatio}t.position.left=i.helper?p.left:0}if(n.top<(t._helper?p.top:0)){t.size.height=t.size.height+(t._helper?(t.position.top-p.top):t.position.top);if(r){t.size.width=t.size.height*i.aspectRatio}t.position.top=t._helper?p.top:0}t.offset.left=t.parentData.left+t.position.left;t.offset.top=t.parentData.top+t.position.top;var l=Math.abs((t._helper?t.offset.left-e.left:(t.offset.left-e.left))+t.sizeDiff.width),s=Math.abs((t._helper?t.offset.top-e.top:(t.offset.top-p.top))+t.sizeDiff.height);var k=t.containerElement.get(0)==t.element.parent().get(0),j=/relative|absolute/.test(t.containerElement.css("position"));if(k&&j){l-=t.parentData.left}if(l+t.size.width>=t.parentData.width){t.size.width=t.parentData.width-l;if(r){t.size.height=t.size.width/t.aspectRatio}}if(s+t.size.height>=t.parentData.height){t.size.height=t.parentData.height-s;if(r){t.size.width=t.size.height*t.aspectRatio}}},stop:function(f,n){var q=c(this).data("resizable"),g=q.options,l=q.position,m=q.containerOffset,e=q.containerPosition,i=q.containerElement;var j=c(q.helper),r=j.offset(),p=j.outerWidth()-q.sizeDiff.width,k=j.outerHeight()-q.sizeDiff.height;if(q._helper&&!g.animate&&(/relative/).test(i.css("position"))){c(this).css({left:r.left-e.left-m.left,width:p,height:k})}if(q._helper&&!g.animate&&(/static/).test(i.css("position"))){c(this).css({left:r.left-e.left-m.left,width:p,height:k})}}});c.ui.plugin.add("resizable","ghost",{start:function(g,h){var e=c(this).data("resizable"),i=e.options,f=e.size;e.ghost=e.originalElement.clone();e.ghost.css({opacity:0.25,display:"block",position:"relative",height:f.height,width:f.width,margin:0,left:0,top:0}).addClass("ui-resizable-ghost").addClass(typeof i.ghost=="string"?i.ghost:"");e.ghost.appendTo(e.helper)},resize:function(f,g){var e=c(this).data("resizable"),h=e.options;if(e.ghost){e.ghost.css({position:"relative",height:e.size.height,width:e.size.width})}},stop:function(f,g){var e=c(this).data("resizable"),h=e.options;if(e.ghost&&e.helper){e.helper.get(0).removeChild(e.ghost.get(0))}}});c.ui.plugin.add("resizable","grid",{resize:function(e,m){var p=c(this).data("resizable"),h=p.options,k=p.size,i=p.originalSize,j=p.originalPosition,n=p.axis,l=h._aspectRatio||e.shiftKey;h.grid=typeof h.grid=="number"?[h.grid,h.grid]:h.grid;var g=Math.round((k.width-i.width)/(h.grid[0]||1))*(h.grid[0]||1),f=Math.round((k.height-i.height)/(h.grid[1]||1))*(h.grid[1]||1);if(/^(se|s|e)$/.test(n)){p.size.width=i.width+g;p.size.height=i.height+f}else{if(/^(ne)$/.test(n)){p.size.width=i.width+g;p.size.height=i.height+f;p.position.top=j.top-f}else{if(/^(sw)$/.test(n)){p.size.width=i.width+g;p.size.height=i.height+f;p.position.left=j.left-g}else{p.size.width=i.width+g;p.size.height=i.height+f;p.position.top=j.top-f;p.position.left=j.left-g}}}}});var b=function(e){return parseInt(e,10)||0};var a=function(e){return !isNaN(parseInt(e,10))}})(jQuery);/*
- * jQuery hashchange event - v1.3 - 7/21/2010
- * http://benalman.com/projects/jquery-hashchange-plugin/
- *
- * Copyright (c) 2010 "Cowboy" Ben Alman
- * Dual licensed under the MIT and GPL licenses.
- * http://benalman.com/about/license/
- */
-(function($,e,b){var c="hashchange",h=document,f,g=$.event.special,i=h.documentMode,d="on"+c in e&&(i===b||i>7);function a(j){j=j||location.href;return"#"+j.replace(/^[^#]*#?(.*)$/,"$1")}$.fn[c]=function(j){return j?this.bind(c,j):this.trigger(c)};$.fn[c].delay=50;g[c]=$.extend(g[c],{setup:function(){if(d){return false}$(f.start)},teardown:function(){if(d){return false}$(f.stop)}});f=(function(){var j={},p,m=a(),k=function(q){return q},l=k,o=k;j.start=function(){p||n()};j.stop=function(){p&&clearTimeout(p);p=b};function n(){var r=a(),q=o(m);if(r!==m){l(m=r,q);$(e).trigger(c)}else{if(q!==m){location.href=location.href.replace(/#.*/,"")+q}}p=setTimeout(n,$.fn[c].delay)}$.browser.msie&&!d&&(function(){var q,r;j.start=function(){if(!q){r=$.fn[c].src;r=r&&r+a();q=$('<iframe tabindex="-1" title="empty"/>').hide().one("load",function(){r||l(a());n()}).attr("src",r||"javascript:0").insertAfter("body")[0].contentWindow;h.onpropertychange=function(){try{if(event.propertyName==="title"){q.document.title=h.title}}catch(s){}}}};j.stop=k;o=function(){return a(q.location.href)};l=function(v,s){var u=q.document,t=$.fn[c].domain;if(v!==s){u.title=h.title;u.open();t&&u.write('<script>document.domain="'+t+'"<\/script>');u.close();q.location.hash=v}}})();return j})()})(jQuery,this);(function(c){var a=c.scrollTo=function(f,e,d){c(window).scrollTo(f,e,d)};a.defaults={axis:"xy",duration:parseFloat(c.fn.jquery)>=1.3?0:1};a.window=function(d){return c(window)._scrollable()};c.fn._scrollable=function(){return this.map(function(){var e=this,d=!e.nodeName||c.inArray(e.nodeName.toLowerCase(),["iframe","#document","html","body"])!=-1;if(!d){return e}var f=(e.contentWindow||e).document||e.ownerDocument||e;return c.browser.safari||f.compatMode=="BackCompat"?f.body:f.documentElement})};c.fn.scrollTo=function(f,e,d){if(typeof e=="object"){d=e;e=0}if(typeof d=="function"){d={onAfter:d}}if(f=="max"){f=9000000000}d=c.extend({},a.defaults,d);e=e||d.speed||d.duration;d.queue=d.queue&&d.axis.length>1;if(d.queue){e/=2}d.offset=b(d.offset);d.over=b(d.over);return this._scrollable().each(function(){var l=this,j=c(l),k=f,i,g={},m=j.is("html,body");switch(typeof k){case"number":case"string":if(/^([+-]=)?\d+(\.\d+)?(px|%)?$/.test(k)){k=b(k);break}k=c(k,this);case"object":if(k.is||k.style){i=(k=c(k)).offset()}}c.each(d.axis.split(""),function(q,r){var s=r=="x"?"Left":"Top",u=s.toLowerCase(),p="scroll"+s,o=l[p],n=a.max(l,r);if(i){g[p]=i[u]+(m?0:o-j.offset()[u]);if(d.margin){g[p]-=parseInt(k.css("margin"+s))||0;g[p]-=parseInt(k.css("border"+s+"Width"))||0}g[p]+=d.offset[u]||0;if(d.over[u]){g[p]+=k[r=="x"?"width":"height"]()*d.over[u]}}else{var t=k[u];g[p]=t.slice&&t.slice(-1)=="%"?parseFloat(t)/100*n:t}if(/^\d+$/.test(g[p])){g[p]=g[p]<=0?0:Math.min(g[p],n)}if(!q&&d.queue){if(o!=g[p]){h(d.onAfterFirst)}delete g[p]}});h(d.onAfter);function h(n){j.animate(g,e,d.easing,n&&function(){n.call(this,f,d)})}}).end()};a.max=function(j,i){var h=i=="x"?"Width":"Height",e="scroll"+h;if(!c(j).is("html,body")){return j[e]-c(j)[h.toLowerCase()]()}var g="client"+h,f=j.ownerDocument.documentElement,d=j.ownerDocument.body;return Math.max(f[e],d[e])-Math.min(f[g],d[g])};function b(d){return typeof d=="object"?d:{top:d,left:d}}})(jQuery);/*
- PowerTip - v1.2.0 - 2013-04-03
- http://stevenbenner.github.com/jquery-powertip/
- Copyright (c) 2013 Steven Benner (http://stevenbenner.com/).
- Released under MIT license.
- https://raw.github.com/stevenbenner/jquery-powertip/master/LICENSE.txt
-*/
-(function(a){if(typeof define==="function"&&define.amd){define(["jquery"],a)}else{a(jQuery)}}(function(k){var A=k(document),s=k(window),w=k("body");var n="displayController",e="hasActiveHover",d="forcedOpen",u="hasMouseMove",f="mouseOnToPopup",g="originalTitle",y="powertip",o="powertipjq",l="powertiptarget",E=180/Math.PI;var c={isTipOpen:false,isFixedTipOpen:false,isClosing:false,tipOpenImminent:false,activeHover:null,currentX:0,currentY:0,previousX:0,previousY:0,desyncTimeout:null,mouseTrackingActive:false,delayInProgress:false,windowWidth:0,windowHeight:0,scrollTop:0,scrollLeft:0};var p={none:0,top:1,bottom:2,left:4,right:8};k.fn.powerTip=function(F,N){if(!this.length){return this}if(k.type(F)==="string"&&k.powerTip[F]){return k.powerTip[F].call(this,this,N)}var O=k.extend({},k.fn.powerTip.defaults,F),G=new x(O);h();this.each(function M(){var R=k(this),Q=R.data(y),P=R.data(o),T=R.data(l),S;if(R.data(n)){k.powerTip.destroy(R)}S=R.attr("title");if(!Q&&!T&&!P&&S){R.data(y,S);R.data(g,S);R.removeAttr("title")}R.data(n,new t(R,O,G))});if(!O.manual){this.on({"mouseenter.powertip":function J(P){k.powerTip.show(this,P)},"mouseleave.powertip":function L(){k.powerTip.hide(this)},"focus.powertip":function K(){k.powerTip.show(this)},"blur.powertip":function H(){k.powerTip.hide(this,true)},"keydown.powertip":function I(P){if(P.keyCode===27){k.powerTip.hide(this,true)}}})}return this};k.fn.powerTip.defaults={fadeInTime:200,fadeOutTime:100,followMouse:false,popupId:"powerTip",intentSensitivity:7,intentPollInterval:100,closeDelay:100,placement:"n",smartPlacement:false,offset:10,mouseOnToPopup:false,manual:false};k.fn.powerTip.smartPlacementLists={n:["n","ne","nw","s"],e:["e","ne","se","w","nw","sw","n","s","e"],s:["s","se","sw","n"],w:["w","nw","sw","e","ne","se","n","s","w"],nw:["nw","w","sw","n","s","se","nw"],ne:["ne","e","se","n","s","sw","ne"],sw:["sw","w","nw","s","n","ne","sw"],se:["se","e","ne","s","n","nw","se"],"nw-alt":["nw-alt","n","ne-alt","sw-alt","s","se-alt","w","e"],"ne-alt":["ne-alt","n","nw-alt","se-alt","s","sw-alt","e","w"],"sw-alt":["sw-alt","s","se-alt","nw-alt","n","ne-alt","w","e"],"se-alt":["se-alt","s","sw-alt","ne-alt","n","nw-alt","e","w"]};k.powerTip={show:function z(F,G){if(G){i(G);c.previousX=G.pageX;c.previousY=G.pageY;k(F).data(n).show()}else{k(F).first().data(n).show(true,true)}return F},reposition:function r(F){k(F).first().data(n).resetPosition();return F},hide:function D(G,F){if(G){k(G).first().data(n).hide(F)}else{if(c.activeHover){c.activeHover.data(n).hide(true)}}return G},destroy:function C(G){k(G).off(".powertip").each(function F(){var I=k(this),H=[g,n,e,d];if(I.data(g)){I.attr("title",I.data(g));H.push(y)}I.removeData(H)});return G}};k.powerTip.showTip=k.powerTip.show;k.powerTip.closeTip=k.powerTip.hide;function b(){var F=this;F.top="auto";F.left="auto";F.right="auto";F.bottom="auto";F.set=function(H,G){if(k.isNumeric(G)){F[H]=Math.round(G)}}}function t(K,N,F){var J=null;function L(P,Q){M();if(!K.data(e)){if(!P){c.tipOpenImminent=true;J=setTimeout(function O(){J=null;I()},N.intentPollInterval)}else{if(Q){K.data(d,true)}F.showTip(K)}}}function G(P){M();c.tipOpenImminent=false;if(K.data(e)){K.data(d,false);if(!P){c.delayInProgress=true;J=setTimeout(function O(){J=null;F.hideTip(K);c.delayInProgress=false},N.closeDelay)}else{F.hideTip(K)}}}function I(){var Q=Math.abs(c.previousX-c.currentX),O=Math.abs(c.previousY-c.currentY),P=Q+O;if(P<N.intentSensitivity){F.showTip(K)}else{c.previousX=c.currentX;c.previousY=c.currentY;L()}}function M(){J=clearTimeout(J);c.delayInProgress=false}function H(){F.resetPosition(K)}this.show=L;this.hide=G;this.cancel=M;this.resetPosition=H}function j(){function G(M,L,J,O,P){var K=L.split("-")[0],N=new b(),I;if(q(M)){I=H(M,K)}else{I=F(M,K)}switch(L){case"n":N.set("left",I.left-(J/2));N.set("bottom",c.windowHeight-I.top+P);break;case"e":N.set("left",I.left+P);N.set("top",I.top-(O/2));break;case"s":N.set("left",I.left-(J/2));N.set("top",I.top+P);break;case"w":N.set("top",I.top-(O/2));N.set("right",c.windowWidth-I.left+P);break;case"nw":N.set("bottom",c.windowHeight-I.top+P);N.set("right",c.windowWidth-I.left-20);break;case"nw-alt":N.set("left",I.left);N.set("bottom",c.windowHeight-I.top+P);break;case"ne":N.set("left",I.left-20);N.set("bottom",c.windowHeight-I.top+P);break;case"ne-alt":N.set("bottom",c.windowHeight-I.top+P);N.set("right",c.windowWidth-I.left);break;case"sw":N.set("top",I.top+P);N.set("right",c.windowWidth-I.left-20);break;case"sw-alt":N.set("left",I.left);N.set("top",I.top+P);break;case"se":N.set("left",I.left-20);N.set("top",I.top+P);break;case"se-alt":N.set("top",I.top+P);N.set("right",c.windowWidth-I.left);break}return N}function F(K,J){var O=K.offset(),N=K.outerWidth(),I=K.outerHeight(),M,L;switch(J){case"n":M=O.left+N/2;L=O.top;break;case"e":M=O.left+N;L=O.top+I/2;break;case"s":M=O.left+N/2;L=O.top+I;break;case"w":M=O.left;L=O.top+I/2;break;case"nw":M=O.left;L=O.top;break;case"ne":M=O.left+N;L=O.top;break;case"sw":M=O.left;L=O.top+I;break;case"se":M=O.left+N;L=O.top+I;break}return{top:L,left:M}}function H(O,K){var S=O.closest("svg")[0],N=O[0],W=S.createSVGPoint(),L=N.getBBox(),V=N.getScreenCTM(),M=L.width/2,Q=L.height/2,P=[],I=["nw","n","ne","e","se","s","sw","w"],U,X,R,T;function J(){P.push(W.matrixTransform(V))}W.x=L.x;W.y=L.y;J();W.x+=M;J();W.x+=M;J();W.y+=Q;J();W.y+=Q;J();W.x-=M;J();W.x-=M;J();W.y-=Q;J();if(P[0].y!==P[1].y||P[0].x!==P[7].x){X=Math.atan2(V.b,V.a)*E;R=Math.ceil(((X%360)-22.5)/45);if(R<1){R+=8}while(R--){I.push(I.shift())}}for(T=0;T<P.length;T++){if(I[T]===K){U=P[T];break}}return{top:U.y+c.scrollTop,left:U.x+c.scrollLeft}}this.compute=G}function x(Q){var P=new j(),O=k("#"+Q.popupId);if(O.length===0){O=k("<div/>",{id:Q.popupId});if(w.length===0){w=k("body")}w.append(O)}if(Q.followMouse){if(!O.data(u)){A.on("mousemove",M);s.on("scroll",M);O.data(u,true)}}if(Q.mouseOnToPopup){O.on({mouseenter:function L(){if(O.data(f)){if(c.activeHover){c.activeHover.data(n).cancel()}}},mouseleave:function N(){if(c.activeHover){c.activeHover.data(n).hide()}}})}function I(S){S.data(e,true);O.queue(function R(T){H(S);T()})}function H(S){var U;if(!S.data(e)){return}if(c.isTipOpen){if(!c.isClosing){K(c.activeHover)}O.delay(100).queue(function R(V){H(S);V()});return}S.trigger("powerTipPreRender");U=B(S);if(U){O.empty().append(U)}else{return}S.trigger("powerTipRender");c.activeHover=S;c.isTipOpen=true;O.data(f,Q.mouseOnToPopup);if(!Q.followMouse){G(S);c.isFixedTipOpen=true}else{M()}O.fadeIn(Q.fadeInTime,function T(){if(!c.desyncTimeout){c.desyncTimeout=setInterval(J,500)}S.trigger("powerTipOpen")})}function K(R){c.isClosing=true;c.activeHover=null;c.isTipOpen=false;c.desyncTimeout=clearInterval(c.desyncTimeout);R.data(e,false);R.data(d,false);O.fadeOut(Q.fadeOutTime,function S(){var T=new b();c.isClosing=false;c.isFixedTipOpen=false;O.removeClass();T.set("top",c.currentY+Q.offset);T.set("left",c.currentX+Q.offset);O.css(T);R.trigger("powerTipClose")})}function M(){if(!c.isFixedTipOpen&&(c.isTipOpen||(c.tipOpenImminent&&O.data(u)))){var R=O.outerWidth(),V=O.outerHeight(),U=new b(),S,T;U.set("top",c.currentY+Q.offset);U.set("left",c.currentX+Q.offset);S=m(U,R,V);if(S!==p.none){T=a(S);if(T===1){if(S===p.right){U.set("left",c.windowWidth-R)}else{if(S===p.bottom){U.set("top",c.scrollTop+c.windowHeight-V)}}}else{U.set("left",c.currentX-R-Q.offset);U.set("top",c.currentY-V-Q.offset)}}O.css(U)}}function G(S){var R,T;if(Q.smartPlacement){R=k.fn.powerTip.smartPlacementLists[Q.placement];k.each(R,function(U,W){var V=m(F(S,W),O.outerWidth(),O.outerHeight());T=W;if(V===p.none){return false}})}else{F(S,Q.placement);T=Q.placement}O.addClass(T)}function F(U,T){var R=0,S,W,V=new b();V.set("top",0);V.set("left",0);O.css(V);do{S=O.outerWidth();W=O.outerHeight();V=P.compute(U,T,S,W,Q.offset);O.css(V)}while(++R<=5&&(S!==O.outerWidth()||W!==O.outerHeight()));return V}function J(){var R=false;if(c.isTipOpen&&!c.isClosing&&!c.delayInProgress){if(c.activeHover.data(e)===false||c.activeHover.is(":disabled")){R=true}else{if(!v(c.activeHover)&&!c.activeHover.is(":focus")&&!c.activeHover.data(d)){if(O.data(f)){if(!v(O)){R=true}}else{R=true}}}if(R){K(c.activeHover)}}}this.showTip=I;this.hideTip=K;this.resetPosition=G}function q(F){return window.SVGElement&&F[0] instanceof SVGElement}function h(){if(!c.mouseTrackingActive){c.mouseTrackingActive=true;k(function H(){c.scrollLeft=s.scrollLeft();c.scrollTop=s.scrollTop();c.windowWidth=s.width();c.windowHeight=s.height()});A.on("mousemove",i);s.on({resize:function G(){c.windowWidth=s.width();c.windowHeight=s.height()},scroll:function F(){var I=s.scrollLeft(),J=s.scrollTop();if(I!==c.scrollLeft){c.currentX+=I-c.scrollLeft;c.scrollLeft=I}if(J!==c.scrollTop){c.currentY+=J-c.scrollTop;c.scrollTop=J}}})}}function i(F){c.currentX=F.pageX;c.currentY=F.pageY}function v(F){var H=F.offset(),J=F[0].getBoundingClientRect(),I=J.right-J.left,G=J.bottom-J.top;return c.currentX>=H.left&&c.currentX<=H.left+I&&c.currentY>=H.top&&c.currentY<=H.top+G}function B(I){var G=I.data(y),F=I.data(o),K=I.data(l),H,J;if(G){if(k.isFunction(G)){G=G.call(I[0])}J=G}else{if(F){if(k.isFunction(F)){F=F.call(I[0])}if(F.length>0){J=F.clone(true,true)}}else{if(K){H=k("#"+K);if(H.length>0){J=H.html()}}}}return J}function m(M,L,K){var G=c.scrollTop,J=c.scrollLeft,I=G+c.windowHeight,F=J+c.windowWidth,H=p.none;if(M.top<G||Math.abs(M.bottom-c.windowHeight)-K<G){H|=p.top}if(M.top+K>I||Math.abs(M.bottom-c.windowHeight)>I){H|=p.bottom}if(M.left<J||M.right+L>F){H|=p.left}if(M.left+L>F||M.right<J){H|=p.right}return H}function a(G){var F=0;while(G){G&=G-1;F++}return F}}));
\ No newline at end of file
diff --git a/docs/html/modules.html b/docs/html/modules.html
deleted file mode 100644
index b78fe83..0000000
--- a/docs/html/modules.html
+++ /dev/null
@@ -1,111 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: Modules</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li class="current"><a href="modules.html"><span>Modules</span></a></li>
- <li><a href="annotated.html"><span>Classes</span></a></li>
- <li><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
-</div><!-- top -->
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-<div class="header">
- <div class="headertitle">
-<div class="title">Modules</div> </div>
-</div><!--header-->
-<div class="contents">
-<div class="textblock">Here is a list of all modules:</div><div class="directory">
-<table class="directory">
-<tr id="row_0_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><a class="el" href="group__platform.html" target="_self">Implementation-specific definitions</a></td><td class="desc"></td></tr>
-<tr id="row_1_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><a class="el" href="group__initialization.html" target="_self">Library initialization</a></td><td class="desc"></td></tr>
-<tr id="row_2_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><a class="el" href="group__policy.html" target="_self">Key policies</a></td><td class="desc"></td></tr>
-<tr id="row_3_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><a class="el" href="group__key__management.html" target="_self">Key management</a></td><td class="desc"></td></tr>
-<tr id="row_4_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><a class="el" href="group__import__export.html" target="_self">Key import and export</a></td><td class="desc"></td></tr>
-<tr id="row_5_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><a class="el" href="group__hash.html" target="_self">Message digests</a></td><td class="desc"></td></tr>
-<tr id="row_6_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><a class="el" href="group__MAC.html" target="_self">Message authentication codes</a></td><td class="desc"></td></tr>
-<tr id="row_7_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><a class="el" href="group__cipher.html" target="_self">Symmetric ciphers</a></td><td class="desc"></td></tr>
-<tr id="row_8_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><a class="el" href="group__aead.html" target="_self">Authenticated encryption with associated data (AEAD)</a></td><td class="desc"></td></tr>
-<tr id="row_9_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><a class="el" href="group__asymmetric.html" target="_self">Asymmetric cryptography</a></td><td class="desc"></td></tr>
-<tr id="row_10_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><a class="el" href="group__generators.html" target="_self">Generators</a></td><td class="desc"></td></tr>
-<tr id="row_11_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><a class="el" href="group__derivation.html" target="_self">Key derivation</a></td><td class="desc"></td></tr>
-<tr id="row_12_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><a class="el" href="group__random.html" target="_self">Random generation</a></td><td class="desc"></td></tr>
-<tr id="row_13_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><a class="el" href="group__error.html" target="_self">Error codes</a></td><td class="desc"></td></tr>
-<tr id="row_14_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><a class="el" href="group__crypto__types.html" target="_self">Key and algorithm types</a></td><td class="desc"></td></tr>
-<tr id="row_15_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><a class="el" href="group__key__lifetimes.html" target="_self">Key lifetimes</a></td><td class="desc"></td></tr>
-</table>
-</div><!-- directory -->
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/nav_f.png b/docs/html/nav_f.png
deleted file mode 100644
index 72a58a5..0000000
--- a/docs/html/nav_f.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/nav_g.png b/docs/html/nav_g.png
deleted file mode 100644
index 2093a23..0000000
--- a/docs/html/nav_g.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/nav_h.png b/docs/html/nav_h.png
deleted file mode 100644
index 33389b1..0000000
--- a/docs/html/nav_h.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/objects.inv b/docs/html/objects.inv
new file mode 100644
index 0000000..2df1e5e
--- /dev/null
+++ b/docs/html/objects.inv
Binary files differ
diff --git a/docs/html/open.png b/docs/html/open.png
deleted file mode 100644
index 30f75c7..0000000
--- a/docs/html/open.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/psa_c-identifiers.html b/docs/html/psa_c-identifiers.html
new file mode 100644
index 0000000..ddc3b8e
--- /dev/null
+++ b/docs/html/psa_c-identifiers.html
@@ -0,0 +1,2066 @@
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+ <title>Index of C identifiers — psa_crypto_api 1.0 beta3 documentation</title>
+ <link rel="stylesheet" href="_static/alabaster.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+ <script type="text/javascript" id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
+ <script type="text/javascript" src="_static/jquery.js"></script>
+ <script type="text/javascript" src="_static/underscore.js"></script>
+ <script type="text/javascript" src="_static/doctools.js"></script>
+ <script type="text/javascript" src="_static/language_data.js"></script>
+ <link rel="index" title="Index" href="genindex.html" />
+ <link rel="search" title="Search" href="search.html" />
+
+
+ <link rel="stylesheet" href="_static/custom.css" type="text/css" />
+
+
+ <meta name="viewport" content="width=device-width, initial-scale=0.9, maximum-scale=0.9" />
+
+
+
+ </head><body>
+
+
+ <div class="document">
+ <div class="documentwrapper">
+ <div class="bodywrapper">
+
+
+ <div class="body" role="main">
+
+
+ <h1>Index of C identifiers</h1>
+
+ <div class="modindex-jumpbox">
+ <a href="#cap-PSA_A"><strong>PSA_A</strong></a> |
+ <a href="#cap-PSA_B"><strong>PSA_B</strong></a> |
+ <a href="#cap-PSA_C"><strong>PSA_C</strong></a> |
+ <a href="#cap-PSA_D"><strong>PSA_D</strong></a> |
+ <a href="#cap-PSA_E"><strong>PSA_E</strong></a> |
+ <a href="#cap-PSA_G"><strong>PSA_G</strong></a> |
+ <a href="#cap-PSA_H"><strong>PSA_H</strong></a> |
+ <a href="#cap-PSA_I"><strong>PSA_I</strong></a> |
+ <a href="#cap-PSA_K"><strong>PSA_K</strong></a> |
+ <a href="#cap-PSA_M"><strong>PSA_M</strong></a> |
+ <a href="#cap-PSA_O"><strong>PSA_O</strong></a> |
+ <a href="#cap-PSA_R"><strong>PSA_R</strong></a> |
+ <a href="#cap-PSA_S"><strong>PSA_S</strong></a> |
+ <a href="#cap-PSA_V"><strong>PSA_V</strong></a> |
+ <a href="#cap-PSA__"><strong>PSA__</strong></a>
+ </div>
+
+ <table class="indextable modindextable">
+ <tr class="pcap"><td></td><td> </td><td></td></tr>
+ <tr class="cap" id="cap-PSA_A"><td></td><td>
+ <strong>PSA_A</strong></td><td></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_AEAD_DECRYPT_OUTPUT_SIZE"><code class="xref">PSA_AEAD_DECRYPT_OUTPUT_SIZE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_AEAD_ENCRYPT_OUTPUT_SIZE"><code class="xref">PSA_AEAD_ENCRYPT_OUTPUT_SIZE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_AEAD_FINISH_OUTPUT_SIZE"><code class="xref">PSA_AEAD_FINISH_OUTPUT_SIZE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_AEAD_OPERATION_INIT"><code class="xref">PSA_AEAD_OPERATION_INIT</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_AEAD_TAG_LENGTH"><code class="xref">PSA_AEAD_TAG_LENGTH</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_AEAD_TAG_LENGTH_OFFSET"><code class="xref">PSA_AEAD_TAG_LENGTH_OFFSET</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_AEAD_UPDATE_OUTPUT_SIZE"><code class="xref">PSA_AEAD_UPDATE_OUTPUT_SIZE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_AEAD_VERIFY_OUTPUT_SIZE"><code class="xref">PSA_AEAD_VERIFY_OUTPUT_SIZE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_AEAD_FROM_BLOCK_FLAG"><code class="xref">PSA_ALG_AEAD_FROM_BLOCK_FLAG</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_AEAD_TAG_LENGTH_MASK"><code class="xref">PSA_ALG_AEAD_TAG_LENGTH_MASK</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_AEAD_WITH_DEFAULT_TAG_LENGTH"><code class="xref">PSA_ALG_AEAD_WITH_DEFAULT_TAG_LENGTH</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_AEAD_WITH_TAG_LENGTH"><code class="xref">PSA_ALG_AEAD_WITH_TAG_LENGTH</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_ANY_HASH"><code class="xref">PSA_ALG_ANY_HASH</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_ARC4"><code class="xref">PSA_ALG_ARC4</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_CATEGORY_AEAD"><code class="xref">PSA_ALG_CATEGORY_AEAD</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION"><code class="xref">PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_CATEGORY_CIPHER"><code class="xref">PSA_ALG_CATEGORY_CIPHER</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_CATEGORY_HASH"><code class="xref">PSA_ALG_CATEGORY_HASH</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_CATEGORY_KEY_AGREEMENT"><code class="xref">PSA_ALG_CATEGORY_KEY_AGREEMENT</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_CATEGORY_KEY_DERIVATION"><code class="xref">PSA_ALG_CATEGORY_KEY_DERIVATION</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_CATEGORY_MAC"><code class="xref">PSA_ALG_CATEGORY_MAC</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_CATEGORY_MASK"><code class="xref">PSA_ALG_CATEGORY_MASK</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_CATEGORY_SIGN"><code class="xref">PSA_ALG_CATEGORY_SIGN</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_CBC_MAC"><code class="xref">PSA_ALG_CBC_MAC</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_CBC_NO_PADDING"><code class="xref">PSA_ALG_CBC_NO_PADDING</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_CBC_PKCS7"><code class="xref">PSA_ALG_CBC_PKCS7</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_CCM"><code class="xref">PSA_ALG_CCM</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_CFB"><code class="xref">PSA_ALG_CFB</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_CHACHA20"><code class="xref">PSA_ALG_CHACHA20</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_CHACHA20_POLY1305"><code class="xref">PSA_ALG_CHACHA20_POLY1305</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_CIPHER_FROM_BLOCK_FLAG"><code class="xref">PSA_ALG_CIPHER_FROM_BLOCK_FLAG</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_CIPHER_MAC_BASE"><code class="xref">PSA_ALG_CIPHER_MAC_BASE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_CIPHER_STREAM_FLAG"><code class="xref">PSA_ALG_CIPHER_STREAM_FLAG</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_CMAC"><code class="xref">PSA_ALG_CMAC</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_CTR"><code class="xref">PSA_ALG_CTR</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_DETERMINISTIC_ECDSA"><code class="xref">PSA_ALG_DETERMINISTIC_ECDSA</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_DETERMINISTIC_ECDSA_BASE"><code class="xref">PSA_ALG_DETERMINISTIC_ECDSA_BASE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_ECDH"><code class="xref">PSA_ALG_ECDH</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_ECDSA"><code class="xref">PSA_ALG_ECDSA</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_ECDSA_ANY"><code class="xref">PSA_ALG_ECDSA_ANY</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_ECDSA_BASE"><code class="xref">PSA_ALG_ECDSA_BASE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_ECDSA_IS_DETERMINISTIC"><code class="xref">PSA_ALG_ECDSA_IS_DETERMINISTIC</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_FFDH"><code class="xref">PSA_ALG_FFDH</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_FULL_LENGTH_MAC"><code class="xref">PSA_ALG_FULL_LENGTH_MAC</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_GCM"><code class="xref">PSA_ALG_GCM</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_GMAC"><code class="xref">PSA_ALG_GMAC</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_HASH_MASK"><code class="xref">PSA_ALG_HASH_MASK</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_HKDF"><code class="xref">PSA_ALG_HKDF</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_HKDF_BASE"><code class="xref">PSA_ALG_HKDF_BASE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_HKDF_GET_HASH"><code class="xref">PSA_ALG_HKDF_GET_HASH</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_HMAC"><code class="xref">PSA_ALG_HMAC</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_HMAC_BASE"><code class="xref">PSA_ALG_HMAC_BASE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_HMAC_GET_HASH"><code class="xref">PSA_ALG_HMAC_GET_HASH</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_IS_AEAD"><code class="xref">PSA_ALG_IS_AEAD</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_IS_AEAD_ON_BLOCK_CIPHER"><code class="xref">PSA_ALG_IS_AEAD_ON_BLOCK_CIPHER</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_IS_ASYMMETRIC_ENCRYPTION"><code class="xref">PSA_ALG_IS_ASYMMETRIC_ENCRYPTION</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_IS_BLOCK_CIPHER_MAC"><code class="xref">PSA_ALG_IS_BLOCK_CIPHER_MAC</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_IS_CIPHER"><code class="xref">PSA_ALG_IS_CIPHER</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_IS_DETERMINISTIC_ECDSA"><code class="xref">PSA_ALG_IS_DETERMINISTIC_ECDSA</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_IS_ECDH"><code class="xref">PSA_ALG_IS_ECDH</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_IS_ECDSA"><code class="xref">PSA_ALG_IS_ECDSA</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_IS_FFDH"><code class="xref">PSA_ALG_IS_FFDH</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_IS_HASH"><code class="xref">PSA_ALG_IS_HASH</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_IS_HASH_AND_SIGN"><code class="xref">PSA_ALG_IS_HASH_AND_SIGN</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_IS_HKDF"><code class="xref">PSA_ALG_IS_HKDF</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_IS_HMAC"><code class="xref">PSA_ALG_IS_HMAC</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_IS_KEY_AGREEMENT"><code class="xref">PSA_ALG_IS_KEY_AGREEMENT</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_IS_KEY_DERIVATION"><code class="xref">PSA_ALG_IS_KEY_DERIVATION</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_IS_KEY_DERIVATION_OR_AGREEMENT"><code class="xref">PSA_ALG_IS_KEY_DERIVATION_OR_AGREEMENT</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_IS_MAC"><code class="xref">PSA_ALG_IS_MAC</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_IS_RANDOMIZED_ECDSA"><code class="xref">PSA_ALG_IS_RANDOMIZED_ECDSA</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_IS_RAW_KEY_AGREEMENT"><code class="xref">PSA_ALG_IS_RAW_KEY_AGREEMENT</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_IS_RSA_OAEP"><code class="xref">PSA_ALG_IS_RSA_OAEP</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_IS_RSA_PKCS1V15_SIGN"><code class="xref">PSA_ALG_IS_RSA_PKCS1V15_SIGN</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_IS_RSA_PSS"><code class="xref">PSA_ALG_IS_RSA_PSS</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_IS_SIGN"><code class="xref">PSA_ALG_IS_SIGN</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_IS_STREAM_CIPHER"><code class="xref">PSA_ALG_IS_STREAM_CIPHER</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_IS_TLS12_PRF"><code class="xref">PSA_ALG_IS_TLS12_PRF</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_IS_TLS12_PSK_TO_MS"><code class="xref">PSA_ALG_IS_TLS12_PSK_TO_MS</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_IS_VENDOR_DEFINED"><code class="xref">PSA_ALG_IS_VENDOR_DEFINED</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_IS_WILDCARD"><code class="xref">PSA_ALG_IS_WILDCARD</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_KEY_AGREEMENT"><code class="xref">PSA_ALG_KEY_AGREEMENT</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_KEY_AGREEMENT_GET_BASE"><code class="xref">PSA_ALG_KEY_AGREEMENT_GET_BASE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_KEY_AGREEMENT_GET_KDF"><code class="xref">PSA_ALG_KEY_AGREEMENT_GET_KDF</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_KEY_AGREEMENT_MASK"><code class="xref">PSA_ALG_KEY_AGREEMENT_MASK</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_KEY_DERIVATION_MASK"><code class="xref">PSA_ALG_KEY_DERIVATION_MASK</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_MAC_SUBCATEGORY_MASK"><code class="xref">PSA_ALG_MAC_SUBCATEGORY_MASK</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_MAC_TRUNCATION_MASK"><code class="xref">PSA_ALG_MAC_TRUNCATION_MASK</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_MD2"><code class="xref">PSA_ALG_MD2</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_MD4"><code class="xref">PSA_ALG_MD4</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_MD5"><code class="xref">PSA_ALG_MD5</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_OFB"><code class="xref">PSA_ALG_OFB</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_RIPEMD160"><code class="xref">PSA_ALG_RIPEMD160</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_RSA_OAEP"><code class="xref">PSA_ALG_RSA_OAEP</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_RSA_OAEP_BASE"><code class="xref">PSA_ALG_RSA_OAEP_BASE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_RSA_OAEP_GET_HASH"><code class="xref">PSA_ALG_RSA_OAEP_GET_HASH</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_RSA_PKCS1V15_CRYPT"><code class="xref">PSA_ALG_RSA_PKCS1V15_CRYPT</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_RSA_PKCS1V15_SIGN"><code class="xref">PSA_ALG_RSA_PKCS1V15_SIGN</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_RSA_PKCS1V15_SIGN_BASE"><code class="xref">PSA_ALG_RSA_PKCS1V15_SIGN_BASE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_RSA_PKCS1V15_SIGN_RAW"><code class="xref">PSA_ALG_RSA_PKCS1V15_SIGN_RAW</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_RSA_PSS"><code class="xref">PSA_ALG_RSA_PSS</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_RSA_PSS_BASE"><code class="xref">PSA_ALG_RSA_PSS_BASE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_SHA3_224"><code class="xref">PSA_ALG_SHA3_224</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_SHA3_256"><code class="xref">PSA_ALG_SHA3_256</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_SHA3_384"><code class="xref">PSA_ALG_SHA3_384</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_SHA3_512"><code class="xref">PSA_ALG_SHA3_512</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_SHA_1"><code class="xref">PSA_ALG_SHA_1</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_SHA_224"><code class="xref">PSA_ALG_SHA_224</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_SHA_256"><code class="xref">PSA_ALG_SHA_256</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_SHA_384"><code class="xref">PSA_ALG_SHA_384</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_SHA_512"><code class="xref">PSA_ALG_SHA_512</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_SHA_512_224"><code class="xref">PSA_ALG_SHA_512_224</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_SHA_512_256"><code class="xref">PSA_ALG_SHA_512_256</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_SIGN_GET_HASH"><code class="xref">PSA_ALG_SIGN_GET_HASH</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_TLS12_PRF"><code class="xref">PSA_ALG_TLS12_PRF</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_TLS12_PRF_BASE"><code class="xref">PSA_ALG_TLS12_PRF_BASE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_TLS12_PRF_GET_HASH"><code class="xref">PSA_ALG_TLS12_PRF_GET_HASH</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_TLS12_PSK_TO_MS"><code class="xref">PSA_ALG_TLS12_PSK_TO_MS</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_TLS12_PSK_TO_MS_BASE"><code class="xref">PSA_ALG_TLS12_PSK_TO_MS_BASE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_TLS12_PSK_TO_MS_GET_HASH"><code class="xref">PSA_ALG_TLS12_PSK_TO_MS_GET_HASH</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_TLS12_PSK_TO_MS_MAX_PSK_LEN"><code class="xref">PSA_ALG_TLS12_PSK_TO_MS_MAX_PSK_LEN</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_TRUNCATED_MAC"><code class="xref">PSA_ALG_TRUNCATED_MAC</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_VENDOR_FLAG"><code class="xref">PSA_ALG_VENDOR_FLAG</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ALG_XTS"><code class="xref">PSA_ALG_XTS</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE"><code class="xref">PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE"><code class="xref">PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ASYMMETRIC_SIGNATURE_MAX_SIZE"><code class="xref">PSA_ASYMMETRIC_SIGNATURE_MAX_SIZE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE"><code class="xref">PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_aead_abort"><code class="xref">psa_aead_abort</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_aead_decrypt"><code class="xref">psa_aead_decrypt</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_aead_decrypt_setup"><code class="xref">psa_aead_decrypt_setup</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_aead_encrypt"><code class="xref">psa_aead_encrypt</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_aead_encrypt_setup"><code class="xref">psa_aead_encrypt_setup</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_aead_finish"><code class="xref">psa_aead_finish</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_aead_generate_nonce"><code class="xref">psa_aead_generate_nonce</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_aead_operation_init"><code class="xref">psa_aead_operation_init</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_aead_operation_t"><code class="xref">psa_aead_operation_t</code></a> <em>(type)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_aead_set_lengths"><code class="xref">psa_aead_set_lengths</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_aead_set_nonce"><code class="xref">psa_aead_set_nonce</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_aead_update"><code class="xref">psa_aead_update</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_aead_update_ad"><code class="xref">psa_aead_update_ad</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_aead_verify"><code class="xref">psa_aead_verify</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_algorithm_t"><code class="xref">psa_algorithm_t</code></a> <em>(type)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_asymmetric_decrypt"><code class="xref">psa_asymmetric_decrypt</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_asymmetric_encrypt"><code class="xref">psa_asymmetric_encrypt</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_asymmetric_sign"><code class="xref">psa_asymmetric_sign</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_asymmetric_verify"><code class="xref">psa_asymmetric_verify</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr class="pcap"><td></td><td> </td><td></td></tr>
+ <tr class="cap" id="cap-PSA_B"><td></td><td>
+ <strong>PSA_B</strong></td><td></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_BITS_TO_BYTES"><code class="xref">PSA_BITS_TO_BYTES</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_BLOCK_CIPHER_BLOCK_SIZE"><code class="xref">PSA_BLOCK_CIPHER_BLOCK_SIZE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_BYTES_TO_BITS"><code class="xref">PSA_BYTES_TO_BITS</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr class="pcap"><td></td><td> </td><td></td></tr>
+ <tr class="cap" id="cap-PSA_C"><td></td><td>
+ <strong>PSA_C</strong></td><td></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_CIPHER_OPERATION_INIT"><code class="xref">PSA_CIPHER_OPERATION_INIT</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_cipher_abort"><code class="xref">psa_cipher_abort</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_cipher_decrypt"><code class="xref">psa_cipher_decrypt</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_cipher_decrypt_setup"><code class="xref">psa_cipher_decrypt_setup</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_cipher_encrypt"><code class="xref">psa_cipher_encrypt</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_cipher_encrypt_setup"><code class="xref">psa_cipher_encrypt_setup</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_cipher_finish"><code class="xref">psa_cipher_finish</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_cipher_generate_iv"><code class="xref">psa_cipher_generate_iv</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_cipher_operation_init"><code class="xref">psa_cipher_operation_init</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_cipher_operation_t"><code class="xref">psa_cipher_operation_t</code></a> <em>(type)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_cipher_set_iv"><code class="xref">psa_cipher_set_iv</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_cipher_update"><code class="xref">psa_cipher_update</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_close_key"><code class="xref">psa_close_key</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_copy_key"><code class="xref">psa_copy_key</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_crypto_init"><code class="xref">psa_crypto_init</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr class="pcap"><td></td><td> </td><td></td></tr>
+ <tr class="cap" id="cap-PSA_D"><td></td><td>
+ <strong>PSA_D</strong></td><td></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_DH_GROUP_FFDHE2048"><code class="xref">PSA_DH_GROUP_FFDHE2048</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_DH_GROUP_FFDHE3072"><code class="xref">PSA_DH_GROUP_FFDHE3072</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_DH_GROUP_FFDHE4096"><code class="xref">PSA_DH_GROUP_FFDHE4096</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_DH_GROUP_FFDHE6144"><code class="xref">PSA_DH_GROUP_FFDHE6144</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_DH_GROUP_FFDHE8192"><code class="xref">PSA_DH_GROUP_FFDHE8192</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_destroy_key"><code class="xref">psa_destroy_key</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_dh_group_t"><code class="xref">psa_dh_group_t</code></a> <em>(type)</em></td><td>
+ <em></em></td></tr>
+ <tr class="pcap"><td></td><td> </td><td></td></tr>
+ <tr class="cap" id="cap-PSA_E"><td></td><td>
+ <strong>PSA_E</strong></td><td></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_BITS"><code class="xref">PSA_ECC_CURVE_BITS</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_BRAINPOOL_P256R1"><code class="xref">PSA_ECC_CURVE_BRAINPOOL_P256R1</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_BRAINPOOL_P384R1"><code class="xref">PSA_ECC_CURVE_BRAINPOOL_P384R1</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_BRAINPOOL_P512R1"><code class="xref">PSA_ECC_CURVE_BRAINPOOL_P512R1</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_CURVE25519"><code class="xref">PSA_ECC_CURVE_CURVE25519</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_CURVE448"><code class="xref">PSA_ECC_CURVE_CURVE448</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_SECP160K1"><code class="xref">PSA_ECC_CURVE_SECP160K1</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_SECP160R1"><code class="xref">PSA_ECC_CURVE_SECP160R1</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_SECP160R2"><code class="xref">PSA_ECC_CURVE_SECP160R2</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_SECP192K1"><code class="xref">PSA_ECC_CURVE_SECP192K1</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_SECP192R1"><code class="xref">PSA_ECC_CURVE_SECP192R1</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_SECP224K1"><code class="xref">PSA_ECC_CURVE_SECP224K1</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_SECP224R1"><code class="xref">PSA_ECC_CURVE_SECP224R1</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_SECP256K1"><code class="xref">PSA_ECC_CURVE_SECP256K1</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_SECP256R1"><code class="xref">PSA_ECC_CURVE_SECP256R1</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_SECP384R1"><code class="xref">PSA_ECC_CURVE_SECP384R1</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_SECP521R1"><code class="xref">PSA_ECC_CURVE_SECP521R1</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_SECT163K1"><code class="xref">PSA_ECC_CURVE_SECT163K1</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_SECT163R1"><code class="xref">PSA_ECC_CURVE_SECT163R1</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_SECT163R2"><code class="xref">PSA_ECC_CURVE_SECT163R2</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_SECT193R1"><code class="xref">PSA_ECC_CURVE_SECT193R1</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_SECT193R2"><code class="xref">PSA_ECC_CURVE_SECT193R2</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_SECT233K1"><code class="xref">PSA_ECC_CURVE_SECT233K1</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_SECT233R1"><code class="xref">PSA_ECC_CURVE_SECT233R1</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_SECT239K1"><code class="xref">PSA_ECC_CURVE_SECT239K1</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_SECT283K1"><code class="xref">PSA_ECC_CURVE_SECT283K1</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_SECT283R1"><code class="xref">PSA_ECC_CURVE_SECT283R1</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_SECT409K1"><code class="xref">PSA_ECC_CURVE_SECT409K1</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_SECT409R1"><code class="xref">PSA_ECC_CURVE_SECT409R1</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_SECT571K1"><code class="xref">PSA_ECC_CURVE_SECT571K1</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECC_CURVE_SECT571R1"><code class="xref">PSA_ECC_CURVE_SECT571R1</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ECDSA_SIGNATURE_SIZE"><code class="xref">PSA_ECDSA_SIGNATURE_SIZE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ERROR_ALREADY_EXISTS"><code class="xref">PSA_ERROR_ALREADY_EXISTS</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ERROR_BAD_STATE"><code class="xref">PSA_ERROR_BAD_STATE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ERROR_BUFFER_TOO_SMALL"><code class="xref">PSA_ERROR_BUFFER_TOO_SMALL</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ERROR_COMMUNICATION_FAILURE"><code class="xref">PSA_ERROR_COMMUNICATION_FAILURE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ERROR_CORRUPTION_DETECTED"><code class="xref">PSA_ERROR_CORRUPTION_DETECTED</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ERROR_DOES_NOT_EXIST"><code class="xref">PSA_ERROR_DOES_NOT_EXIST</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ERROR_GENERIC_ERROR"><code class="xref">PSA_ERROR_GENERIC_ERROR</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ERROR_HARDWARE_FAILURE"><code class="xref">PSA_ERROR_HARDWARE_FAILURE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ERROR_INSUFFICIENT_DATA"><code class="xref">PSA_ERROR_INSUFFICIENT_DATA</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ERROR_INSUFFICIENT_ENTROPY"><code class="xref">PSA_ERROR_INSUFFICIENT_ENTROPY</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ERROR_INSUFFICIENT_MEMORY"><code class="xref">PSA_ERROR_INSUFFICIENT_MEMORY</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ERROR_INSUFFICIENT_STORAGE"><code class="xref">PSA_ERROR_INSUFFICIENT_STORAGE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ERROR_INVALID_ARGUMENT"><code class="xref">PSA_ERROR_INVALID_ARGUMENT</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ERROR_INVALID_HANDLE"><code class="xref">PSA_ERROR_INVALID_HANDLE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ERROR_INVALID_PADDING"><code class="xref">PSA_ERROR_INVALID_PADDING</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ERROR_INVALID_SIGNATURE"><code class="xref">PSA_ERROR_INVALID_SIGNATURE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ERROR_NOT_PERMITTED"><code class="xref">PSA_ERROR_NOT_PERMITTED</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ERROR_NOT_SUPPORTED"><code class="xref">PSA_ERROR_NOT_SUPPORTED</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ERROR_STORAGE_FAILURE"><code class="xref">PSA_ERROR_STORAGE_FAILURE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_ecc_curve_t"><code class="xref">psa_ecc_curve_t</code></a> <em>(type)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_export_key"><code class="xref">psa_export_key</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_export_public_key"><code class="xref">psa_export_public_key</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr class="pcap"><td></td><td> </td><td></td></tr>
+ <tr class="cap" id="cap-PSA_G"><td></td><td>
+ <strong>PSA_G</strong></td><td></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_generate_key"><code class="xref">psa_generate_key</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_generate_random"><code class="xref">psa_generate_random</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_get_key_algorithm"><code class="xref">psa_get_key_algorithm</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_get_key_attributes"><code class="xref">psa_get_key_attributes</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_get_key_bits"><code class="xref">psa_get_key_bits</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_get_key_id"><code class="xref">psa_get_key_id</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_get_key_lifetime"><code class="xref">psa_get_key_lifetime</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_get_key_type"><code class="xref">psa_get_key_type</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_get_key_usage_flags"><code class="xref">psa_get_key_usage_flags</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr class="pcap"><td></td><td> </td><td></td></tr>
+ <tr class="cap" id="cap-PSA_H"><td></td><td>
+ <strong>PSA_H</strong></td><td></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_HASH_MAX_SIZE"><code class="xref">PSA_HASH_MAX_SIZE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_HASH_OPERATION_INIT"><code class="xref">PSA_HASH_OPERATION_INIT</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_HASH_SIZE"><code class="xref">PSA_HASH_SIZE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_HMAC_MAX_HASH_BLOCK_SIZE"><code class="xref">PSA_HMAC_MAX_HASH_BLOCK_SIZE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_hash_abort"><code class="xref">psa_hash_abort</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_hash_clone"><code class="xref">psa_hash_clone</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_hash_compare"><code class="xref">psa_hash_compare</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_hash_compute"><code class="xref">psa_hash_compute</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_hash_finish"><code class="xref">psa_hash_finish</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_hash_operation_init"><code class="xref">psa_hash_operation_init</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_hash_operation_t"><code class="xref">psa_hash_operation_t</code></a> <em>(type)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_hash_setup"><code class="xref">psa_hash_setup</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_hash_update"><code class="xref">psa_hash_update</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_hash_verify"><code class="xref">psa_hash_verify</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr class="pcap"><td></td><td> </td><td></td></tr>
+ <tr class="cap" id="cap-PSA_I"><td></td><td>
+ <strong>PSA_I</strong></td><td></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_import_key"><code class="xref">psa_import_key</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr class="pcap"><td></td><td> </td><td></td></tr>
+ <tr class="cap" id="cap-PSA_K"><td></td><td>
+ <strong>PSA_K</strong></td><td></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_ATTRIBUTES_INIT"><code class="xref">PSA_KEY_ATTRIBUTES_INIT</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_DERIVATION_INPUT_INFO"><code class="xref">PSA_KEY_DERIVATION_INPUT_INFO</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_DERIVATION_INPUT_LABEL"><code class="xref">PSA_KEY_DERIVATION_INPUT_LABEL</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_DERIVATION_INPUT_SALT"><code class="xref">PSA_KEY_DERIVATION_INPUT_SALT</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_DERIVATION_INPUT_SECRET"><code class="xref">PSA_KEY_DERIVATION_INPUT_SECRET</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_DERIVATION_INPUT_SEED"><code class="xref">PSA_KEY_DERIVATION_INPUT_SEED</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_DERIVATION_OPERATION_INIT"><code class="xref">PSA_KEY_DERIVATION_OPERATION_INIT</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_DERIVATION_UNLIMITED_CAPACITY"><code class="xref">PSA_KEY_DERIVATION_UNLIMITED_CAPACITY</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE"><code class="xref">PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_EXPORT_DSA_KEY_PAIR_MAX_SIZE"><code class="xref">PSA_KEY_EXPORT_DSA_KEY_PAIR_MAX_SIZE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_EXPORT_DSA_PUBLIC_KEY_MAX_SIZE"><code class="xref">PSA_KEY_EXPORT_DSA_PUBLIC_KEY_MAX_SIZE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_EXPORT_ECC_KEY_PAIR_MAX_SIZE"><code class="xref">PSA_KEY_EXPORT_ECC_KEY_PAIR_MAX_SIZE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE"><code class="xref">PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_EXPORT_MAX_SIZE"><code class="xref">PSA_KEY_EXPORT_MAX_SIZE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_EXPORT_RSA_KEY_PAIR_MAX_SIZE"><code class="xref">PSA_KEY_EXPORT_RSA_KEY_PAIR_MAX_SIZE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_EXPORT_RSA_PUBLIC_KEY_MAX_SIZE"><code class="xref">PSA_KEY_EXPORT_RSA_PUBLIC_KEY_MAX_SIZE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_ID_USER_MAX"><code class="xref">PSA_KEY_ID_USER_MAX</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_ID_USER_MIN"><code class="xref">PSA_KEY_ID_USER_MIN</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_ID_VENDOR_MAX"><code class="xref">PSA_KEY_ID_VENDOR_MAX</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_ID_VENDOR_MIN"><code class="xref">PSA_KEY_ID_VENDOR_MIN</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_LIFETIME_PERSISTENT"><code class="xref">PSA_KEY_LIFETIME_PERSISTENT</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_LIFETIME_VOLATILE"><code class="xref">PSA_KEY_LIFETIME_VOLATILE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_AES"><code class="xref">PSA_KEY_TYPE_AES</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_ARC4"><code class="xref">PSA_KEY_TYPE_ARC4</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_CAMELLIA"><code class="xref">PSA_KEY_TYPE_CAMELLIA</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_CATEGORY_FLAG_PAIR"><code class="xref">PSA_KEY_TYPE_CATEGORY_FLAG_PAIR</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_CATEGORY_KEY_PAIR"><code class="xref">PSA_KEY_TYPE_CATEGORY_KEY_PAIR</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_CATEGORY_MASK"><code class="xref">PSA_KEY_TYPE_CATEGORY_MASK</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY"><code class="xref">PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_CATEGORY_RAW"><code class="xref">PSA_KEY_TYPE_CATEGORY_RAW</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_CATEGORY_SYMMETRIC"><code class="xref">PSA_KEY_TYPE_CATEGORY_SYMMETRIC</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_CHACHA20"><code class="xref">PSA_KEY_TYPE_CHACHA20</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_DERIVE"><code class="xref">PSA_KEY_TYPE_DERIVE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_DES"><code class="xref">PSA_KEY_TYPE_DES</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_DH_GROUP_MASK"><code class="xref">PSA_KEY_TYPE_DH_GROUP_MASK</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_DH_KEY_PAIR"><code class="xref">PSA_KEY_TYPE_DH_KEY_PAIR</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_DH_KEY_PAIR_BASE"><code class="xref">PSA_KEY_TYPE_DH_KEY_PAIR_BASE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_DH_PUBLIC_KEY"><code class="xref">PSA_KEY_TYPE_DH_PUBLIC_KEY</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_DH_PUBLIC_KEY_BASE"><code class="xref">PSA_KEY_TYPE_DH_PUBLIC_KEY_BASE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_ECC_CURVE_MASK"><code class="xref">PSA_KEY_TYPE_ECC_CURVE_MASK</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_ECC_KEY_PAIR"><code class="xref">PSA_KEY_TYPE_ECC_KEY_PAIR</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_ECC_KEY_PAIR_BASE"><code class="xref">PSA_KEY_TYPE_ECC_KEY_PAIR_BASE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_ECC_PUBLIC_KEY"><code class="xref">PSA_KEY_TYPE_ECC_PUBLIC_KEY</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE"><code class="xref">PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_GET_CURVE"><code class="xref">PSA_KEY_TYPE_GET_CURVE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_GET_GROUP"><code class="xref">PSA_KEY_TYPE_GET_GROUP</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_HMAC"><code class="xref">PSA_KEY_TYPE_HMAC</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_IS_ASYMMETRIC"><code class="xref">PSA_KEY_TYPE_IS_ASYMMETRIC</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_IS_DH"><code class="xref">PSA_KEY_TYPE_IS_DH</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_IS_DH_KEY_PAIR"><code class="xref">PSA_KEY_TYPE_IS_DH_KEY_PAIR</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_IS_DH_PUBLIC_KEY"><code class="xref">PSA_KEY_TYPE_IS_DH_PUBLIC_KEY</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_IS_ECC"><code class="xref">PSA_KEY_TYPE_IS_ECC</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_IS_ECC_KEY_PAIR"><code class="xref">PSA_KEY_TYPE_IS_ECC_KEY_PAIR</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY"><code class="xref">PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_IS_KEY_PAIR"><code class="xref">PSA_KEY_TYPE_IS_KEY_PAIR</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_IS_PUBLIC_KEY"><code class="xref">PSA_KEY_TYPE_IS_PUBLIC_KEY</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_IS_RSA"><code class="xref">PSA_KEY_TYPE_IS_RSA</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_IS_UNSTRUCTURED"><code class="xref">PSA_KEY_TYPE_IS_UNSTRUCTURED</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_IS_VENDOR_DEFINED"><code class="xref">PSA_KEY_TYPE_IS_VENDOR_DEFINED</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_KEY_PAIR_OF_PUBLIC_KEY"><code class="xref">PSA_KEY_TYPE_KEY_PAIR_OF_PUBLIC_KEY</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_NONE"><code class="xref">PSA_KEY_TYPE_NONE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR"><code class="xref">PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_RAW_DATA"><code class="xref">PSA_KEY_TYPE_RAW_DATA</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_RSA_KEY_PAIR"><code class="xref">PSA_KEY_TYPE_RSA_KEY_PAIR</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_RSA_PUBLIC_KEY"><code class="xref">PSA_KEY_TYPE_RSA_PUBLIC_KEY</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_TYPE_VENDOR_FLAG"><code class="xref">PSA_KEY_TYPE_VENDOR_FLAG</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_USAGE_COPY"><code class="xref">PSA_KEY_USAGE_COPY</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_USAGE_DECRYPT"><code class="xref">PSA_KEY_USAGE_DECRYPT</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_USAGE_DERIVE"><code class="xref">PSA_KEY_USAGE_DERIVE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_USAGE_ENCRYPT"><code class="xref">PSA_KEY_USAGE_ENCRYPT</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_USAGE_EXPORT"><code class="xref">PSA_KEY_USAGE_EXPORT</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_USAGE_SIGN"><code class="xref">PSA_KEY_USAGE_SIGN</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_KEY_USAGE_VERIFY"><code class="xref">PSA_KEY_USAGE_VERIFY</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_key_attributes_init"><code class="xref">psa_key_attributes_init</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_key_attributes_t"><code class="xref">psa_key_attributes_t</code></a> <em>(type)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_key_derivation_abort"><code class="xref">psa_key_derivation_abort</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_key_derivation_get_capacity"><code class="xref">psa_key_derivation_get_capacity</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_key_derivation_input_bytes"><code class="xref">psa_key_derivation_input_bytes</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_key_derivation_input_key"><code class="xref">psa_key_derivation_input_key</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_key_derivation_key_agreement"><code class="xref">psa_key_derivation_key_agreement</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_key_derivation_operation_init"><code class="xref">psa_key_derivation_operation_init</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_key_derivation_operation_t"><code class="xref">psa_key_derivation_operation_t</code></a> <em>(type)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_key_derivation_output_bytes"><code class="xref">psa_key_derivation_output_bytes</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_key_derivation_output_key"><code class="xref">psa_key_derivation_output_key</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_key_derivation_set_capacity"><code class="xref">psa_key_derivation_set_capacity</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_key_derivation_setup"><code class="xref">psa_key_derivation_setup</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_key_derivation_step_t"><code class="xref">psa_key_derivation_step_t</code></a> <em>(type)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_key_handle_t"><code class="xref">psa_key_handle_t</code></a> <em>(type)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_key_id_t"><code class="xref">psa_key_id_t</code></a> <em>(type)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_key_lifetime_t"><code class="xref">psa_key_lifetime_t</code></a> <em>(type)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_key_type_t"><code class="xref">psa_key_type_t</code></a> <em>(type)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_key_usage_t"><code class="xref">psa_key_usage_t</code></a> <em>(type)</em></td><td>
+ <em></em></td></tr>
+ <tr class="pcap"><td></td><td> </td><td></td></tr>
+ <tr class="cap" id="cap-PSA_M"><td></td><td>
+ <strong>PSA_M</strong></td><td></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_MAC_FINAL_SIZE"><code class="xref">PSA_MAC_FINAL_SIZE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_MAC_MAX_SIZE"><code class="xref">PSA_MAC_MAX_SIZE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_MAC_OPERATION_INIT"><code class="xref">PSA_MAC_OPERATION_INIT</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_MAC_TRUNCATED_LENGTH"><code class="xref">PSA_MAC_TRUNCATED_LENGTH</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_MAC_TRUNCATION_OFFSET"><code class="xref">PSA_MAC_TRUNCATION_OFFSET</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_MAX_BLOCK_CIPHER_BLOCK_SIZE"><code class="xref">PSA_MAX_BLOCK_CIPHER_BLOCK_SIZE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_mac_abort"><code class="xref">psa_mac_abort</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_mac_compute"><code class="xref">psa_mac_compute</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_mac_operation_init"><code class="xref">psa_mac_operation_init</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_mac_operation_t"><code class="xref">psa_mac_operation_t</code></a> <em>(type)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_mac_sign_finish"><code class="xref">psa_mac_sign_finish</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_mac_sign_setup"><code class="xref">psa_mac_sign_setup</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_mac_update"><code class="xref">psa_mac_update</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_mac_verify"><code class="xref">psa_mac_verify</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_mac_verify_finish"><code class="xref">psa_mac_verify_finish</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_mac_verify_setup"><code class="xref">psa_mac_verify_setup</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr class="pcap"><td></td><td> </td><td></td></tr>
+ <tr class="cap" id="cap-PSA_O"><td></td><td>
+ <strong>PSA_O</strong></td><td></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_open_key"><code class="xref">psa_open_key</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr class="pcap"><td></td><td> </td><td></td></tr>
+ <tr class="cap" id="cap-PSA_R"><td></td><td>
+ <strong>PSA_R</strong></td><td></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_ROUND_UP_TO_MULTIPLE"><code class="xref">PSA_ROUND_UP_TO_MULTIPLE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_RSA_MINIMUM_PADDING_SIZE"><code class="xref">PSA_RSA_MINIMUM_PADDING_SIZE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_raw_key_agreement"><code class="xref">psa_raw_key_agreement</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_reset_key_attributes"><code class="xref">psa_reset_key_attributes</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr class="pcap"><td></td><td> </td><td></td></tr>
+ <tr class="cap" id="cap-PSA_S"><td></td><td>
+ <strong>PSA_S</strong></td><td></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_SUCCESS"><code class="xref">PSA_SUCCESS</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_set_key_algorithm"><code class="xref">psa_set_key_algorithm</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_set_key_bits"><code class="xref">psa_set_key_bits</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_set_key_id"><code class="xref">psa_set_key_id</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_set_key_lifetime"><code class="xref">psa_set_key_lifetime</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_set_key_type"><code class="xref">psa_set_key_type</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_set_key_usage_flags"><code class="xref">psa_set_key_usage_flags</code></a> <em>(function)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#psa_status_t"><code class="xref">psa_status_t</code></a> <em>(type)</em></td><td>
+ <em></em></td></tr>
+ <tr class="pcap"><td></td><td> </td><td></td></tr>
+ <tr class="cap" id="cap-PSA_V"><td></td><td>
+ <strong>PSA_V</strong></td><td></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_VENDOR_ECC_MAX_CURVE_BITS"><code class="xref">PSA_VENDOR_ECC_MAX_CURVE_BITS</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA_VENDOR_RSA_MAX_KEY_BITS"><code class="xref">PSA_VENDOR_RSA_MAX_KEY_BITS</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ <tr class="pcap"><td></td><td> </td><td></td></tr>
+ <tr class="cap" id="cap-PSA__"><td></td><td>
+ <strong>PSA__</strong></td><td></td></tr>
+ <tr>
+ <td></td>
+ <td>
+ <a href="from_doxygen.html#PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE"><code class="xref">PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE</code></a> <em>(macro)</em></td><td>
+ <em></em></td></tr>
+ </table>
+
+
+ </div>
+
+ </div>
+ </div>
+ <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
+ <div class="sphinxsidebarwrapper">
+<h1 class="logo"><a href="index.html">psa_crypto_api</a></h1>
+
+
+
+
+
+
+
+
+<h3>Navigation</h3>
+<ul>
+<li class="toctree-l1"><a class="reference internal" href="general.html">Introduction</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#design-goals">Design goals</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#functionality-overview">Functionality overview</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#sample-architectures">Sample architectures</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#library-conventions">Library conventions</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#implementation-considerations">Implementation considerations</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#usage-considerations">Usage considerations</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html">Implementation-specific definitions</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#library-initialization">Library initialization</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-attributes">Key attributes</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-management">Key management</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-import-and-export">Key import and export</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#message-digests">Message digests</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#message-authentication-codes">Message authentication codes</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#symmetric-ciphers">Symmetric ciphers</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#authenticated-encryption-with-associated-data-aead">Authenticated encryption with associated data (AEAD)</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#asymmetric-cryptography">Asymmetric cryptography</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-derivation-and-pseudorandom-generation">Key derivation and pseudorandom generation</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#random-generation">Random generation</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#error-codes">Error codes</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-and-algorithm-types">Key and algorithm types</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-lifetimes">Key lifetimes</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-policies">Key policies</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-derivation">Key derivation</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#other-definitions">Other definitions</a></li>
+</ul>
+
+<div class="relations">
+<h3>Related Topics</h3>
+<ul>
+ <li><a href="index.html">Documentation overview</a><ul>
+ </ul></li>
+</ul>
+</div>
+<div id="searchbox" style="display: none" role="search">
+ <h3>Quick search</h3>
+ <div class="searchformwrapper">
+ <form class="search" action="search.html" method="get">
+ <input type="text" name="q" />
+ <input type="submit" value="Go" />
+ <input type="hidden" name="check_keywords" value="yes" />
+ <input type="hidden" name="area" value="default" />
+ </form>
+ </div>
+</div>
+<script type="text/javascript">$('#searchbox').show(0);</script>
+
+
+
+
+
+
+
+
+ </div>
+ </div>
+ <div class="clearer"></div>
+ </div>
+ <div class="footer">
+ ©2019, Arm.
+
+ |
+ Powered by <a href="http://sphinx-doc.org/">Sphinx 1.8.5</a>
+ & <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
+
+ </div>
+
+
+
+
+ </body>
+</html>
\ No newline at end of file
diff --git a/docs/html/search.html b/docs/html/search.html
new file mode 100644
index 0000000..266bde5
--- /dev/null
+++ b/docs/html/search.html
@@ -0,0 +1,144 @@
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+ <title>Search — psa_crypto_api 1.0 beta3 documentation</title>
+ <link rel="stylesheet" href="_static/alabaster.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+
+ <script type="text/javascript" id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
+ <script type="text/javascript" src="_static/jquery.js"></script>
+ <script type="text/javascript" src="_static/underscore.js"></script>
+ <script type="text/javascript" src="_static/doctools.js"></script>
+ <script type="text/javascript" src="_static/language_data.js"></script>
+ <script type="text/javascript" src="_static/searchtools.js"></script>
+ <link rel="index" title="Index" href="genindex.html" />
+ <link rel="search" title="Search" href="#" />
+ <script type="text/javascript">
+ jQuery(function() { Search.loadIndex("searchindex.js"); });
+ </script>
+
+ <script type="text/javascript" id="searchindexloader"></script>
+
+
+ <link rel="stylesheet" href="_static/custom.css" type="text/css" />
+
+
+ <meta name="viewport" content="width=device-width, initial-scale=0.9, maximum-scale=0.9" />
+
+
+ </head><body>
+
+
+ <div class="document">
+ <div class="documentwrapper">
+ <div class="bodywrapper">
+
+
+ <div class="body" role="main">
+
+ <h1 id="search-documentation">Search</h1>
+ <div id="fallback" class="admonition warning">
+ <script type="text/javascript">$('#fallback').hide();</script>
+ <p>
+ Please activate JavaScript to enable the search
+ functionality.
+ </p>
+ </div>
+ <p>
+ From here you can search these documents. Enter your search
+ words into the box below and click "search". Note that the search
+ function will automatically search for all of the words. Pages
+ containing fewer words won't appear in the result list.
+ </p>
+ <form action="" method="get">
+ <input type="text" name="q" value="" />
+ <input type="submit" value="search" />
+ <span id="search-progress" style="padding-left: 10px"></span>
+ </form>
+
+ <div id="search-results">
+
+ </div>
+
+ </div>
+
+ </div>
+ </div>
+ <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
+ <div class="sphinxsidebarwrapper">
+<h1 class="logo"><a href="index.html">psa_crypto_api</a></h1>
+
+
+
+
+
+
+
+
+<h3>Navigation</h3>
+<ul>
+<li class="toctree-l1"><a class="reference internal" href="general.html">Introduction</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#design-goals">Design goals</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#functionality-overview">Functionality overview</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#sample-architectures">Sample architectures</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#library-conventions">Library conventions</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#implementation-considerations">Implementation considerations</a></li>
+<li class="toctree-l1"><a class="reference internal" href="general.html#usage-considerations">Usage considerations</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html">Implementation-specific definitions</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#library-initialization">Library initialization</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-attributes">Key attributes</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-management">Key management</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-import-and-export">Key import and export</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#message-digests">Message digests</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#message-authentication-codes">Message authentication codes</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#symmetric-ciphers">Symmetric ciphers</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#authenticated-encryption-with-associated-data-aead">Authenticated encryption with associated data (AEAD)</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#asymmetric-cryptography">Asymmetric cryptography</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-derivation-and-pseudorandom-generation">Key derivation and pseudorandom generation</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#random-generation">Random generation</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#error-codes">Error codes</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-and-algorithm-types">Key and algorithm types</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-lifetimes">Key lifetimes</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-policies">Key policies</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#key-derivation">Key derivation</a></li>
+<li class="toctree-l1"><a class="reference internal" href="from_doxygen.html#other-definitions">Other definitions</a></li>
+</ul>
+
+<div class="relations">
+<h3>Related Topics</h3>
+<ul>
+ <li><a href="index.html">Documentation overview</a><ul>
+ </ul></li>
+</ul>
+</div>
+
+
+
+
+
+
+
+
+ </div>
+ </div>
+ <div class="clearer"></div>
+ </div>
+ <div class="footer">
+ ©2019, Arm.
+
+ |
+ Powered by <a href="http://sphinx-doc.org/">Sphinx 1.8.5</a>
+ & <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
+
+ </div>
+
+
+
+
+ </body>
+</html>
\ No newline at end of file
diff --git a/docs/html/search/all_0.html b/docs/html/search/all_0.html
deleted file mode 100644
index d54e0bd..0000000
--- a/docs/html/search/all_0.html
+++ /dev/null
@@ -1,26 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html><head><title></title>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<link rel="stylesheet" type="text/css" href="search.css"/>
-<script type="text/javascript" src="all_0.js"></script>
-<script type="text/javascript" src="search.js"></script>
-</head>
-<body class="SRPage">
-<div id="SRIndex">
-<div class="SRStatus" id="Loading">Loading...</div>
-<div id="SRResults"></div>
-<script type="text/javascript"><!--
-createResults();
---></script>
-<div class="SRStatus" id="Searching">Searching...</div>
-<div class="SRStatus" id="NoMatches">No Matches</div>
-<script type="text/javascript"><!--
-document.getElementById("Loading").style.display="none";
-document.getElementById("NoMatches").style.display="none";
-var searchResults = new SearchResults("searchResults");
-searchResults.Search();
---></script>
-</div>
-</body>
-</html>
diff --git a/docs/html/search/all_0.js b/docs/html/search/all_0.js
deleted file mode 100644
index 9e9cdcb..0000000
--- a/docs/html/search/all_0.js
+++ /dev/null
@@ -1,5 +0,0 @@
-var searchData=
-[
- ['authenticated_20encryption_20with_20associated_20data_20_28aead_29',['Authenticated encryption with associated data (AEAD)',['../group__aead.html',1,'']]],
- ['asymmetric_20cryptography',['Asymmetric cryptography',['../group__asymmetric.html',1,'']]]
-];
diff --git a/docs/html/search/all_1.html b/docs/html/search/all_1.html
deleted file mode 100644
index 8cc6a1d..0000000
--- a/docs/html/search/all_1.html
+++ /dev/null
@@ -1,26 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html><head><title></title>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<link rel="stylesheet" type="text/css" href="search.css"/>
-<script type="text/javascript" src="all_1.js"></script>
-<script type="text/javascript" src="search.js"></script>
-</head>
-<body class="SRPage">
-<div id="SRIndex">
-<div class="SRStatus" id="Loading">Loading...</div>
-<div id="SRResults"></div>
-<script type="text/javascript"><!--
-createResults();
---></script>
-<div class="SRStatus" id="Searching">Searching...</div>
-<div class="SRStatus" id="NoMatches">No Matches</div>
-<script type="text/javascript"><!--
-document.getElementById("Loading").style.display="none";
-document.getElementById("NoMatches").style.display="none";
-var searchResults = new SearchResults("searchResults");
-searchResults.Search();
---></script>
-</div>
-</body>
-</html>
diff --git a/docs/html/search/all_1.js b/docs/html/search/all_1.js
deleted file mode 100644
index 1f9a5bb..0000000
--- a/docs/html/search/all_1.js
+++ /dev/null
@@ -1,7 +0,0 @@
-var searchData=
-[
- ['crypto_2eh',['crypto.h',['../crypto_8h.html',1,'']]],
- ['crypto_5fsizes_2eh',['crypto_sizes.h',['../crypto__sizes_8h.html',1,'']]],
- ['crypto_5ftypes_2eh',['crypto_types.h',['../crypto__types_8h.html',1,'']]],
- ['crypto_5fvalues_2eh',['crypto_values.h',['../crypto__values_8h.html',1,'']]]
-];
diff --git a/docs/html/search/all_2.html b/docs/html/search/all_2.html
deleted file mode 100644
index d15ac65..0000000
--- a/docs/html/search/all_2.html
+++ /dev/null
@@ -1,26 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html><head><title></title>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<link rel="stylesheet" type="text/css" href="search.css"/>
-<script type="text/javascript" src="all_2.js"></script>
-<script type="text/javascript" src="search.js"></script>
-</head>
-<body class="SRPage">
-<div id="SRIndex">
-<div class="SRStatus" id="Loading">Loading...</div>
-<div id="SRResults"></div>
-<script type="text/javascript"><!--
-createResults();
---></script>
-<div class="SRStatus" id="Searching">Searching...</div>
-<div class="SRStatus" id="NoMatches">No Matches</div>
-<script type="text/javascript"><!--
-document.getElementById("Loading").style.display="none";
-document.getElementById("NoMatches").style.display="none";
-var searchResults = new SearchResults("searchResults");
-searchResults.Search();
---></script>
-</div>
-</body>
-</html>
diff --git a/docs/html/search/all_2.js b/docs/html/search/all_2.js
deleted file mode 100644
index da175df..0000000
--- a/docs/html/search/all_2.js
+++ /dev/null
@@ -1,5 +0,0 @@
-var searchData=
-[
- ['e',['e',['../structpsa__generate__key__extra__rsa.html#a53ccb9e4375f3c9af6e3ecfe111ce11d',1,'psa_generate_key_extra_rsa']]],
- ['error_20codes',['Error codes',['../group__error.html',1,'']]]
-];
diff --git a/docs/html/search/all_3.html b/docs/html/search/all_3.html
deleted file mode 100644
index 9f526c6..0000000
--- a/docs/html/search/all_3.html
+++ /dev/null
@@ -1,26 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html><head><title></title>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<link rel="stylesheet" type="text/css" href="search.css"/>
-<script type="text/javascript" src="all_3.js"></script>
-<script type="text/javascript" src="search.js"></script>
-</head>
-<body class="SRPage">
-<div id="SRIndex">
-<div class="SRStatus" id="Loading">Loading...</div>
-<div id="SRResults"></div>
-<script type="text/javascript"><!--
-createResults();
---></script>
-<div class="SRStatus" id="Searching">Searching...</div>
-<div class="SRStatus" id="NoMatches">No Matches</div>
-<script type="text/javascript"><!--
-document.getElementById("Loading").style.display="none";
-document.getElementById("NoMatches").style.display="none";
-var searchResults = new SearchResults("searchResults");
-searchResults.Search();
---></script>
-</div>
-</body>
-</html>
diff --git a/docs/html/search/all_3.js b/docs/html/search/all_3.js
deleted file mode 100644
index bb51584..0000000
--- a/docs/html/search/all_3.js
+++ /dev/null
@@ -1,4 +0,0 @@
-var searchData=
-[
- ['generators',['Generators',['../group__generators.html',1,'']]]
-];
diff --git a/docs/html/search/all_4.html b/docs/html/search/all_4.html
deleted file mode 100644
index 7b814aa..0000000
--- a/docs/html/search/all_4.html
+++ /dev/null
@@ -1,26 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html><head><title></title>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<link rel="stylesheet" type="text/css" href="search.css"/>
-<script type="text/javascript" src="all_4.js"></script>
-<script type="text/javascript" src="search.js"></script>
-</head>
-<body class="SRPage">
-<div id="SRIndex">
-<div class="SRStatus" id="Loading">Loading...</div>
-<div id="SRResults"></div>
-<script type="text/javascript"><!--
-createResults();
---></script>
-<div class="SRStatus" id="Searching">Searching...</div>
-<div class="SRStatus" id="NoMatches">No Matches</div>
-<script type="text/javascript"><!--
-document.getElementById("Loading").style.display="none";
-document.getElementById("NoMatches").style.display="none";
-var searchResults = new SearchResults("searchResults");
-searchResults.Search();
---></script>
-</div>
-</body>
-</html>
diff --git a/docs/html/search/all_4.js b/docs/html/search/all_4.js
deleted file mode 100644
index f48be25..0000000
--- a/docs/html/search/all_4.js
+++ /dev/null
@@ -1,4 +0,0 @@
-var searchData=
-[
- ['implementation_2dspecific_20definitions',['Implementation-specific definitions',['../group__platform.html',1,'']]]
-];
diff --git a/docs/html/search/all_5.html b/docs/html/search/all_5.html
deleted file mode 100644
index d8de556..0000000
--- a/docs/html/search/all_5.html
+++ /dev/null
@@ -1,26 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html><head><title></title>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<link rel="stylesheet" type="text/css" href="search.css"/>
-<script type="text/javascript" src="all_5.js"></script>
-<script type="text/javascript" src="search.js"></script>
-</head>
-<body class="SRPage">
-<div id="SRIndex">
-<div class="SRStatus" id="Loading">Loading...</div>
-<div id="SRResults"></div>
-<script type="text/javascript"><!--
-createResults();
---></script>
-<div class="SRStatus" id="Searching">Searching...</div>
-<div class="SRStatus" id="NoMatches">No Matches</div>
-<script type="text/javascript"><!--
-document.getElementById("Loading").style.display="none";
-document.getElementById("NoMatches").style.display="none";
-var searchResults = new SearchResults("searchResults");
-searchResults.Search();
---></script>
-</div>
-</body>
-</html>
diff --git a/docs/html/search/all_5.js b/docs/html/search/all_5.js
deleted file mode 100644
index 489c5ec..0000000
--- a/docs/html/search/all_5.js
+++ /dev/null
@@ -1,9 +0,0 @@
-var searchData=
-[
- ['key_20and_20algorithm_20types',['Key and algorithm types',['../group__crypto__types.html',1,'']]],
- ['key_20derivation',['Key derivation',['../group__derivation.html',1,'']]],
- ['key_20import_20and_20export',['Key import and export',['../group__import__export.html',1,'']]],
- ['key_20lifetimes',['Key lifetimes',['../group__key__lifetimes.html',1,'']]],
- ['key_20management',['Key management',['../group__key__management.html',1,'']]],
- ['key_20policies',['Key policies',['../group__policy.html',1,'']]]
-];
diff --git a/docs/html/search/all_6.html b/docs/html/search/all_6.html
deleted file mode 100644
index 9ba0cc2..0000000
--- a/docs/html/search/all_6.html
+++ /dev/null
@@ -1,26 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html><head><title></title>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<link rel="stylesheet" type="text/css" href="search.css"/>
-<script type="text/javascript" src="all_6.js"></script>
-<script type="text/javascript" src="search.js"></script>
-</head>
-<body class="SRPage">
-<div id="SRIndex">
-<div class="SRStatus" id="Loading">Loading...</div>
-<div id="SRResults"></div>
-<script type="text/javascript"><!--
-createResults();
---></script>
-<div class="SRStatus" id="Searching">Searching...</div>
-<div class="SRStatus" id="NoMatches">No Matches</div>
-<script type="text/javascript"><!--
-document.getElementById("Loading").style.display="none";
-document.getElementById("NoMatches").style.display="none";
-var searchResults = new SearchResults("searchResults");
-searchResults.Search();
---></script>
-</div>
-</body>
-</html>
diff --git a/docs/html/search/all_6.js b/docs/html/search/all_6.js
deleted file mode 100644
index c72a68d..0000000
--- a/docs/html/search/all_6.js
+++ /dev/null
@@ -1,4 +0,0 @@
-var searchData=
-[
- ['library_20initialization',['Library initialization',['../group__initialization.html',1,'']]]
-];
diff --git a/docs/html/search/all_7.html b/docs/html/search/all_7.html
deleted file mode 100644
index 9384ec9..0000000
--- a/docs/html/search/all_7.html
+++ /dev/null
@@ -1,26 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html><head><title></title>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<link rel="stylesheet" type="text/css" href="search.css"/>
-<script type="text/javascript" src="all_7.js"></script>
-<script type="text/javascript" src="search.js"></script>
-</head>
-<body class="SRPage">
-<div id="SRIndex">
-<div class="SRStatus" id="Loading">Loading...</div>
-<div id="SRResults"></div>
-<script type="text/javascript"><!--
-createResults();
---></script>
-<div class="SRStatus" id="Searching">Searching...</div>
-<div class="SRStatus" id="NoMatches">No Matches</div>
-<script type="text/javascript"><!--
-document.getElementById("Loading").style.display="none";
-document.getElementById("NoMatches").style.display="none";
-var searchResults = new SearchResults("searchResults");
-searchResults.Search();
---></script>
-</div>
-</body>
-</html>
diff --git a/docs/html/search/all_7.js b/docs/html/search/all_7.js
deleted file mode 100644
index 6efdddb..0000000
--- a/docs/html/search/all_7.js
+++ /dev/null
@@ -1,5 +0,0 @@
-var searchData=
-[
- ['message_20digests',['Message digests',['../group__hash.html',1,'']]],
- ['message_20authentication_20codes',['Message authentication codes',['../group__MAC.html',1,'']]]
-];
diff --git a/docs/html/search/all_8.html b/docs/html/search/all_8.html
deleted file mode 100644
index 37566c5..0000000
--- a/docs/html/search/all_8.html
+++ /dev/null
@@ -1,26 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html><head><title></title>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<link rel="stylesheet" type="text/css" href="search.css"/>
-<script type="text/javascript" src="all_8.js"></script>
-<script type="text/javascript" src="search.js"></script>
-</head>
-<body class="SRPage">
-<div id="SRIndex">
-<div class="SRStatus" id="Loading">Loading...</div>
-<div id="SRResults"></div>
-<script type="text/javascript"><!--
-createResults();
---></script>
-<div class="SRStatus" id="Searching">Searching...</div>
-<div class="SRStatus" id="NoMatches">No Matches</div>
-<script type="text/javascript"><!--
-document.getElementById("Loading").style.display="none";
-document.getElementById("NoMatches").style.display="none";
-var searchResults = new SearchResults("searchResults");
-searchResults.Search();
---></script>
-</div>
-</body>
-</html>
diff --git a/docs/html/search/all_8.js b/docs/html/search/all_8.js
deleted file mode 100644
index c99c08b..0000000
--- a/docs/html/search/all_8.js
+++ /dev/null
@@ -1,238 +0,0 @@
-var searchData=
-[
- ['psa_5faead_5fabort',['psa_aead_abort',['../group__aead.html#gae8a5f93d92318c8f592ee9fbb9d36ba0',1,'crypto.h']]],
- ['psa_5faead_5fdecrypt',['psa_aead_decrypt',['../group__aead.html#gaa8ce6527f2e227f1071fadbf2099793b',1,'crypto.h']]],
- ['psa_5faead_5fdecrypt_5foutput_5fsize',['PSA_AEAD_DECRYPT_OUTPUT_SIZE',['../crypto__sizes_8h.html#a1d057796166c16eb673ad1997e48a60b',1,'crypto_sizes.h']]],
- ['psa_5faead_5fdecrypt_5fsetup',['psa_aead_decrypt_setup',['../group__aead.html#ga439896519d4a367ec86b47f201884152',1,'crypto.h']]],
- ['psa_5faead_5fencrypt',['psa_aead_encrypt',['../group__aead.html#ga44de092cf58bb6c820c5c80a6c51610d',1,'crypto.h']]],
- ['psa_5faead_5fencrypt_5foutput_5fsize',['PSA_AEAD_ENCRYPT_OUTPUT_SIZE',['../crypto__sizes_8h.html#a85667d47a7aa6c7b99a80e5273671266',1,'crypto_sizes.h']]],
- ['psa_5faead_5fencrypt_5fsetup',['psa_aead_encrypt_setup',['../group__aead.html#ga47265dc4852f1476f852752218fd12b2',1,'crypto.h']]],
- ['psa_5faead_5ffinish',['psa_aead_finish',['../group__aead.html#ga759791bbe1763b377c3b5447641f1fc8',1,'crypto.h']]],
- ['psa_5faead_5ffinish_5foutput_5fsize',['PSA_AEAD_FINISH_OUTPUT_SIZE',['../crypto__sizes_8h.html#ab097f6e054f1a73e975d597ade9029a6',1,'crypto_sizes.h']]],
- ['psa_5faead_5fgenerate_5fnonce',['psa_aead_generate_nonce',['../group__aead.html#ga3eadcf2a29f662129ea4fb3454969ba2',1,'crypto.h']]],
- ['psa_5faead_5foperation_5finit',['PSA_AEAD_OPERATION_INIT',['../group__aead.html#gaf52e036794c0dc6fbadd93a2b990f366',1,'crypto.h']]],
- ['psa_5faead_5foperation_5ft',['psa_aead_operation_t',['../group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed',1,'crypto.h']]],
- ['psa_5faead_5fset_5flengths',['psa_aead_set_lengths',['../group__aead.html#gad3431e28d05002c2a7b0760610176050',1,'crypto.h']]],
- ['psa_5faead_5fset_5fnonce',['psa_aead_set_nonce',['../group__aead.html#ga40641d0721ca7fe01bbcd9ef635fbc46',1,'crypto.h']]],
- ['psa_5faead_5ftag_5flength',['PSA_AEAD_TAG_LENGTH',['../crypto__sizes_8h.html#a8e3079b2e624cb8d32b94843cddada49',1,'crypto_sizes.h']]],
- ['psa_5faead_5fupdate',['psa_aead_update',['../group__aead.html#ga3b105de2088cef7c3d9e2fd8048c841c',1,'crypto.h']]],
- ['psa_5faead_5fupdate_5fad',['psa_aead_update_ad',['../group__aead.html#ga6d0eed03f832e5c9c91cb8adf2882569',1,'crypto.h']]],
- ['psa_5faead_5fverify',['psa_aead_verify',['../group__aead.html#gaaed211fc61977c859d6ff07f39f59219',1,'crypto.h']]],
- ['psa_5falg_5faead_5fwith_5fdefault_5ftag_5flength',['PSA_ALG_AEAD_WITH_DEFAULT_TAG_LENGTH',['../group__crypto__types.html#gaddea507e062250cda8a29407a9480d2b',1,'crypto_values.h']]],
- ['psa_5falg_5faead_5fwith_5ftag_5flength',['PSA_ALG_AEAD_WITH_TAG_LENGTH',['../group__crypto__types.html#gaa63c520b62ab001d54d28801742fc9db',1,'crypto_values.h']]],
- ['psa_5falg_5fany_5fhash',['PSA_ALG_ANY_HASH',['../group__crypto__types.html#gaa1288ea8bd397a8a3f5e19e94110f2e4',1,'crypto_values.h']]],
- ['psa_5falg_5farc4',['PSA_ALG_ARC4',['../group__crypto__types.html#gab6a5284decb0e5e1b5b8740a41ef3c5e',1,'crypto_values.h']]],
- ['psa_5falg_5fcbc_5fno_5fpadding',['PSA_ALG_CBC_NO_PADDING',['../group__crypto__types.html#gacb332d72716958880ee7f97d8365ae66',1,'crypto_values.h']]],
- ['psa_5falg_5fcbc_5fpkcs7',['PSA_ALG_CBC_PKCS7',['../group__crypto__types.html#gaef50d2e9716eb6d476046608e4e0c78c',1,'crypto_values.h']]],
- ['psa_5falg_5fccm',['PSA_ALG_CCM',['../group__crypto__types.html#gac2c0e7d21f1b2df5e76bcb4a8f84273c',1,'crypto_values.h']]],
- ['psa_5falg_5fctr',['PSA_ALG_CTR',['../group__crypto__types.html#gad318309706a769cffdc64e4c7e06b2e9',1,'crypto_values.h']]],
- ['psa_5falg_5fdeterministic_5fdsa',['PSA_ALG_DETERMINISTIC_DSA',['../group__crypto__types.html#gab8eb98fb6d2e094e47f3b44dfe128f94',1,'crypto_values.h']]],
- ['psa_5falg_5fdeterministic_5fecdsa',['PSA_ALG_DETERMINISTIC_ECDSA',['../group__crypto__types.html#ga11da566bcd341661c8de921e2ca5ed03',1,'crypto_values.h']]],
- ['psa_5falg_5fdsa',['PSA_ALG_DSA',['../group__crypto__types.html#ga9a68efdddff5ae95f104a1416b12742e',1,'crypto_values.h']]],
- ['psa_5falg_5fecdh',['PSA_ALG_ECDH',['../group__crypto__types.html#gab2dbcf71b63785e7dd7b54a100edee43',1,'crypto_values.h']]],
- ['psa_5falg_5fecdsa',['PSA_ALG_ECDSA',['../group__crypto__types.html#ga7e3ce9f514a227d5ba5d8318870452e3',1,'crypto_values.h']]],
- ['psa_5falg_5fecdsa_5fany',['PSA_ALG_ECDSA_ANY',['../group__crypto__types.html#ga51d6b6044a62e33cae0cf64bfc3b22a4',1,'crypto_values.h']]],
- ['psa_5falg_5fffdh',['PSA_ALG_FFDH',['../group__crypto__types.html#ga0ebbb6f93a05b6511e6f108ffd2d1eb4',1,'crypto_values.h']]],
- ['psa_5falg_5ffull_5flength_5fmac',['PSA_ALG_FULL_LENGTH_MAC',['../group__crypto__types.html#gaa05a8d99634f3350597ac9284fb70cb1',1,'crypto_values.h']]],
- ['psa_5falg_5fgcm',['PSA_ALG_GCM',['../group__crypto__types.html#ga0d7d02b15aaae490d38277d99f1c637c',1,'crypto_values.h']]],
- ['psa_5falg_5fhkdf',['PSA_ALG_HKDF',['../group__crypto__types.html#ga32a888fb360e6e25cab8a343772c4a82',1,'crypto_values.h']]],
- ['psa_5falg_5fhmac',['PSA_ALG_HMAC',['../group__crypto__types.html#ga70f397425684b3efcde1e0e34c28261f',1,'crypto_values.h']]],
- ['psa_5falg_5fis_5faead',['PSA_ALG_IS_AEAD',['../group__crypto__types.html#ga1d44829d60065eaa4ac9a703e7d6abc8',1,'crypto_values.h']]],
- ['psa_5falg_5fis_5fasymmetric_5fencryption',['PSA_ALG_IS_ASYMMETRIC_ENCRYPTION',['../group__crypto__types.html#ga41d2ee937d54efd76bd54a97b2ebc08a',1,'crypto_values.h']]],
- ['psa_5falg_5fis_5fblock_5fcipher_5fmac',['PSA_ALG_IS_BLOCK_CIPHER_MAC',['../group__crypto__types.html#gae49d1eb601125d65a5c5b252aa45479e',1,'crypto_values.h']]],
- ['psa_5falg_5fis_5fcipher',['PSA_ALG_IS_CIPHER',['../group__crypto__types.html#ga1d1a5a402ad89a2e68f12bfb535490eb',1,'crypto_values.h']]],
- ['psa_5falg_5fis_5fecdh',['PSA_ALG_IS_ECDH',['../group__crypto__types.html#ga9d9b6533d2a6bea7bac7ae01facb820d',1,'crypto_values.h']]],
- ['psa_5falg_5fis_5fffdh',['PSA_ALG_IS_FFDH',['../group__crypto__types.html#gaa3cf76164cd9375af4fb8a291078a19e',1,'crypto_values.h']]],
- ['psa_5falg_5fis_5fhash',['PSA_ALG_IS_HASH',['../group__crypto__types.html#gac9280662bb482590b4b33d1dcd32930f',1,'crypto_values.h']]],
- ['psa_5falg_5fis_5fhash_5fand_5fsign',['PSA_ALG_IS_HASH_AND_SIGN',['../group__crypto__types.html#gad8a8ea0536975363b66410cdeafe38b6',1,'crypto_values.h']]],
- ['psa_5falg_5fis_5fhkdf',['PSA_ALG_IS_HKDF',['../group__crypto__types.html#ga1979d0a76fcee6164cf2e65960f38db2',1,'crypto_values.h']]],
- ['psa_5falg_5fis_5fhmac',['PSA_ALG_IS_HMAC',['../group__crypto__types.html#ga4a050c3c3cbc6eb96418f18847601c8a',1,'crypto_values.h']]],
- ['psa_5falg_5fis_5fkey_5fagreement',['PSA_ALG_IS_KEY_AGREEMENT',['../group__crypto__types.html#ga59753742cb06553bd22751bbef472b6f',1,'crypto_values.h']]],
- ['psa_5falg_5fis_5fkey_5fderivation',['PSA_ALG_IS_KEY_DERIVATION',['../group__crypto__types.html#gaf8b90c648aa53dbd06c236695e300cd0',1,'crypto_values.h']]],
- ['psa_5falg_5fis_5fmac',['PSA_ALG_IS_MAC',['../group__crypto__types.html#gaca7aee4c9dde316b3b1a150a26eab776',1,'crypto_values.h']]],
- ['psa_5falg_5fis_5fraw_5fkey_5fagreement',['PSA_ALG_IS_RAW_KEY_AGREEMENT',['../group__crypto__types.html#gaa40ab362ce141ce541d69b2eb1f41438',1,'crypto_values.h']]],
- ['psa_5falg_5fis_5fsign',['PSA_ALG_IS_SIGN',['../group__crypto__types.html#ga6d490d0904e0698f6c1268a89d72ff31',1,'crypto_values.h']]],
- ['psa_5falg_5fis_5fstream_5fcipher',['PSA_ALG_IS_STREAM_CIPHER',['../group__crypto__types.html#gacfec68e0c6175e02e1b2ebc97df383c0',1,'crypto_values.h']]],
- ['psa_5falg_5fis_5ftls12_5fprf',['PSA_ALG_IS_TLS12_PRF',['../group__crypto__types.html#gaa3c18890c50222e5219f40ade8927e66',1,'crypto_values.h']]],
- ['psa_5falg_5fis_5ftls12_5fpsk_5fto_5fms',['PSA_ALG_IS_TLS12_PSK_TO_MS',['../group__crypto__types.html#gab25ecc074a93fd11069bedfbba5a287b',1,'crypto_values.h']]],
- ['psa_5falg_5fis_5fwildcard',['PSA_ALG_IS_WILDCARD',['../group__crypto__types.html#gacf83d7430e82b97cecb8b26ca6fa1426',1,'crypto_values.h']]],
- ['psa_5falg_5fkey_5fagreement',['PSA_ALG_KEY_AGREEMENT',['../group__crypto__types.html#ga78bb81cffb87a635c247725eeb2a2682',1,'crypto_values.h']]],
- ['psa_5falg_5frsa_5foaep',['PSA_ALG_RSA_OAEP',['../group__crypto__types.html#gaa1235dc3fdd9839c6c1b1a9857344c76',1,'crypto_values.h']]],
- ['psa_5falg_5frsa_5fpkcs1v15_5fcrypt',['PSA_ALG_RSA_PKCS1V15_CRYPT',['../group__crypto__types.html#ga4c540d3abe43fb9abcb94f2bc51acef9',1,'crypto_values.h']]],
- ['psa_5falg_5frsa_5fpkcs1v15_5fsign',['PSA_ALG_RSA_PKCS1V15_SIGN',['../group__crypto__types.html#ga702ff75385a6ae7d4247033f479439af',1,'crypto_values.h']]],
- ['psa_5falg_5frsa_5fpkcs1v15_5fsign_5fraw',['PSA_ALG_RSA_PKCS1V15_SIGN_RAW',['../group__crypto__types.html#ga4215e2a78dcf834e9a625927faa2a817',1,'crypto_values.h']]],
- ['psa_5falg_5frsa_5fpss',['PSA_ALG_RSA_PSS',['../group__crypto__types.html#ga62152bf4cb4bf6aace5e1be8f143564d',1,'crypto_values.h']]],
- ['psa_5falg_5fsha3_5f224',['PSA_ALG_SHA3_224',['../group__crypto__types.html#ga16f5fe34ccce68c2fada1224c054a999',1,'crypto_values.h']]],
- ['psa_5falg_5fsha3_5f256',['PSA_ALG_SHA3_256',['../group__crypto__types.html#gaace70d9515489bbe3c5e7ac1b7d9155b',1,'crypto_values.h']]],
- ['psa_5falg_5fsha3_5f384',['PSA_ALG_SHA3_384',['../group__crypto__types.html#gab0f079257ea75e2acfe2fc3b38c78cd8',1,'crypto_values.h']]],
- ['psa_5falg_5fsha3_5f512',['PSA_ALG_SHA3_512',['../group__crypto__types.html#ga37e5dbe936dddb155e76f2997de27188',1,'crypto_values.h']]],
- ['psa_5falg_5fsha_5f224',['PSA_ALG_SHA_224',['../group__crypto__types.html#ga25d6a3244d10a7148fe6b026d1979f7b',1,'crypto_values.h']]],
- ['psa_5falg_5fsha_5f256',['PSA_ALG_SHA_256',['../group__crypto__types.html#ga619471f978e13cdd0a1e37145e4bf341',1,'crypto_values.h']]],
- ['psa_5falg_5fsha_5f384',['PSA_ALG_SHA_384',['../group__crypto__types.html#ga58af64dd9a86a287e8da9ed7739eead4',1,'crypto_values.h']]],
- ['psa_5falg_5fsha_5f512',['PSA_ALG_SHA_512',['../group__crypto__types.html#gafba3ae409f46d3dd7f37a0910660c3e9',1,'crypto_values.h']]],
- ['psa_5falg_5fsha_5f512_5f224',['PSA_ALG_SHA_512_224',['../group__crypto__types.html#ga3fe2d7c3c80e3186ca78d16a35d5d931',1,'crypto_values.h']]],
- ['psa_5falg_5fsha_5f512_5f256',['PSA_ALG_SHA_512_256',['../group__crypto__types.html#ga5910b3964c14e9613e8643a45b09c2d4',1,'crypto_values.h']]],
- ['psa_5falg_5fsign_5fget_5fhash',['PSA_ALG_SIGN_GET_HASH',['../group__crypto__types.html#ga24cf6d7bcd2b9aeeeff86f07b6c674e3',1,'crypto_values.h']]],
- ['psa_5falg_5ftls12_5fprf',['PSA_ALG_TLS12_PRF',['../group__crypto__types.html#ga6d5623c2ccda1d4a84e34351af8382d5',1,'crypto_values.h']]],
- ['psa_5falg_5ftls12_5fpsk_5fto_5fms',['PSA_ALG_TLS12_PSK_TO_MS',['../group__crypto__types.html#ga039ec797f15d1635d9b2e09a611f8a68',1,'crypto_values.h']]],
- ['psa_5falg_5ftls12_5fpsk_5fto_5fms_5fmax_5fpsk_5flen',['PSA_ALG_TLS12_PSK_TO_MS_MAX_PSK_LEN',['../crypto__sizes_8h.html#ab589ea3b86f2bfa18880459299c58f8a',1,'crypto_sizes.h']]],
- ['psa_5falg_5ftruncated_5fmac',['PSA_ALG_TRUNCATED_MAC',['../group__crypto__types.html#gaf36137110baf7bb13c5028fd62c64276',1,'crypto_values.h']]],
- ['psa_5falg_5fxts',['PSA_ALG_XTS',['../group__crypto__types.html#gaa722c0e426a797fd6d99623f59748125',1,'crypto_values.h']]],
- ['psa_5falgorithm_5ft',['psa_algorithm_t',['../group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69',1,'crypto_types.h']]],
- ['psa_5fallocate_5fkey',['psa_allocate_key',['../group__key__management.html#ga40094b77b7a42b9c8e158395113f1a35',1,'crypto.h']]],
- ['psa_5fasymmetric_5fdecrypt',['psa_asymmetric_decrypt',['../group__asymmetric.html#ga34b55fbaee23dba1a677186fc66a556e',1,'crypto.h']]],
- ['psa_5fasymmetric_5fdecrypt_5foutput_5fsize',['PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE',['../crypto__sizes_8h.html#a61a246f3eac41989821d982e56fea6c1',1,'crypto_sizes.h']]],
- ['psa_5fasymmetric_5fencrypt',['psa_asymmetric_encrypt',['../group__asymmetric.html#gad429293b7b0bf2a830b9540a02552004',1,'crypto.h']]],
- ['psa_5fasymmetric_5fencrypt_5foutput_5fsize',['PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE',['../crypto__sizes_8h.html#a66ba3bd93e5ec52870ccc3848778bad8',1,'crypto_sizes.h']]],
- ['psa_5fasymmetric_5fsign',['psa_asymmetric_sign',['../group__asymmetric.html#ga1b0db9d345b5048cdd39357ac2d56c07',1,'crypto.h']]],
- ['psa_5fasymmetric_5fsign_5foutput_5fsize',['PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE',['../crypto__sizes_8h.html#a77565b9b4fe6d8730fd2120f4c8378ab',1,'crypto_sizes.h']]],
- ['psa_5fasymmetric_5fsignature_5fmax_5fsize',['PSA_ASYMMETRIC_SIGNATURE_MAX_SIZE',['../crypto__sizes_8h.html#ad755101764dba14589e5919ee41be7ca',1,'crypto_sizes.h']]],
- ['psa_5fasymmetric_5fverify',['psa_asymmetric_verify',['../group__asymmetric.html#ga1b8e964c8d927e3d632325d762959eb7',1,'crypto.h']]],
- ['psa_5fblock_5fcipher_5fblock_5fsize',['PSA_BLOCK_CIPHER_BLOCK_SIZE',['../group__crypto__types.html#gacaa366bdeb0413e63e87a667c5457b2e',1,'crypto_values.h']]],
- ['psa_5fcipher_5fabort',['psa_cipher_abort',['../group__cipher.html#gaad482cdca2098bca0620596aaa02eaa4',1,'crypto.h']]],
- ['psa_5fcipher_5fdecrypt',['psa_cipher_decrypt',['../group__cipher.html#ga43d5991711ec45c98af0c1d99f6e0216',1,'crypto.h']]],
- ['psa_5fcipher_5fdecrypt_5fsetup',['psa_cipher_decrypt_setup',['../group__cipher.html#gaddf8504e5367cd0efb4415bdec004f44',1,'crypto.h']]],
- ['psa_5fcipher_5fencrypt',['psa_cipher_encrypt',['../group__cipher.html#gac76dda492d9a1ba6b327bff610ec17b2',1,'crypto.h']]],
- ['psa_5fcipher_5fencrypt_5fsetup',['psa_cipher_encrypt_setup',['../group__cipher.html#ga2a7fc79a9d150d42dba99f40ee3a185e',1,'crypto.h']]],
- ['psa_5fcipher_5ffinish',['psa_cipher_finish',['../group__cipher.html#ga1dcb58b8befe23f8a4d7a1d49c99249b',1,'crypto.h']]],
- ['psa_5fcipher_5fgenerate_5fiv',['psa_cipher_generate_iv',['../group__cipher.html#ga44857cf5e0c3d134a3c560f8ff5b50aa',1,'crypto.h']]],
- ['psa_5fcipher_5foperation_5finit',['PSA_CIPHER_OPERATION_INIT',['../group__cipher.html#ga2da0541aabf9a4995cf2004e36311919',1,'crypto.h']]],
- ['psa_5fcipher_5foperation_5ft',['psa_cipher_operation_t',['../group__cipher.html#ga1399de29db657e3737bb09927aae51fa',1,'crypto.h']]],
- ['psa_5fcipher_5fset_5fiv',['psa_cipher_set_iv',['../group__cipher.html#ga1359b2101f31637496ce7cc36c6e3d42',1,'crypto.h']]],
- ['psa_5fcipher_5fupdate',['psa_cipher_update',['../group__cipher.html#gafd0caea99cf1052527e4089d37f5ab91',1,'crypto.h']]],
- ['psa_5fclose_5fkey',['psa_close_key',['../group__key__management.html#gaa09b720d299dfe6b9f41c36e448078eb',1,'crypto.h']]],
- ['psa_5fcopy_5fkey',['psa_copy_key',['../group__import__export.html#ga5c1c24176cfb1517a8806235b3162a9d',1,'crypto.h']]],
- ['psa_5fcreate_5fkey',['psa_create_key',['../group__key__management.html#ga4108f255d3eaa6d23a7a14b684af8d7c',1,'crypto.h']]],
- ['psa_5fcrypto_5fgenerator_5finit',['PSA_CRYPTO_GENERATOR_INIT',['../group__generators.html#ga4788b471385fc667876fbd8a0d3fe062',1,'crypto.h']]],
- ['psa_5fcrypto_5fgenerator_5ft',['psa_crypto_generator_t',['../group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b',1,'crypto.h']]],
- ['psa_5fcrypto_5finit',['psa_crypto_init',['../group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9',1,'crypto.h']]],
- ['psa_5fdestroy_5fkey',['psa_destroy_key',['../group__import__export.html#ga165085fc1bc7a78b91792fdd94ae102c',1,'crypto.h']]],
- ['psa_5fecc_5fcurve_5ft',['psa_ecc_curve_t',['../group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9',1,'crypto_types.h']]],
- ['psa_5fecdsa_5fsignature_5fsize',['PSA_ECDSA_SIGNATURE_SIZE',['../crypto__sizes_8h.html#a10c472a35f04051add6b20cc228ffc11',1,'crypto_sizes.h']]],
- ['psa_5ferror_5fbad_5fstate',['PSA_ERROR_BAD_STATE',['../group__error.html#ga933d40fa2a591004f2e93aa91e11db84',1,'crypto_values.h']]],
- ['psa_5ferror_5fbuffer_5ftoo_5fsmall',['PSA_ERROR_BUFFER_TOO_SMALL',['../group__error.html#ga695025f4ec11249aee7ea3d0f65e01c8',1,'crypto_values.h']]],
- ['psa_5ferror_5fcommunication_5ffailure',['PSA_ERROR_COMMUNICATION_FAILURE',['../group__error.html#ga5cdb6948371d49e916106249020ea3f7',1,'crypto_values.h']]],
- ['psa_5ferror_5fempty_5fslot',['PSA_ERROR_EMPTY_SLOT',['../group__error.html#gaba00e3e6ceb2b12965a81e5ac02ae040',1,'crypto_values.h']]],
- ['psa_5ferror_5fhardware_5ffailure',['PSA_ERROR_HARDWARE_FAILURE',['../group__error.html#ga08b10e70fa5ff0b05c631d9f8f6b2c6b',1,'crypto_values.h']]],
- ['psa_5ferror_5finsufficient_5fcapacity',['PSA_ERROR_INSUFFICIENT_CAPACITY',['../group__error.html#gaf1fa61f72e9e5b4a848c991bea495767',1,'crypto_values.h']]],
- ['psa_5ferror_5finsufficient_5fentropy',['PSA_ERROR_INSUFFICIENT_ENTROPY',['../group__error.html#ga4deb59fec02297ec5d8b42178323f675',1,'crypto_values.h']]],
- ['psa_5ferror_5finsufficient_5fmemory',['PSA_ERROR_INSUFFICIENT_MEMORY',['../group__error.html#ga91b2ad8a867517a2651f1b076c5216e5',1,'crypto_values.h']]],
- ['psa_5ferror_5finsufficient_5fstorage',['PSA_ERROR_INSUFFICIENT_STORAGE',['../group__error.html#ga897a45eb206a6f6b7be7ffbe36f0d766',1,'crypto_values.h']]],
- ['psa_5ferror_5finvalid_5fargument',['PSA_ERROR_INVALID_ARGUMENT',['../group__error.html#ga798df25a505ebf931f7bec1f80f1f85f',1,'crypto_values.h']]],
- ['psa_5ferror_5finvalid_5fhandle',['PSA_ERROR_INVALID_HANDLE',['../group__error.html#gadf22718935657c2c3168c228204085f9',1,'crypto_values.h']]],
- ['psa_5ferror_5finvalid_5fpadding',['PSA_ERROR_INVALID_PADDING',['../group__error.html#gabe29594edbfb152cf153975b0597ac48',1,'crypto_values.h']]],
- ['psa_5ferror_5finvalid_5fsignature',['PSA_ERROR_INVALID_SIGNATURE',['../group__error.html#ga35927f755d232c4766de600f2c49e9f2',1,'crypto_values.h']]],
- ['psa_5ferror_5fnot_5fpermitted',['PSA_ERROR_NOT_PERMITTED',['../group__error.html#ga4d1b8dd8526177a15a210b7afc1accb1',1,'crypto_values.h']]],
- ['psa_5ferror_5fnot_5fsupported',['PSA_ERROR_NOT_SUPPORTED',['../group__error.html#ga1dcc6d130633ed5db8942257581b55dd',1,'crypto_values.h']]],
- ['psa_5ferror_5foccupied_5fslot',['PSA_ERROR_OCCUPIED_SLOT',['../group__error.html#gac2fee3a51249fbea45360aaa911f3e58',1,'crypto_values.h']]],
- ['psa_5ferror_5fstorage_5ffailure',['PSA_ERROR_STORAGE_FAILURE',['../group__error.html#gadd169a1af2707862b95fb9df91dfc37d',1,'crypto_values.h']]],
- ['psa_5ferror_5ftampering_5fdetected',['PSA_ERROR_TAMPERING_DETECTED',['../group__error.html#ga2c5dda1485cb54f2385cb9c1279a7004',1,'crypto_values.h']]],
- ['psa_5ferror_5funknown_5ferror',['PSA_ERROR_UNKNOWN_ERROR',['../group__error.html#ga24d5fdcdd759f846f79d9e581c63a83f',1,'crypto_values.h']]],
- ['psa_5fexport_5fkey',['psa_export_key',['../group__import__export.html#ga902b9a7a6cf34d6111668be777b05eaf',1,'crypto.h']]],
- ['psa_5fexport_5fpublic_5fkey',['psa_export_public_key',['../group__import__export.html#gad760d1f0d4e60972c78cbb4c8a528256',1,'crypto.h']]],
- ['psa_5fgenerate_5fkey',['psa_generate_key',['../group__random.html#ga72921520494b4f007a3afb904cd9ecdd',1,'crypto.h']]],
- ['psa_5fgenerate_5fkey_5fextra_5frsa',['psa_generate_key_extra_rsa',['../structpsa__generate__key__extra__rsa.html',1,'']]],
- ['psa_5fgenerate_5frandom',['psa_generate_random',['../group__random.html#ga1985eae417dfbccedf50d5fff54ea8c5',1,'crypto.h']]],
- ['psa_5fgenerator_5fabort',['psa_generator_abort',['../group__generators.html#ga563ca64537d90368899286b36d8cf7f3',1,'crypto.h']]],
- ['psa_5fgenerator_5fimport_5fkey',['psa_generator_import_key',['../group__generators.html#ga7fcdf07cd37279ca167db484053da894',1,'crypto.h']]],
- ['psa_5fgenerator_5fread',['psa_generator_read',['../group__generators.html#gab5712ad29b78c2b170e64cc5bcfc1bce',1,'crypto.h']]],
- ['psa_5fgenerator_5funbridled_5fcapacity',['PSA_GENERATOR_UNBRIDLED_CAPACITY',['../group__generators.html#gac3222df9b9ecca4d33ae56a7b8fbb1c9',1,'crypto.h']]],
- ['psa_5fget_5fgenerator_5fcapacity',['psa_get_generator_capacity',['../group__generators.html#ga7453491e3b440193be2c5dccc2040fd2',1,'crypto.h']]],
- ['psa_5fget_5fkey_5fdomain_5fparameters',['psa_get_key_domain_parameters',['../group__import__export.html#gae260b92e32ac5d63f7dfc6ffdf6536f7',1,'crypto.h']]],
- ['psa_5fget_5fkey_5finformation',['psa_get_key_information',['../group__import__export.html#gae8939902d6977ea8ad13eb7b4db9a042',1,'crypto.h']]],
- ['psa_5fget_5fkey_5flifetime',['psa_get_key_lifetime',['../group__key__management.html#ga1e4825ab59260aeb3bdbb3ff07210022',1,'crypto.h']]],
- ['psa_5fget_5fkey_5fpolicy',['psa_get_key_policy',['../group__policy.html#gaed087d1386b807edee66b2e445ba9111',1,'crypto.h']]],
- ['psa_5fhash_5fabort',['psa_hash_abort',['../group__hash.html#gab0b4d5f9912a615559497a467b532928',1,'crypto.h']]],
- ['psa_5fhash_5fclone',['psa_hash_clone',['../group__hash.html#ga39673348f3302b4646bd780034a5aeda',1,'crypto.h']]],
- ['psa_5fhash_5fcompare',['psa_hash_compare',['../group__hash.html#ga0bb6dbd3c310648c3cf7d202413ff0bc',1,'crypto.h']]],
- ['psa_5fhash_5fcompute',['psa_hash_compute',['../group__hash.html#gac69f7f19d96a56c28cf3799d11b12156',1,'crypto.h']]],
- ['psa_5fhash_5ffinish',['psa_hash_finish',['../group__hash.html#ga4795fd06a0067b0adcd92e9627b8c97e',1,'crypto.h']]],
- ['psa_5fhash_5fmax_5fsize',['PSA_HASH_MAX_SIZE',['../crypto__sizes_8h.html#a6ce1014efbbc0bcca286ef7f9a72cb29',1,'crypto_sizes.h']]],
- ['psa_5fhash_5foperation_5finit',['PSA_HASH_OPERATION_INIT',['../group__hash.html#ga6ab7fe8d3500bc2f21be840b4f4f8d1d',1,'crypto.h']]],
- ['psa_5fhash_5foperation_5ft',['psa_hash_operation_t',['../group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab',1,'crypto.h']]],
- ['psa_5fhash_5fsetup',['psa_hash_setup',['../group__hash.html#ga8d72896cf70fc4d514c5c6b978912515',1,'crypto.h']]],
- ['psa_5fhash_5fsize',['PSA_HASH_SIZE',['../crypto__sizes_8h.html#aef340331ce3cba2b57e1fc5624bf1f99',1,'crypto_sizes.h']]],
- ['psa_5fhash_5fupdate',['psa_hash_update',['../group__hash.html#ga65b16ef97d7f650899b7db4b7d1112ff',1,'crypto.h']]],
- ['psa_5fhash_5fverify',['psa_hash_verify',['../group__hash.html#ga7be923c5700c9c70ef77ee9b76d1a5c0',1,'crypto.h']]],
- ['psa_5fimport_5fkey',['psa_import_key',['../group__import__export.html#gac9f999cb4d098663d56095afe81a453a',1,'crypto.h']]],
- ['psa_5fkdf_5fstep_5finfo',['PSA_KDF_STEP_INFO',['../group__derivation.html#ga836afe760bbda3dafc6c29631560b1a0',1,'crypto_values.h']]],
- ['psa_5fkdf_5fstep_5flabel',['PSA_KDF_STEP_LABEL',['../group__derivation.html#ga9f4da10191bcb690b88756ed8470b03c',1,'crypto_values.h']]],
- ['psa_5fkdf_5fstep_5fsalt',['PSA_KDF_STEP_SALT',['../group__derivation.html#ga384777dac55791d8f3a1af72c847b327',1,'crypto_values.h']]],
- ['psa_5fkdf_5fstep_5fsecret',['PSA_KDF_STEP_SECRET',['../group__derivation.html#ga90a1995a41e26ed5ca30d2d4641d1168',1,'crypto_values.h']]],
- ['psa_5fkey_5fagreement',['psa_key_agreement',['../group__derivation.html#ga2c7fe304cacc141ffb91553548abc5d2',1,'crypto.h']]],
- ['psa_5fkey_5fagreement_5fraw_5fshared_5fsecret',['psa_key_agreement_raw_shared_secret',['../group__derivation.html#gaf1b12eff66a1a0020b5bdc8d0e910006',1,'crypto.h']]],
- ['psa_5fkey_5fderivation_5finput_5fbytes',['psa_key_derivation_input_bytes',['../group__derivation.html#ga1b30e888db65c71f5337900848e1b03f',1,'crypto.h']]],
- ['psa_5fkey_5fderivation_5finput_5fkey',['psa_key_derivation_input_key',['../group__derivation.html#ga9e5f549aa1f6f3863a07008d3d98f91a',1,'crypto.h']]],
- ['psa_5fkey_5fderivation_5fsetup',['psa_key_derivation_setup',['../group__derivation.html#ga1825696be813dfac2b8d3d02717e71c5',1,'crypto.h']]],
- ['psa_5fkey_5fderivation_5fstep_5ft',['psa_key_derivation_step_t',['../group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b',1,'crypto_types.h']]],
- ['psa_5fkey_5fexport_5fmax_5fsize',['PSA_KEY_EXPORT_MAX_SIZE',['../crypto__sizes_8h.html#a0aae885cc8ff92e00fb5248420b939c3',1,'crypto_sizes.h']]],
- ['psa_5fkey_5fhandle_5ft',['psa_key_handle_t',['../group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75',1,'crypto.h']]],
- ['psa_5fkey_5fid_5ft',['psa_key_id_t',['../group__key__lifetimes.html#ga11e986351c65bd3dc3c0fe2cd9926e4b',1,'crypto_types.h']]],
- ['psa_5fkey_5flifetime_5fpersistent',['PSA_KEY_LIFETIME_PERSISTENT',['../group__key__lifetimes.html#ga3713a01c5fcd5f7eae46ff22ceaf6d02',1,'crypto_values.h']]],
- ['psa_5fkey_5flifetime_5ft',['psa_key_lifetime_t',['../group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf',1,'crypto_types.h']]],
- ['psa_5fkey_5flifetime_5fvolatile',['PSA_KEY_LIFETIME_VOLATILE',['../group__key__lifetimes.html#ga8b438870ba69489b685730d346455108',1,'crypto_values.h']]],
- ['psa_5fkey_5fpolicy_5fget_5falgorithm',['psa_key_policy_get_algorithm',['../group__policy.html#gaadf16b89ace53e1d2cb5bcb0aef24c86',1,'crypto.h']]],
- ['psa_5fkey_5fpolicy_5fget_5fusage',['psa_key_policy_get_usage',['../group__policy.html#ga7746662b7503e484774d0ecb5d8ac2ab',1,'crypto.h']]],
- ['psa_5fkey_5fpolicy_5finit',['PSA_KEY_POLICY_INIT',['../group__policy.html#ga5e6bc5f550e88fdc7790f2a75e79f7c5',1,'crypto.h']]],
- ['psa_5fkey_5fpolicy_5fset_5fusage',['psa_key_policy_set_usage',['../group__policy.html#gac16792fd6d375a5f76d372090df40607',1,'crypto.h']]],
- ['psa_5fkey_5fpolicy_5ft',['psa_key_policy_t',['../group__policy.html#gaf553efd409845b6d09ff25ce2ba36607',1,'crypto.h']]],
- ['psa_5fkey_5ftype_5faes',['PSA_KEY_TYPE_AES',['../group__crypto__types.html#ga6ee54579dcf278c677eda4bb1a29575e',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5farc4',['PSA_KEY_TYPE_ARC4',['../group__crypto__types.html#gae4d46e83f910dcaa126000a8ed03cde9',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5fcamellia',['PSA_KEY_TYPE_CAMELLIA',['../group__crypto__types.html#gad8e5da742343fd5519f9d8a630c2ed81',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5fderive',['PSA_KEY_TYPE_DERIVE',['../group__crypto__types.html#gae871b2357b8593f33bfd51abbf93ebb1',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5fdes',['PSA_KEY_TYPE_DES',['../group__crypto__types.html#ga577562bfbbc691c820d55ec308333138',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5fdh_5fkeypair',['PSA_KEY_TYPE_DH_KEYPAIR',['../group__crypto__types.html#ga39b63c6b97a62a316c0660bf72b2fdd5',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5fdh_5fpublic_5fkey',['PSA_KEY_TYPE_DH_PUBLIC_KEY',['../group__crypto__types.html#ga325a340d7c72d99d3a678eb210bf6e0a',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5fdsa_5fkeypair',['PSA_KEY_TYPE_DSA_KEYPAIR',['../group__crypto__types.html#ga011010ee28c20388f3d89fb27088ed62',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5fdsa_5fpublic_5fkey',['PSA_KEY_TYPE_DSA_PUBLIC_KEY',['../group__crypto__types.html#ga5e7439c2905136366c3a876e62e5ddfc',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5fecc_5fkeypair',['PSA_KEY_TYPE_ECC_KEYPAIR',['../group__crypto__types.html#gadf3ad65d157bf5282849c954bf3f51af',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5fecc_5fpublic_5fkey',['PSA_KEY_TYPE_ECC_PUBLIC_KEY',['../group__crypto__types.html#gad54c03d3b47020e571a72cd01d978cf2',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5fget_5fcurve',['PSA_KEY_TYPE_GET_CURVE',['../group__crypto__types.html#ga0c567210e6f80aa8f2aa87efa7a3a3f9',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5fhmac',['PSA_KEY_TYPE_HMAC',['../group__crypto__types.html#ga92d989f4ca64abd00f463defd773a6f8',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5fis_5fasymmetric',['PSA_KEY_TYPE_IS_ASYMMETRIC',['../group__crypto__types.html#gab138ae2ebf2905dfbaf4154db2620939',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5fis_5fdh',['PSA_KEY_TYPE_IS_DH',['../group__crypto__types.html#ga248ae35c0e2becaebbf479fc1c3a3b0e',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5fis_5fdsa',['PSA_KEY_TYPE_IS_DSA',['../group__crypto__types.html#ga273fdfcf23eb0624f8b63d2321cf95c1',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5fis_5fecc',['PSA_KEY_TYPE_IS_ECC',['../group__crypto__types.html#ga88e01fa06b585654689a99bcc06bbe66',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5fis_5fecc_5fkeypair',['PSA_KEY_TYPE_IS_ECC_KEYPAIR',['../group__crypto__types.html#ga7bf101b671e8cf26f4cb08fcb679db4b',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5fis_5fecc_5fpublic_5fkey',['PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY',['../group__crypto__types.html#ga5af146a173b0c84d7e737e2fb6a3c0a7',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5fis_5fkeypair',['PSA_KEY_TYPE_IS_KEYPAIR',['../group__crypto__types.html#gac14c6d6e1b2b7f4a92a7b757465cff29',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5fis_5fpublic_5fkey',['PSA_KEY_TYPE_IS_PUBLIC_KEY',['../group__crypto__types.html#gac674a0f059bc0cb72b47f0c517b4f45b',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5fis_5frsa',['PSA_KEY_TYPE_IS_RSA',['../group__crypto__types.html#ga0e1d8f241228e49c9cadadfb4579ef1a',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5fis_5funstructured',['PSA_KEY_TYPE_IS_UNSTRUCTURED',['../group__crypto__types.html#gaef86ce4e810e1c2c76068ac874bfef54',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5fis_5fvendor_5fdefined',['PSA_KEY_TYPE_IS_VENDOR_DEFINED',['../group__crypto__types.html#gadbe4c086a6562aefe344bc79e51bdfd3',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5fkeypair_5fof_5fpublic_5fkey',['PSA_KEY_TYPE_KEYPAIR_OF_PUBLIC_KEY',['../group__crypto__types.html#gaf09f1ca1de6a7e7cff0fe516f3f6c91d',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5fnone',['PSA_KEY_TYPE_NONE',['../group__crypto__types.html#gafce7ab2b54ce97ea5bff73f13a9f3e5b',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5fpublic_5fkey_5fof_5fkeypair',['PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR',['../group__crypto__types.html#gace08e46dd7cbf642d50d982a25d02bec',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5fraw_5fdata',['PSA_KEY_TYPE_RAW_DATA',['../group__crypto__types.html#gaa97f92025533102616b32d571c940d80',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5frsa_5fkeypair',['PSA_KEY_TYPE_RSA_KEYPAIR',['../group__crypto__types.html#ga581f50687f5d650456925278948f2799',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5frsa_5fpublic_5fkey',['PSA_KEY_TYPE_RSA_PUBLIC_KEY',['../group__crypto__types.html#ga9ba0878f56c8bcd1995ac017a74f513b',1,'crypto_values.h']]],
- ['psa_5fkey_5ftype_5ft',['psa_key_type_t',['../group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628',1,'crypto_types.h']]],
- ['psa_5fkey_5ftype_5fvendor_5fflag',['PSA_KEY_TYPE_VENDOR_FLAG',['../group__crypto__types.html#ga8dbaed2fdb1ebae8aa127ad3988516f7',1,'crypto_values.h']]],
- ['psa_5fkey_5fusage_5fdecrypt',['PSA_KEY_USAGE_DECRYPT',['../group__policy.html#gac3f2d2e5983db1edde9f142ca9bf8e6a',1,'crypto_values.h']]],
- ['psa_5fkey_5fusage_5fderive',['PSA_KEY_USAGE_DERIVE',['../group__policy.html#gaf19022acc5ef23cf12477f632b48a0b2',1,'crypto_values.h']]],
- ['psa_5fkey_5fusage_5fencrypt',['PSA_KEY_USAGE_ENCRYPT',['../group__policy.html#ga75153b296d045d529d97203a6a995dad',1,'crypto_values.h']]],
- ['psa_5fkey_5fusage_5fexport',['PSA_KEY_USAGE_EXPORT',['../group__policy.html#ga7dddccdd1303176e87a4d20c87b589ed',1,'crypto_values.h']]],
- ['psa_5fkey_5fusage_5fsign',['PSA_KEY_USAGE_SIGN',['../group__policy.html#ga99b9f456cf59efc4b5579465407aef5a',1,'crypto_values.h']]],
- ['psa_5fkey_5fusage_5ft',['psa_key_usage_t',['../group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25',1,'crypto_types.h']]],
- ['psa_5fkey_5fusage_5fverify',['PSA_KEY_USAGE_VERIFY',['../group__policy.html#ga39b54ffd5958b69634607924fa53cea6',1,'crypto_values.h']]],
- ['psa_5fmac_5fabort',['psa_mac_abort',['../group__MAC.html#gacd8dd54855ba1bc0a03f104f252884fd',1,'crypto.h']]],
- ['psa_5fmac_5fcompute',['psa_mac_compute',['../group__MAC.html#gace78d9b51394f9d4f77952963665897a',1,'crypto.h']]],
- ['psa_5fmac_5ffinal_5fsize',['PSA_MAC_FINAL_SIZE',['../crypto__sizes_8h.html#aa84c5fb384ac7cb1bfc52adde96588ee',1,'crypto_sizes.h']]],
- ['psa_5fmac_5fmax_5fsize',['PSA_MAC_MAX_SIZE',['../crypto__sizes_8h.html#a4681cc4f6226883a2160122c562ca682',1,'crypto_sizes.h']]],
- ['psa_5fmac_5foperation_5finit',['PSA_MAC_OPERATION_INIT',['../group__MAC.html#ga441b6efc161a4573d06465bd22d9dc2d',1,'crypto.h']]],
- ['psa_5fmac_5foperation_5ft',['psa_mac_operation_t',['../group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37',1,'crypto.h']]],
- ['psa_5fmac_5fsign_5ffinish',['psa_mac_sign_finish',['../group__MAC.html#gac22bc0125580c96724a09226cfbc97f2',1,'crypto.h']]],
- ['psa_5fmac_5fsign_5fsetup',['psa_mac_sign_setup',['../group__MAC.html#gad33f2b15119593571ca6b8e7c757ab0e',1,'crypto.h']]],
- ['psa_5fmac_5ftruncated_5flength',['PSA_MAC_TRUNCATED_LENGTH',['../group__crypto__types.html#gab03726c4476174e019a08e2a04018ce8',1,'crypto_values.h']]],
- ['psa_5fmac_5fupdate',['psa_mac_update',['../group__MAC.html#ga5560af371497babefe03c9da4e8a1c05',1,'crypto.h']]],
- ['psa_5fmac_5fverify',['psa_mac_verify',['../group__MAC.html#ga08e2e8c21bfe762a907266f3bdd1d07c',1,'crypto.h']]],
- ['psa_5fmac_5fverify_5ffinish',['psa_mac_verify_finish',['../group__MAC.html#gac92b2930d6728e1be4d011c05d485822',1,'crypto.h']]],
- ['psa_5fmac_5fverify_5fsetup',['psa_mac_verify_setup',['../group__MAC.html#gaa721a59ae6d085ec90c7dc918879a027',1,'crypto.h']]],
- ['psa_5fmax_5fblock_5fcipher_5fblock_5fsize',['PSA_MAX_BLOCK_CIPHER_BLOCK_SIZE',['../crypto__sizes_8h.html#aa3cfcff0291d6da279fec8fe834d5dec',1,'crypto_sizes.h']]],
- ['psa_5fopen_5fkey',['psa_open_key',['../group__key__management.html#gaa9f1c848cf78b80fe2a7b18bb7ccec50',1,'crypto.h']]],
- ['psa_5fset_5fgenerator_5fcapacity',['psa_set_generator_capacity',['../group__generators.html#ga45676ec3c719622f95caaf926f44bb6e',1,'crypto.h']]],
- ['psa_5fset_5fkey_5fdomain_5fparameters',['psa_set_key_domain_parameters',['../group__import__export.html#ga091da8d3d39137fd6ad59f2b10234300',1,'crypto.h']]],
- ['psa_5fset_5fkey_5fpolicy',['psa_set_key_policy',['../group__policy.html#ga1e2a6e50b621864f95d438222a3c640b',1,'crypto.h']]],
- ['psa_5fstatus_5ft',['psa_status_t',['../group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9',1,'crypto_types.h']]],
- ['psa_5fsuccess',['PSA_SUCCESS',['../group__error.html#ga4cc859e2c66ca381c7418db3527a65e1',1,'crypto_values.h']]]
-];
diff --git a/docs/html/search/all_9.html b/docs/html/search/all_9.html
deleted file mode 100644
index c8c5102..0000000
--- a/docs/html/search/all_9.html
+++ /dev/null
@@ -1,26 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html><head><title></title>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<link rel="stylesheet" type="text/css" href="search.css"/>
-<script type="text/javascript" src="all_9.js"></script>
-<script type="text/javascript" src="search.js"></script>
-</head>
-<body class="SRPage">
-<div id="SRIndex">
-<div class="SRStatus" id="Loading">Loading...</div>
-<div id="SRResults"></div>
-<script type="text/javascript"><!--
-createResults();
---></script>
-<div class="SRStatus" id="Searching">Searching...</div>
-<div class="SRStatus" id="NoMatches">No Matches</div>
-<script type="text/javascript"><!--
-document.getElementById("Loading").style.display="none";
-document.getElementById("NoMatches").style.display="none";
-var searchResults = new SearchResults("searchResults");
-searchResults.Search();
---></script>
-</div>
-</body>
-</html>
diff --git a/docs/html/search/all_9.js b/docs/html/search/all_9.js
deleted file mode 100644
index 2b3e593..0000000
--- a/docs/html/search/all_9.js
+++ /dev/null
@@ -1,4 +0,0 @@
-var searchData=
-[
- ['random_20generation',['Random generation',['../group__random.html',1,'']]]
-];
diff --git a/docs/html/search/all_a.html b/docs/html/search/all_a.html
deleted file mode 100644
index 4cb31f0..0000000
--- a/docs/html/search/all_a.html
+++ /dev/null
@@ -1,26 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html><head><title></title>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<link rel="stylesheet" type="text/css" href="search.css"/>
-<script type="text/javascript" src="all_a.js"></script>
-<script type="text/javascript" src="search.js"></script>
-</head>
-<body class="SRPage">
-<div id="SRIndex">
-<div class="SRStatus" id="Loading">Loading...</div>
-<div id="SRResults"></div>
-<script type="text/javascript"><!--
-createResults();
---></script>
-<div class="SRStatus" id="Searching">Searching...</div>
-<div class="SRStatus" id="NoMatches">No Matches</div>
-<script type="text/javascript"><!--
-document.getElementById("Loading").style.display="none";
-document.getElementById("NoMatches").style.display="none";
-var searchResults = new SearchResults("searchResults");
-searchResults.Search();
---></script>
-</div>
-</body>
-</html>
diff --git a/docs/html/search/all_a.js b/docs/html/search/all_a.js
deleted file mode 100644
index 5161a09..0000000
--- a/docs/html/search/all_a.js
+++ /dev/null
@@ -1,4 +0,0 @@
-var searchData=
-[
- ['symmetric_20ciphers',['Symmetric ciphers',['../group__cipher.html',1,'']]]
-];
diff --git a/docs/html/search/classes_0.html b/docs/html/search/classes_0.html
deleted file mode 100644
index 025587a..0000000
--- a/docs/html/search/classes_0.html
+++ /dev/null
@@ -1,26 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html><head><title></title>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<link rel="stylesheet" type="text/css" href="search.css"/>
-<script type="text/javascript" src="classes_0.js"></script>
-<script type="text/javascript" src="search.js"></script>
-</head>
-<body class="SRPage">
-<div id="SRIndex">
-<div class="SRStatus" id="Loading">Loading...</div>
-<div id="SRResults"></div>
-<script type="text/javascript"><!--
-createResults();
---></script>
-<div class="SRStatus" id="Searching">Searching...</div>
-<div class="SRStatus" id="NoMatches">No Matches</div>
-<script type="text/javascript"><!--
-document.getElementById("Loading").style.display="none";
-document.getElementById("NoMatches").style.display="none";
-var searchResults = new SearchResults("searchResults");
-searchResults.Search();
---></script>
-</div>
-</body>
-</html>
diff --git a/docs/html/search/classes_0.js b/docs/html/search/classes_0.js
deleted file mode 100644
index 1d78234..0000000
--- a/docs/html/search/classes_0.js
+++ /dev/null
@@ -1,4 +0,0 @@
-var searchData=
-[
- ['psa_5fgenerate_5fkey_5fextra_5frsa',['psa_generate_key_extra_rsa',['../structpsa__generate__key__extra__rsa.html',1,'']]]
-];
diff --git a/docs/html/search/close.png b/docs/html/search/close.png
deleted file mode 100644
index 9342d3d..0000000
--- a/docs/html/search/close.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/search/defines_0.html b/docs/html/search/defines_0.html
deleted file mode 100644
index 17cfaa2..0000000
--- a/docs/html/search/defines_0.html
+++ /dev/null
@@ -1,26 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html><head><title></title>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<link rel="stylesheet" type="text/css" href="search.css"/>
-<script type="text/javascript" src="defines_0.js"></script>
-<script type="text/javascript" src="search.js"></script>
-</head>
-<body class="SRPage">
-<div id="SRIndex">
-<div class="SRStatus" id="Loading">Loading...</div>
-<div id="SRResults"></div>
-<script type="text/javascript"><!--
-createResults();
---></script>
-<div class="SRStatus" id="Searching">Searching...</div>
-<div class="SRStatus" id="NoMatches">No Matches</div>
-<script type="text/javascript"><!--
-document.getElementById("Loading").style.display="none";
-document.getElementById("NoMatches").style.display="none";
-var searchResults = new SearchResults("searchResults");
-searchResults.Search();
---></script>
-</div>
-</body>
-</html>
diff --git a/docs/html/search/defines_0.js b/docs/html/search/defines_0.js
deleted file mode 100644
index 81e47ba..0000000
--- a/docs/html/search/defines_0.js
+++ /dev/null
@@ -1,19 +0,0 @@
-var searchData=
-[
- ['psa_5faead_5fdecrypt_5foutput_5fsize',['PSA_AEAD_DECRYPT_OUTPUT_SIZE',['../crypto__sizes_8h.html#a1d057796166c16eb673ad1997e48a60b',1,'crypto_sizes.h']]],
- ['psa_5faead_5fencrypt_5foutput_5fsize',['PSA_AEAD_ENCRYPT_OUTPUT_SIZE',['../crypto__sizes_8h.html#a85667d47a7aa6c7b99a80e5273671266',1,'crypto_sizes.h']]],
- ['psa_5faead_5ffinish_5foutput_5fsize',['PSA_AEAD_FINISH_OUTPUT_SIZE',['../crypto__sizes_8h.html#ab097f6e054f1a73e975d597ade9029a6',1,'crypto_sizes.h']]],
- ['psa_5faead_5ftag_5flength',['PSA_AEAD_TAG_LENGTH',['../crypto__sizes_8h.html#a8e3079b2e624cb8d32b94843cddada49',1,'crypto_sizes.h']]],
- ['psa_5falg_5ftls12_5fpsk_5fto_5fms_5fmax_5fpsk_5flen',['PSA_ALG_TLS12_PSK_TO_MS_MAX_PSK_LEN',['../crypto__sizes_8h.html#ab589ea3b86f2bfa18880459299c58f8a',1,'crypto_sizes.h']]],
- ['psa_5fasymmetric_5fdecrypt_5foutput_5fsize',['PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE',['../crypto__sizes_8h.html#a61a246f3eac41989821d982e56fea6c1',1,'crypto_sizes.h']]],
- ['psa_5fasymmetric_5fencrypt_5foutput_5fsize',['PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE',['../crypto__sizes_8h.html#a66ba3bd93e5ec52870ccc3848778bad8',1,'crypto_sizes.h']]],
- ['psa_5fasymmetric_5fsign_5foutput_5fsize',['PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE',['../crypto__sizes_8h.html#a77565b9b4fe6d8730fd2120f4c8378ab',1,'crypto_sizes.h']]],
- ['psa_5fasymmetric_5fsignature_5fmax_5fsize',['PSA_ASYMMETRIC_SIGNATURE_MAX_SIZE',['../crypto__sizes_8h.html#ad755101764dba14589e5919ee41be7ca',1,'crypto_sizes.h']]],
- ['psa_5fecdsa_5fsignature_5fsize',['PSA_ECDSA_SIGNATURE_SIZE',['../crypto__sizes_8h.html#a10c472a35f04051add6b20cc228ffc11',1,'crypto_sizes.h']]],
- ['psa_5fhash_5fmax_5fsize',['PSA_HASH_MAX_SIZE',['../crypto__sizes_8h.html#a6ce1014efbbc0bcca286ef7f9a72cb29',1,'crypto_sizes.h']]],
- ['psa_5fhash_5fsize',['PSA_HASH_SIZE',['../crypto__sizes_8h.html#aef340331ce3cba2b57e1fc5624bf1f99',1,'crypto_sizes.h']]],
- ['psa_5fkey_5fexport_5fmax_5fsize',['PSA_KEY_EXPORT_MAX_SIZE',['../crypto__sizes_8h.html#a0aae885cc8ff92e00fb5248420b939c3',1,'crypto_sizes.h']]],
- ['psa_5fmac_5ffinal_5fsize',['PSA_MAC_FINAL_SIZE',['../crypto__sizes_8h.html#aa84c5fb384ac7cb1bfc52adde96588ee',1,'crypto_sizes.h']]],
- ['psa_5fmac_5fmax_5fsize',['PSA_MAC_MAX_SIZE',['../crypto__sizes_8h.html#a4681cc4f6226883a2160122c562ca682',1,'crypto_sizes.h']]],
- ['psa_5fmax_5fblock_5fcipher_5fblock_5fsize',['PSA_MAX_BLOCK_CIPHER_BLOCK_SIZE',['../crypto__sizes_8h.html#aa3cfcff0291d6da279fec8fe834d5dec',1,'crypto_sizes.h']]]
-];
diff --git a/docs/html/search/files_0.html b/docs/html/search/files_0.html
deleted file mode 100644
index 0b637cf..0000000
--- a/docs/html/search/files_0.html
+++ /dev/null
@@ -1,26 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html><head><title></title>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<link rel="stylesheet" type="text/css" href="search.css"/>
-<script type="text/javascript" src="files_0.js"></script>
-<script type="text/javascript" src="search.js"></script>
-</head>
-<body class="SRPage">
-<div id="SRIndex">
-<div class="SRStatus" id="Loading">Loading...</div>
-<div id="SRResults"></div>
-<script type="text/javascript"><!--
-createResults();
---></script>
-<div class="SRStatus" id="Searching">Searching...</div>
-<div class="SRStatus" id="NoMatches">No Matches</div>
-<script type="text/javascript"><!--
-document.getElementById("Loading").style.display="none";
-document.getElementById("NoMatches").style.display="none";
-var searchResults = new SearchResults("searchResults");
-searchResults.Search();
---></script>
-</div>
-</body>
-</html>
diff --git a/docs/html/search/files_0.js b/docs/html/search/files_0.js
deleted file mode 100644
index 1f9a5bb..0000000
--- a/docs/html/search/files_0.js
+++ /dev/null
@@ -1,7 +0,0 @@
-var searchData=
-[
- ['crypto_2eh',['crypto.h',['../crypto_8h.html',1,'']]],
- ['crypto_5fsizes_2eh',['crypto_sizes.h',['../crypto__sizes_8h.html',1,'']]],
- ['crypto_5ftypes_2eh',['crypto_types.h',['../crypto__types_8h.html',1,'']]],
- ['crypto_5fvalues_2eh',['crypto_values.h',['../crypto__values_8h.html',1,'']]]
-];
diff --git a/docs/html/search/functions_0.html b/docs/html/search/functions_0.html
deleted file mode 100644
index 6bc52b6..0000000
--- a/docs/html/search/functions_0.html
+++ /dev/null
@@ -1,26 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html><head><title></title>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<link rel="stylesheet" type="text/css" href="search.css"/>
-<script type="text/javascript" src="functions_0.js"></script>
-<script type="text/javascript" src="search.js"></script>
-</head>
-<body class="SRPage">
-<div id="SRIndex">
-<div class="SRStatus" id="Loading">Loading...</div>
-<div id="SRResults"></div>
-<script type="text/javascript"><!--
-createResults();
---></script>
-<div class="SRStatus" id="Searching">Searching...</div>
-<div class="SRStatus" id="NoMatches">No Matches</div>
-<script type="text/javascript"><!--
-document.getElementById("Loading").style.display="none";
-document.getElementById("NoMatches").style.display="none";
-var searchResults = new SearchResults("searchResults");
-searchResults.Search();
---></script>
-</div>
-</body>
-</html>
diff --git a/docs/html/search/functions_0.js b/docs/html/search/functions_0.js
deleted file mode 100644
index cc5b60d..0000000
--- a/docs/html/search/functions_0.js
+++ /dev/null
@@ -1,75 +0,0 @@
-var searchData=
-[
- ['psa_5faead_5fabort',['psa_aead_abort',['../group__aead.html#gae8a5f93d92318c8f592ee9fbb9d36ba0',1,'crypto.h']]],
- ['psa_5faead_5fdecrypt',['psa_aead_decrypt',['../group__aead.html#gaa8ce6527f2e227f1071fadbf2099793b',1,'crypto.h']]],
- ['psa_5faead_5fdecrypt_5fsetup',['psa_aead_decrypt_setup',['../group__aead.html#ga439896519d4a367ec86b47f201884152',1,'crypto.h']]],
- ['psa_5faead_5fencrypt',['psa_aead_encrypt',['../group__aead.html#ga44de092cf58bb6c820c5c80a6c51610d',1,'crypto.h']]],
- ['psa_5faead_5fencrypt_5fsetup',['psa_aead_encrypt_setup',['../group__aead.html#ga47265dc4852f1476f852752218fd12b2',1,'crypto.h']]],
- ['psa_5faead_5ffinish',['psa_aead_finish',['../group__aead.html#ga759791bbe1763b377c3b5447641f1fc8',1,'crypto.h']]],
- ['psa_5faead_5fgenerate_5fnonce',['psa_aead_generate_nonce',['../group__aead.html#ga3eadcf2a29f662129ea4fb3454969ba2',1,'crypto.h']]],
- ['psa_5faead_5fset_5flengths',['psa_aead_set_lengths',['../group__aead.html#gad3431e28d05002c2a7b0760610176050',1,'crypto.h']]],
- ['psa_5faead_5fset_5fnonce',['psa_aead_set_nonce',['../group__aead.html#ga40641d0721ca7fe01bbcd9ef635fbc46',1,'crypto.h']]],
- ['psa_5faead_5fupdate',['psa_aead_update',['../group__aead.html#ga3b105de2088cef7c3d9e2fd8048c841c',1,'crypto.h']]],
- ['psa_5faead_5fupdate_5fad',['psa_aead_update_ad',['../group__aead.html#ga6d0eed03f832e5c9c91cb8adf2882569',1,'crypto.h']]],
- ['psa_5faead_5fverify',['psa_aead_verify',['../group__aead.html#gaaed211fc61977c859d6ff07f39f59219',1,'crypto.h']]],
- ['psa_5fallocate_5fkey',['psa_allocate_key',['../group__key__management.html#ga40094b77b7a42b9c8e158395113f1a35',1,'crypto.h']]],
- ['psa_5fasymmetric_5fdecrypt',['psa_asymmetric_decrypt',['../group__asymmetric.html#ga34b55fbaee23dba1a677186fc66a556e',1,'crypto.h']]],
- ['psa_5fasymmetric_5fencrypt',['psa_asymmetric_encrypt',['../group__asymmetric.html#gad429293b7b0bf2a830b9540a02552004',1,'crypto.h']]],
- ['psa_5fasymmetric_5fsign',['psa_asymmetric_sign',['../group__asymmetric.html#ga1b0db9d345b5048cdd39357ac2d56c07',1,'crypto.h']]],
- ['psa_5fasymmetric_5fverify',['psa_asymmetric_verify',['../group__asymmetric.html#ga1b8e964c8d927e3d632325d762959eb7',1,'crypto.h']]],
- ['psa_5fcipher_5fabort',['psa_cipher_abort',['../group__cipher.html#gaad482cdca2098bca0620596aaa02eaa4',1,'crypto.h']]],
- ['psa_5fcipher_5fdecrypt',['psa_cipher_decrypt',['../group__cipher.html#ga43d5991711ec45c98af0c1d99f6e0216',1,'crypto.h']]],
- ['psa_5fcipher_5fdecrypt_5fsetup',['psa_cipher_decrypt_setup',['../group__cipher.html#gaddf8504e5367cd0efb4415bdec004f44',1,'crypto.h']]],
- ['psa_5fcipher_5fencrypt',['psa_cipher_encrypt',['../group__cipher.html#gac76dda492d9a1ba6b327bff610ec17b2',1,'crypto.h']]],
- ['psa_5fcipher_5fencrypt_5fsetup',['psa_cipher_encrypt_setup',['../group__cipher.html#ga2a7fc79a9d150d42dba99f40ee3a185e',1,'crypto.h']]],
- ['psa_5fcipher_5ffinish',['psa_cipher_finish',['../group__cipher.html#ga1dcb58b8befe23f8a4d7a1d49c99249b',1,'crypto.h']]],
- ['psa_5fcipher_5fgenerate_5fiv',['psa_cipher_generate_iv',['../group__cipher.html#ga44857cf5e0c3d134a3c560f8ff5b50aa',1,'crypto.h']]],
- ['psa_5fcipher_5fset_5fiv',['psa_cipher_set_iv',['../group__cipher.html#ga1359b2101f31637496ce7cc36c6e3d42',1,'crypto.h']]],
- ['psa_5fcipher_5fupdate',['psa_cipher_update',['../group__cipher.html#gafd0caea99cf1052527e4089d37f5ab91',1,'crypto.h']]],
- ['psa_5fclose_5fkey',['psa_close_key',['../group__key__management.html#gaa09b720d299dfe6b9f41c36e448078eb',1,'crypto.h']]],
- ['psa_5fcopy_5fkey',['psa_copy_key',['../group__import__export.html#ga5c1c24176cfb1517a8806235b3162a9d',1,'crypto.h']]],
- ['psa_5fcreate_5fkey',['psa_create_key',['../group__key__management.html#ga4108f255d3eaa6d23a7a14b684af8d7c',1,'crypto.h']]],
- ['psa_5fcrypto_5finit',['psa_crypto_init',['../group__initialization.html#ga2de150803fc2f7dc6101d5af7e921dd9',1,'crypto.h']]],
- ['psa_5fdestroy_5fkey',['psa_destroy_key',['../group__import__export.html#ga165085fc1bc7a78b91792fdd94ae102c',1,'crypto.h']]],
- ['psa_5fexport_5fkey',['psa_export_key',['../group__import__export.html#ga902b9a7a6cf34d6111668be777b05eaf',1,'crypto.h']]],
- ['psa_5fexport_5fpublic_5fkey',['psa_export_public_key',['../group__import__export.html#gad760d1f0d4e60972c78cbb4c8a528256',1,'crypto.h']]],
- ['psa_5fgenerate_5fkey',['psa_generate_key',['../group__random.html#ga72921520494b4f007a3afb904cd9ecdd',1,'crypto.h']]],
- ['psa_5fgenerate_5frandom',['psa_generate_random',['../group__random.html#ga1985eae417dfbccedf50d5fff54ea8c5',1,'crypto.h']]],
- ['psa_5fgenerator_5fabort',['psa_generator_abort',['../group__generators.html#ga563ca64537d90368899286b36d8cf7f3',1,'crypto.h']]],
- ['psa_5fgenerator_5fimport_5fkey',['psa_generator_import_key',['../group__generators.html#ga7fcdf07cd37279ca167db484053da894',1,'crypto.h']]],
- ['psa_5fgenerator_5fread',['psa_generator_read',['../group__generators.html#gab5712ad29b78c2b170e64cc5bcfc1bce',1,'crypto.h']]],
- ['psa_5fget_5fgenerator_5fcapacity',['psa_get_generator_capacity',['../group__generators.html#ga7453491e3b440193be2c5dccc2040fd2',1,'crypto.h']]],
- ['psa_5fget_5fkey_5fdomain_5fparameters',['psa_get_key_domain_parameters',['../group__import__export.html#gae260b92e32ac5d63f7dfc6ffdf6536f7',1,'crypto.h']]],
- ['psa_5fget_5fkey_5finformation',['psa_get_key_information',['../group__import__export.html#gae8939902d6977ea8ad13eb7b4db9a042',1,'crypto.h']]],
- ['psa_5fget_5fkey_5flifetime',['psa_get_key_lifetime',['../group__key__management.html#ga1e4825ab59260aeb3bdbb3ff07210022',1,'crypto.h']]],
- ['psa_5fget_5fkey_5fpolicy',['psa_get_key_policy',['../group__policy.html#gaed087d1386b807edee66b2e445ba9111',1,'crypto.h']]],
- ['psa_5fhash_5fabort',['psa_hash_abort',['../group__hash.html#gab0b4d5f9912a615559497a467b532928',1,'crypto.h']]],
- ['psa_5fhash_5fclone',['psa_hash_clone',['../group__hash.html#ga39673348f3302b4646bd780034a5aeda',1,'crypto.h']]],
- ['psa_5fhash_5fcompare',['psa_hash_compare',['../group__hash.html#ga0bb6dbd3c310648c3cf7d202413ff0bc',1,'crypto.h']]],
- ['psa_5fhash_5fcompute',['psa_hash_compute',['../group__hash.html#gac69f7f19d96a56c28cf3799d11b12156',1,'crypto.h']]],
- ['psa_5fhash_5ffinish',['psa_hash_finish',['../group__hash.html#ga4795fd06a0067b0adcd92e9627b8c97e',1,'crypto.h']]],
- ['psa_5fhash_5fsetup',['psa_hash_setup',['../group__hash.html#ga8d72896cf70fc4d514c5c6b978912515',1,'crypto.h']]],
- ['psa_5fhash_5fupdate',['psa_hash_update',['../group__hash.html#ga65b16ef97d7f650899b7db4b7d1112ff',1,'crypto.h']]],
- ['psa_5fhash_5fverify',['psa_hash_verify',['../group__hash.html#ga7be923c5700c9c70ef77ee9b76d1a5c0',1,'crypto.h']]],
- ['psa_5fimport_5fkey',['psa_import_key',['../group__import__export.html#gac9f999cb4d098663d56095afe81a453a',1,'crypto.h']]],
- ['psa_5fkey_5fagreement',['psa_key_agreement',['../group__derivation.html#ga2c7fe304cacc141ffb91553548abc5d2',1,'crypto.h']]],
- ['psa_5fkey_5fagreement_5fraw_5fshared_5fsecret',['psa_key_agreement_raw_shared_secret',['../group__derivation.html#gaf1b12eff66a1a0020b5bdc8d0e910006',1,'crypto.h']]],
- ['psa_5fkey_5fderivation_5finput_5fbytes',['psa_key_derivation_input_bytes',['../group__derivation.html#ga1b30e888db65c71f5337900848e1b03f',1,'crypto.h']]],
- ['psa_5fkey_5fderivation_5finput_5fkey',['psa_key_derivation_input_key',['../group__derivation.html#ga9e5f549aa1f6f3863a07008d3d98f91a',1,'crypto.h']]],
- ['psa_5fkey_5fderivation_5fsetup',['psa_key_derivation_setup',['../group__derivation.html#ga1825696be813dfac2b8d3d02717e71c5',1,'crypto.h']]],
- ['psa_5fkey_5fpolicy_5fget_5falgorithm',['psa_key_policy_get_algorithm',['../group__policy.html#gaadf16b89ace53e1d2cb5bcb0aef24c86',1,'crypto.h']]],
- ['psa_5fkey_5fpolicy_5fget_5fusage',['psa_key_policy_get_usage',['../group__policy.html#ga7746662b7503e484774d0ecb5d8ac2ab',1,'crypto.h']]],
- ['psa_5fkey_5fpolicy_5fset_5fusage',['psa_key_policy_set_usage',['../group__policy.html#gac16792fd6d375a5f76d372090df40607',1,'crypto.h']]],
- ['psa_5fmac_5fabort',['psa_mac_abort',['../group__MAC.html#gacd8dd54855ba1bc0a03f104f252884fd',1,'crypto.h']]],
- ['psa_5fmac_5fcompute',['psa_mac_compute',['../group__MAC.html#gace78d9b51394f9d4f77952963665897a',1,'crypto.h']]],
- ['psa_5fmac_5fsign_5ffinish',['psa_mac_sign_finish',['../group__MAC.html#gac22bc0125580c96724a09226cfbc97f2',1,'crypto.h']]],
- ['psa_5fmac_5fsign_5fsetup',['psa_mac_sign_setup',['../group__MAC.html#gad33f2b15119593571ca6b8e7c757ab0e',1,'crypto.h']]],
- ['psa_5fmac_5fupdate',['psa_mac_update',['../group__MAC.html#ga5560af371497babefe03c9da4e8a1c05',1,'crypto.h']]],
- ['psa_5fmac_5fverify',['psa_mac_verify',['../group__MAC.html#ga08e2e8c21bfe762a907266f3bdd1d07c',1,'crypto.h']]],
- ['psa_5fmac_5fverify_5ffinish',['psa_mac_verify_finish',['../group__MAC.html#gac92b2930d6728e1be4d011c05d485822',1,'crypto.h']]],
- ['psa_5fmac_5fverify_5fsetup',['psa_mac_verify_setup',['../group__MAC.html#gaa721a59ae6d085ec90c7dc918879a027',1,'crypto.h']]],
- ['psa_5fopen_5fkey',['psa_open_key',['../group__key__management.html#gaa9f1c848cf78b80fe2a7b18bb7ccec50',1,'crypto.h']]],
- ['psa_5fset_5fgenerator_5fcapacity',['psa_set_generator_capacity',['../group__generators.html#ga45676ec3c719622f95caaf926f44bb6e',1,'crypto.h']]],
- ['psa_5fset_5fkey_5fdomain_5fparameters',['psa_set_key_domain_parameters',['../group__import__export.html#ga091da8d3d39137fd6ad59f2b10234300',1,'crypto.h']]],
- ['psa_5fset_5fkey_5fpolicy',['psa_set_key_policy',['../group__policy.html#ga1e2a6e50b621864f95d438222a3c640b',1,'crypto.h']]]
-];
diff --git a/docs/html/search/groups_0.html b/docs/html/search/groups_0.html
deleted file mode 100644
index 95cee43..0000000
--- a/docs/html/search/groups_0.html
+++ /dev/null
@@ -1,26 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html><head><title></title>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<link rel="stylesheet" type="text/css" href="search.css"/>
-<script type="text/javascript" src="groups_0.js"></script>
-<script type="text/javascript" src="search.js"></script>
-</head>
-<body class="SRPage">
-<div id="SRIndex">
-<div class="SRStatus" id="Loading">Loading...</div>
-<div id="SRResults"></div>
-<script type="text/javascript"><!--
-createResults();
---></script>
-<div class="SRStatus" id="Searching">Searching...</div>
-<div class="SRStatus" id="NoMatches">No Matches</div>
-<script type="text/javascript"><!--
-document.getElementById("Loading").style.display="none";
-document.getElementById("NoMatches").style.display="none";
-var searchResults = new SearchResults("searchResults");
-searchResults.Search();
---></script>
-</div>
-</body>
-</html>
diff --git a/docs/html/search/groups_0.js b/docs/html/search/groups_0.js
deleted file mode 100644
index 9e9cdcb..0000000
--- a/docs/html/search/groups_0.js
+++ /dev/null
@@ -1,5 +0,0 @@
-var searchData=
-[
- ['authenticated_20encryption_20with_20associated_20data_20_28aead_29',['Authenticated encryption with associated data (AEAD)',['../group__aead.html',1,'']]],
- ['asymmetric_20cryptography',['Asymmetric cryptography',['../group__asymmetric.html',1,'']]]
-];
diff --git a/docs/html/search/groups_1.html b/docs/html/search/groups_1.html
deleted file mode 100644
index 979ea3d..0000000
--- a/docs/html/search/groups_1.html
+++ /dev/null
@@ -1,26 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html><head><title></title>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<link rel="stylesheet" type="text/css" href="search.css"/>
-<script type="text/javascript" src="groups_1.js"></script>
-<script type="text/javascript" src="search.js"></script>
-</head>
-<body class="SRPage">
-<div id="SRIndex">
-<div class="SRStatus" id="Loading">Loading...</div>
-<div id="SRResults"></div>
-<script type="text/javascript"><!--
-createResults();
---></script>
-<div class="SRStatus" id="Searching">Searching...</div>
-<div class="SRStatus" id="NoMatches">No Matches</div>
-<script type="text/javascript"><!--
-document.getElementById("Loading").style.display="none";
-document.getElementById("NoMatches").style.display="none";
-var searchResults = new SearchResults("searchResults");
-searchResults.Search();
---></script>
-</div>
-</body>
-</html>
diff --git a/docs/html/search/groups_1.js b/docs/html/search/groups_1.js
deleted file mode 100644
index 4ab58fc..0000000
--- a/docs/html/search/groups_1.js
+++ /dev/null
@@ -1,4 +0,0 @@
-var searchData=
-[
- ['error_20codes',['Error codes',['../group__error.html',1,'']]]
-];
diff --git a/docs/html/search/groups_2.html b/docs/html/search/groups_2.html
deleted file mode 100644
index 310ab32..0000000
--- a/docs/html/search/groups_2.html
+++ /dev/null
@@ -1,26 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html><head><title></title>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<link rel="stylesheet" type="text/css" href="search.css"/>
-<script type="text/javascript" src="groups_2.js"></script>
-<script type="text/javascript" src="search.js"></script>
-</head>
-<body class="SRPage">
-<div id="SRIndex">
-<div class="SRStatus" id="Loading">Loading...</div>
-<div id="SRResults"></div>
-<script type="text/javascript"><!--
-createResults();
---></script>
-<div class="SRStatus" id="Searching">Searching...</div>
-<div class="SRStatus" id="NoMatches">No Matches</div>
-<script type="text/javascript"><!--
-document.getElementById("Loading").style.display="none";
-document.getElementById("NoMatches").style.display="none";
-var searchResults = new SearchResults("searchResults");
-searchResults.Search();
---></script>
-</div>
-</body>
-</html>
diff --git a/docs/html/search/groups_2.js b/docs/html/search/groups_2.js
deleted file mode 100644
index bb51584..0000000
--- a/docs/html/search/groups_2.js
+++ /dev/null
@@ -1,4 +0,0 @@
-var searchData=
-[
- ['generators',['Generators',['../group__generators.html',1,'']]]
-];
diff --git a/docs/html/search/groups_3.html b/docs/html/search/groups_3.html
deleted file mode 100644
index c24c7bd..0000000
--- a/docs/html/search/groups_3.html
+++ /dev/null
@@ -1,26 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html><head><title></title>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<link rel="stylesheet" type="text/css" href="search.css"/>
-<script type="text/javascript" src="groups_3.js"></script>
-<script type="text/javascript" src="search.js"></script>
-</head>
-<body class="SRPage">
-<div id="SRIndex">
-<div class="SRStatus" id="Loading">Loading...</div>
-<div id="SRResults"></div>
-<script type="text/javascript"><!--
-createResults();
---></script>
-<div class="SRStatus" id="Searching">Searching...</div>
-<div class="SRStatus" id="NoMatches">No Matches</div>
-<script type="text/javascript"><!--
-document.getElementById("Loading").style.display="none";
-document.getElementById("NoMatches").style.display="none";
-var searchResults = new SearchResults("searchResults");
-searchResults.Search();
---></script>
-</div>
-</body>
-</html>
diff --git a/docs/html/search/groups_3.js b/docs/html/search/groups_3.js
deleted file mode 100644
index f48be25..0000000
--- a/docs/html/search/groups_3.js
+++ /dev/null
@@ -1,4 +0,0 @@
-var searchData=
-[
- ['implementation_2dspecific_20definitions',['Implementation-specific definitions',['../group__platform.html',1,'']]]
-];
diff --git a/docs/html/search/groups_4.html b/docs/html/search/groups_4.html
deleted file mode 100644
index a1f3533..0000000
--- a/docs/html/search/groups_4.html
+++ /dev/null
@@ -1,26 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html><head><title></title>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<link rel="stylesheet" type="text/css" href="search.css"/>
-<script type="text/javascript" src="groups_4.js"></script>
-<script type="text/javascript" src="search.js"></script>
-</head>
-<body class="SRPage">
-<div id="SRIndex">
-<div class="SRStatus" id="Loading">Loading...</div>
-<div id="SRResults"></div>
-<script type="text/javascript"><!--
-createResults();
---></script>
-<div class="SRStatus" id="Searching">Searching...</div>
-<div class="SRStatus" id="NoMatches">No Matches</div>
-<script type="text/javascript"><!--
-document.getElementById("Loading").style.display="none";
-document.getElementById("NoMatches").style.display="none";
-var searchResults = new SearchResults("searchResults");
-searchResults.Search();
---></script>
-</div>
-</body>
-</html>
diff --git a/docs/html/search/groups_4.js b/docs/html/search/groups_4.js
deleted file mode 100644
index 489c5ec..0000000
--- a/docs/html/search/groups_4.js
+++ /dev/null
@@ -1,9 +0,0 @@
-var searchData=
-[
- ['key_20and_20algorithm_20types',['Key and algorithm types',['../group__crypto__types.html',1,'']]],
- ['key_20derivation',['Key derivation',['../group__derivation.html',1,'']]],
- ['key_20import_20and_20export',['Key import and export',['../group__import__export.html',1,'']]],
- ['key_20lifetimes',['Key lifetimes',['../group__key__lifetimes.html',1,'']]],
- ['key_20management',['Key management',['../group__key__management.html',1,'']]],
- ['key_20policies',['Key policies',['../group__policy.html',1,'']]]
-];
diff --git a/docs/html/search/groups_5.html b/docs/html/search/groups_5.html
deleted file mode 100644
index 938507d..0000000
--- a/docs/html/search/groups_5.html
+++ /dev/null
@@ -1,26 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html><head><title></title>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<link rel="stylesheet" type="text/css" href="search.css"/>
-<script type="text/javascript" src="groups_5.js"></script>
-<script type="text/javascript" src="search.js"></script>
-</head>
-<body class="SRPage">
-<div id="SRIndex">
-<div class="SRStatus" id="Loading">Loading...</div>
-<div id="SRResults"></div>
-<script type="text/javascript"><!--
-createResults();
---></script>
-<div class="SRStatus" id="Searching">Searching...</div>
-<div class="SRStatus" id="NoMatches">No Matches</div>
-<script type="text/javascript"><!--
-document.getElementById("Loading").style.display="none";
-document.getElementById("NoMatches").style.display="none";
-var searchResults = new SearchResults("searchResults");
-searchResults.Search();
---></script>
-</div>
-</body>
-</html>
diff --git a/docs/html/search/groups_5.js b/docs/html/search/groups_5.js
deleted file mode 100644
index c72a68d..0000000
--- a/docs/html/search/groups_5.js
+++ /dev/null
@@ -1,4 +0,0 @@
-var searchData=
-[
- ['library_20initialization',['Library initialization',['../group__initialization.html',1,'']]]
-];
diff --git a/docs/html/search/groups_6.html b/docs/html/search/groups_6.html
deleted file mode 100644
index e675e85..0000000
--- a/docs/html/search/groups_6.html
+++ /dev/null
@@ -1,26 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html><head><title></title>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<link rel="stylesheet" type="text/css" href="search.css"/>
-<script type="text/javascript" src="groups_6.js"></script>
-<script type="text/javascript" src="search.js"></script>
-</head>
-<body class="SRPage">
-<div id="SRIndex">
-<div class="SRStatus" id="Loading">Loading...</div>
-<div id="SRResults"></div>
-<script type="text/javascript"><!--
-createResults();
---></script>
-<div class="SRStatus" id="Searching">Searching...</div>
-<div class="SRStatus" id="NoMatches">No Matches</div>
-<script type="text/javascript"><!--
-document.getElementById("Loading").style.display="none";
-document.getElementById("NoMatches").style.display="none";
-var searchResults = new SearchResults("searchResults");
-searchResults.Search();
---></script>
-</div>
-</body>
-</html>
diff --git a/docs/html/search/groups_6.js b/docs/html/search/groups_6.js
deleted file mode 100644
index 6efdddb..0000000
--- a/docs/html/search/groups_6.js
+++ /dev/null
@@ -1,5 +0,0 @@
-var searchData=
-[
- ['message_20digests',['Message digests',['../group__hash.html',1,'']]],
- ['message_20authentication_20codes',['Message authentication codes',['../group__MAC.html',1,'']]]
-];
diff --git a/docs/html/search/groups_7.html b/docs/html/search/groups_7.html
deleted file mode 100644
index c974917..0000000
--- a/docs/html/search/groups_7.html
+++ /dev/null
@@ -1,26 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html><head><title></title>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<link rel="stylesheet" type="text/css" href="search.css"/>
-<script type="text/javascript" src="groups_7.js"></script>
-<script type="text/javascript" src="search.js"></script>
-</head>
-<body class="SRPage">
-<div id="SRIndex">
-<div class="SRStatus" id="Loading">Loading...</div>
-<div id="SRResults"></div>
-<script type="text/javascript"><!--
-createResults();
---></script>
-<div class="SRStatus" id="Searching">Searching...</div>
-<div class="SRStatus" id="NoMatches">No Matches</div>
-<script type="text/javascript"><!--
-document.getElementById("Loading").style.display="none";
-document.getElementById("NoMatches").style.display="none";
-var searchResults = new SearchResults("searchResults");
-searchResults.Search();
---></script>
-</div>
-</body>
-</html>
diff --git a/docs/html/search/groups_7.js b/docs/html/search/groups_7.js
deleted file mode 100644
index 2b3e593..0000000
--- a/docs/html/search/groups_7.js
+++ /dev/null
@@ -1,4 +0,0 @@
-var searchData=
-[
- ['random_20generation',['Random generation',['../group__random.html',1,'']]]
-];
diff --git a/docs/html/search/groups_8.html b/docs/html/search/groups_8.html
deleted file mode 100644
index 863b2f7..0000000
--- a/docs/html/search/groups_8.html
+++ /dev/null
@@ -1,26 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html><head><title></title>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<link rel="stylesheet" type="text/css" href="search.css"/>
-<script type="text/javascript" src="groups_8.js"></script>
-<script type="text/javascript" src="search.js"></script>
-</head>
-<body class="SRPage">
-<div id="SRIndex">
-<div class="SRStatus" id="Loading">Loading...</div>
-<div id="SRResults"></div>
-<script type="text/javascript"><!--
-createResults();
---></script>
-<div class="SRStatus" id="Searching">Searching...</div>
-<div class="SRStatus" id="NoMatches">No Matches</div>
-<script type="text/javascript"><!--
-document.getElementById("Loading").style.display="none";
-document.getElementById("NoMatches").style.display="none";
-var searchResults = new SearchResults("searchResults");
-searchResults.Search();
---></script>
-</div>
-</body>
-</html>
diff --git a/docs/html/search/groups_8.js b/docs/html/search/groups_8.js
deleted file mode 100644
index 5161a09..0000000
--- a/docs/html/search/groups_8.js
+++ /dev/null
@@ -1,4 +0,0 @@
-var searchData=
-[
- ['symmetric_20ciphers',['Symmetric ciphers',['../group__cipher.html',1,'']]]
-];
diff --git a/docs/html/search/mag_sel.png b/docs/html/search/mag_sel.png
deleted file mode 100644
index 81f6040..0000000
--- a/docs/html/search/mag_sel.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/search/nomatches.html b/docs/html/search/nomatches.html
deleted file mode 100644
index b1ded27..0000000
--- a/docs/html/search/nomatches.html
+++ /dev/null
@@ -1,12 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html><head><title></title>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<link rel="stylesheet" type="text/css" href="search.css"/>
-<script type="text/javascript" src="search.js"></script>
-</head>
-<body class="SRPage">
-<div id="SRIndex">
-<div class="SRStatus" id="NoMatches">No Matches</div>
-</div>
-</body>
-</html>
diff --git a/docs/html/search/search.css b/docs/html/search/search.css
deleted file mode 100644
index 4d7612f..0000000
--- a/docs/html/search/search.css
+++ /dev/null
@@ -1,271 +0,0 @@
-/*---------------- Search Box */
-
-#FSearchBox {
- float: left;
-}
-
-#MSearchBox {
- white-space : nowrap;
- position: absolute;
- float: none;
- display: inline;
- margin-top: 8px;
- right: 0px;
- width: 170px;
- z-index: 102;
- background-color: white;
-}
-
-#MSearchBox .left
-{
- display:block;
- position:absolute;
- left:10px;
- width:20px;
- height:19px;
- background:url('search_l.png') no-repeat;
- background-position:right;
-}
-
-#MSearchSelect {
- display:block;
- position:absolute;
- width:20px;
- height:19px;
-}
-
-.left #MSearchSelect {
- left:4px;
-}
-
-.right #MSearchSelect {
- right:5px;
-}
-
-#MSearchField {
- display:block;
- position:absolute;
- height:19px;
- background:url('search_m.png') repeat-x;
- border:none;
- width:111px;
- margin-left:20px;
- padding-left:4px;
- color: #909090;
- outline: none;
- font: 9pt Arial, Verdana, sans-serif;
-}
-
-#FSearchBox #MSearchField {
- margin-left:15px;
-}
-
-#MSearchBox .right {
- display:block;
- position:absolute;
- right:10px;
- top:0px;
- width:20px;
- height:19px;
- background:url('search_r.png') no-repeat;
- background-position:left;
-}
-
-#MSearchClose {
- display: none;
- position: absolute;
- top: 4px;
- background : none;
- border: none;
- margin: 0px 4px 0px 0px;
- padding: 0px 0px;
- outline: none;
-}
-
-.left #MSearchClose {
- left: 6px;
-}
-
-.right #MSearchClose {
- right: 2px;
-}
-
-.MSearchBoxActive #MSearchField {
- color: #000000;
-}
-
-/*---------------- Search filter selection */
-
-#MSearchSelectWindow {
- display: none;
- position: absolute;
- left: 0; top: 0;
- border: 1px solid #90A5CE;
- background-color: #F9FAFC;
- z-index: 1;
- padding-top: 4px;
- padding-bottom: 4px;
- -moz-border-radius: 4px;
- -webkit-border-top-left-radius: 4px;
- -webkit-border-top-right-radius: 4px;
- -webkit-border-bottom-left-radius: 4px;
- -webkit-border-bottom-right-radius: 4px;
- -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
-}
-
-.SelectItem {
- font: 8pt Arial, Verdana, sans-serif;
- padding-left: 2px;
- padding-right: 12px;
- border: 0px;
-}
-
-span.SelectionMark {
- margin-right: 4px;
- font-family: monospace;
- outline-style: none;
- text-decoration: none;
-}
-
-a.SelectItem {
- display: block;
- outline-style: none;
- color: #000000;
- text-decoration: none;
- padding-left: 6px;
- padding-right: 12px;
-}
-
-a.SelectItem:focus,
-a.SelectItem:active {
- color: #000000;
- outline-style: none;
- text-decoration: none;
-}
-
-a.SelectItem:hover {
- color: #FFFFFF;
- background-color: #3D578C;
- outline-style: none;
- text-decoration: none;
- cursor: pointer;
- display: block;
-}
-
-/*---------------- Search results window */
-
-iframe#MSearchResults {
- width: 60ex;
- height: 15em;
-}
-
-#MSearchResultsWindow {
- display: none;
- position: absolute;
- left: 0; top: 0;
- border: 1px solid #000;
- background-color: #EEF1F7;
-}
-
-/* ----------------------------------- */
-
-
-#SRIndex {
- clear:both;
- padding-bottom: 15px;
-}
-
-.SREntry {
- font-size: 10pt;
- padding-left: 1ex;
-}
-
-.SRPage .SREntry {
- font-size: 8pt;
- padding: 1px 5px;
-}
-
-body.SRPage {
- margin: 5px 2px;
-}
-
-.SRChildren {
- padding-left: 3ex; padding-bottom: .5em
-}
-
-.SRPage .SRChildren {
- display: none;
-}
-
-.SRSymbol {
- font-weight: bold;
- color: #425E97;
- font-family: Arial, Verdana, sans-serif;
- text-decoration: none;
- outline: none;
-}
-
-a.SRScope {
- display: block;
- color: #425E97;
- font-family: Arial, Verdana, sans-serif;
- text-decoration: none;
- outline: none;
-}
-
-a.SRSymbol:focus, a.SRSymbol:active,
-a.SRScope:focus, a.SRScope:active {
- text-decoration: underline;
-}
-
-span.SRScope {
- padding-left: 4px;
-}
-
-.SRPage .SRStatus {
- padding: 2px 5px;
- font-size: 8pt;
- font-style: italic;
-}
-
-.SRResult {
- display: none;
-}
-
-DIV.searchresults {
- margin-left: 10px;
- margin-right: 10px;
-}
-
-/*---------------- External search page results */
-
-.searchresult {
- background-color: #F0F3F8;
-}
-
-.pages b {
- color: white;
- padding: 5px 5px 3px 5px;
- background-image: url("../tab_a.png");
- background-repeat: repeat-x;
- text-shadow: 0 1px 1px #000000;
-}
-
-.pages {
- line-height: 17px;
- margin-left: 4px;
- text-decoration: none;
-}
-
-.hl {
- font-weight: bold;
-}
-
-#searchresults {
- margin-bottom: 20px;
-}
-
-.searchpages {
- margin-top: 10px;
-}
-
diff --git a/docs/html/search/search.js b/docs/html/search/search.js
deleted file mode 100644
index dedce3b..0000000
--- a/docs/html/search/search.js
+++ /dev/null
@@ -1,791 +0,0 @@
-function convertToId(search)
-{
- var result = '';
- for (i=0;i<search.length;i++)
- {
- var c = search.charAt(i);
- var cn = c.charCodeAt(0);
- if (c.match(/[a-z0-9\u0080-\uFFFF]/))
- {
- result+=c;
- }
- else if (cn<16)
- {
- result+="_0"+cn.toString(16);
- }
- else
- {
- result+="_"+cn.toString(16);
- }
- }
- return result;
-}
-
-function getXPos(item)
-{
- var x = 0;
- if (item.offsetWidth)
- {
- while (item && item!=document.body)
- {
- x += item.offsetLeft;
- item = item.offsetParent;
- }
- }
- return x;
-}
-
-function getYPos(item)
-{
- var y = 0;
- if (item.offsetWidth)
- {
- while (item && item!=document.body)
- {
- y += item.offsetTop;
- item = item.offsetParent;
- }
- }
- return y;
-}
-
-/* A class handling everything associated with the search panel.
-
- Parameters:
- name - The name of the global variable that will be
- storing this instance. Is needed to be able to set timeouts.
- resultPath - path to use for external files
-*/
-function SearchBox(name, resultsPath, inFrame, label)
-{
- if (!name || !resultsPath) { alert("Missing parameters to SearchBox."); }
-
- // ---------- Instance variables
- this.name = name;
- this.resultsPath = resultsPath;
- this.keyTimeout = 0;
- this.keyTimeoutLength = 500;
- this.closeSelectionTimeout = 300;
- this.lastSearchValue = "";
- this.lastResultsPage = "";
- this.hideTimeout = 0;
- this.searchIndex = 0;
- this.searchActive = false;
- this.insideFrame = inFrame;
- this.searchLabel = label;
-
- // ----------- DOM Elements
-
- this.DOMSearchField = function()
- { return document.getElementById("MSearchField"); }
-
- this.DOMSearchSelect = function()
- { return document.getElementById("MSearchSelect"); }
-
- this.DOMSearchSelectWindow = function()
- { return document.getElementById("MSearchSelectWindow"); }
-
- this.DOMPopupSearchResults = function()
- { return document.getElementById("MSearchResults"); }
-
- this.DOMPopupSearchResultsWindow = function()
- { return document.getElementById("MSearchResultsWindow"); }
-
- this.DOMSearchClose = function()
- { return document.getElementById("MSearchClose"); }
-
- this.DOMSearchBox = function()
- { return document.getElementById("MSearchBox"); }
-
- // ------------ Event Handlers
-
- // Called when focus is added or removed from the search field.
- this.OnSearchFieldFocus = function(isActive)
- {
- this.Activate(isActive);
- }
-
- this.OnSearchSelectShow = function()
- {
- var searchSelectWindow = this.DOMSearchSelectWindow();
- var searchField = this.DOMSearchSelect();
-
- if (this.insideFrame)
- {
- var left = getXPos(searchField);
- var top = getYPos(searchField);
- left += searchField.offsetWidth + 6;
- top += searchField.offsetHeight;
-
- // show search selection popup
- searchSelectWindow.style.display='block';
- left -= searchSelectWindow.offsetWidth;
- searchSelectWindow.style.left = left + 'px';
- searchSelectWindow.style.top = top + 'px';
- }
- else
- {
- var left = getXPos(searchField);
- var top = getYPos(searchField);
- top += searchField.offsetHeight;
-
- // show search selection popup
- searchSelectWindow.style.display='block';
- searchSelectWindow.style.left = left + 'px';
- searchSelectWindow.style.top = top + 'px';
- }
-
- // stop selection hide timer
- if (this.hideTimeout)
- {
- clearTimeout(this.hideTimeout);
- this.hideTimeout=0;
- }
- return false; // to avoid "image drag" default event
- }
-
- this.OnSearchSelectHide = function()
- {
- this.hideTimeout = setTimeout(this.name +".CloseSelectionWindow()",
- this.closeSelectionTimeout);
- }
-
- // Called when the content of the search field is changed.
- this.OnSearchFieldChange = function(evt)
- {
- if (this.keyTimeout) // kill running timer
- {
- clearTimeout(this.keyTimeout);
- this.keyTimeout = 0;
- }
-
- var e = (evt) ? evt : window.event; // for IE
- if (e.keyCode==40 || e.keyCode==13)
- {
- if (e.shiftKey==1)
- {
- this.OnSearchSelectShow();
- var win=this.DOMSearchSelectWindow();
- for (i=0;i<win.childNodes.length;i++)
- {
- var child = win.childNodes[i]; // get span within a
- if (child.className=='SelectItem')
- {
- child.focus();
- return;
- }
- }
- return;
- }
- else if (window.frames.MSearchResults.searchResults)
- {
- var elem = window.frames.MSearchResults.searchResults.NavNext(0);
- if (elem) elem.focus();
- }
- }
- else if (e.keyCode==27) // Escape out of the search field
- {
- this.DOMSearchField().blur();
- this.DOMPopupSearchResultsWindow().style.display = 'none';
- this.DOMSearchClose().style.display = 'none';
- this.lastSearchValue = '';
- this.Activate(false);
- return;
- }
-
- // strip whitespaces
- var searchValue = this.DOMSearchField().value.replace(/ +/g, "");
-
- if (searchValue != this.lastSearchValue) // search value has changed
- {
- if (searchValue != "") // non-empty search
- {
- // set timer for search update
- this.keyTimeout = setTimeout(this.name + '.Search()',
- this.keyTimeoutLength);
- }
- else // empty search field
- {
- this.DOMPopupSearchResultsWindow().style.display = 'none';
- this.DOMSearchClose().style.display = 'none';
- this.lastSearchValue = '';
- }
- }
- }
-
- this.SelectItemCount = function(id)
- {
- var count=0;
- var win=this.DOMSearchSelectWindow();
- for (i=0;i<win.childNodes.length;i++)
- {
- var child = win.childNodes[i]; // get span within a
- if (child.className=='SelectItem')
- {
- count++;
- }
- }
- return count;
- }
-
- this.SelectItemSet = function(id)
- {
- var i,j=0;
- var win=this.DOMSearchSelectWindow();
- for (i=0;i<win.childNodes.length;i++)
- {
- var child = win.childNodes[i]; // get span within a
- if (child.className=='SelectItem')
- {
- var node = child.firstChild;
- if (j==id)
- {
- node.innerHTML='•';
- }
- else
- {
- node.innerHTML=' ';
- }
- j++;
- }
- }
- }
-
- // Called when an search filter selection is made.
- // set item with index id as the active item
- this.OnSelectItem = function(id)
- {
- this.searchIndex = id;
- this.SelectItemSet(id);
- var searchValue = this.DOMSearchField().value.replace(/ +/g, "");
- if (searchValue!="" && this.searchActive) // something was found -> do a search
- {
- this.Search();
- }
- }
-
- this.OnSearchSelectKey = function(evt)
- {
- var e = (evt) ? evt : window.event; // for IE
- if (e.keyCode==40 && this.searchIndex<this.SelectItemCount()) // Down
- {
- this.searchIndex++;
- this.OnSelectItem(this.searchIndex);
- }
- else if (e.keyCode==38 && this.searchIndex>0) // Up
- {
- this.searchIndex--;
- this.OnSelectItem(this.searchIndex);
- }
- else if (e.keyCode==13 || e.keyCode==27)
- {
- this.OnSelectItem(this.searchIndex);
- this.CloseSelectionWindow();
- this.DOMSearchField().focus();
- }
- return false;
- }
-
- // --------- Actions
-
- // Closes the results window.
- this.CloseResultsWindow = function()
- {
- this.DOMPopupSearchResultsWindow().style.display = 'none';
- this.DOMSearchClose().style.display = 'none';
- this.Activate(false);
- }
-
- this.CloseSelectionWindow = function()
- {
- this.DOMSearchSelectWindow().style.display = 'none';
- }
-
- // Performs a search.
- this.Search = function()
- {
- this.keyTimeout = 0;
-
- // strip leading whitespace
- var searchValue = this.DOMSearchField().value.replace(/^ +/, "");
-
- var code = searchValue.toLowerCase().charCodeAt(0);
- var idxChar = searchValue.substr(0, 1).toLowerCase();
- if ( 0xD800 <= code && code <= 0xDBFF && searchValue > 1) // surrogate pair
- {
- idxChar = searchValue.substr(0, 2);
- }
-
- var resultsPage;
- var resultsPageWithSearch;
- var hasResultsPage;
-
- var idx = indexSectionsWithContent[this.searchIndex].indexOf(idxChar);
- if (idx!=-1)
- {
- var hexCode=idx.toString(16);
- resultsPage = this.resultsPath + '/' + indexSectionNames[this.searchIndex] + '_' + hexCode + '.html';
- resultsPageWithSearch = resultsPage+'?'+escape(searchValue);
- hasResultsPage = true;
- }
- else // nothing available for this search term
- {
- resultsPage = this.resultsPath + '/nomatches.html';
- resultsPageWithSearch = resultsPage;
- hasResultsPage = false;
- }
-
- window.frames.MSearchResults.location = resultsPageWithSearch;
- var domPopupSearchResultsWindow = this.DOMPopupSearchResultsWindow();
-
- if (domPopupSearchResultsWindow.style.display!='block')
- {
- var domSearchBox = this.DOMSearchBox();
- this.DOMSearchClose().style.display = 'inline';
- if (this.insideFrame)
- {
- var domPopupSearchResults = this.DOMPopupSearchResults();
- domPopupSearchResultsWindow.style.position = 'relative';
- domPopupSearchResultsWindow.style.display = 'block';
- var width = document.body.clientWidth - 8; // the -8 is for IE :-(
- domPopupSearchResultsWindow.style.width = width + 'px';
- domPopupSearchResults.style.width = width + 'px';
- }
- else
- {
- var domPopupSearchResults = this.DOMPopupSearchResults();
- var left = getXPos(domSearchBox) + 150; // domSearchBox.offsetWidth;
- var top = getYPos(domSearchBox) + 20; // domSearchBox.offsetHeight + 1;
- domPopupSearchResultsWindow.style.display = 'block';
- left -= domPopupSearchResults.offsetWidth;
- domPopupSearchResultsWindow.style.top = top + 'px';
- domPopupSearchResultsWindow.style.left = left + 'px';
- }
- }
-
- this.lastSearchValue = searchValue;
- this.lastResultsPage = resultsPage;
- }
-
- // -------- Activation Functions
-
- // Activates or deactivates the search panel, resetting things to
- // their default values if necessary.
- this.Activate = function(isActive)
- {
- if (isActive || // open it
- this.DOMPopupSearchResultsWindow().style.display == 'block'
- )
- {
- this.DOMSearchBox().className = 'MSearchBoxActive';
-
- var searchField = this.DOMSearchField();
-
- if (searchField.value == this.searchLabel) // clear "Search" term upon entry
- {
- searchField.value = '';
- this.searchActive = true;
- }
- }
- else if (!isActive) // directly remove the panel
- {
- this.DOMSearchBox().className = 'MSearchBoxInactive';
- this.DOMSearchField().value = this.searchLabel;
- this.searchActive = false;
- this.lastSearchValue = ''
- this.lastResultsPage = '';
- }
- }
-}
-
-// -----------------------------------------------------------------------
-
-// The class that handles everything on the search results page.
-function SearchResults(name)
-{
- // The number of matches from the last run of <Search()>.
- this.lastMatchCount = 0;
- this.lastKey = 0;
- this.repeatOn = false;
-
- // Toggles the visibility of the passed element ID.
- this.FindChildElement = function(id)
- {
- var parentElement = document.getElementById(id);
- var element = parentElement.firstChild;
-
- while (element && element!=parentElement)
- {
- if (element.nodeName == 'DIV' && element.className == 'SRChildren')
- {
- return element;
- }
-
- if (element.nodeName == 'DIV' && element.hasChildNodes())
- {
- element = element.firstChild;
- }
- else if (element.nextSibling)
- {
- element = element.nextSibling;
- }
- else
- {
- do
- {
- element = element.parentNode;
- }
- while (element && element!=parentElement && !element.nextSibling);
-
- if (element && element!=parentElement)
- {
- element = element.nextSibling;
- }
- }
- }
- }
-
- this.Toggle = function(id)
- {
- var element = this.FindChildElement(id);
- if (element)
- {
- if (element.style.display == 'block')
- {
- element.style.display = 'none';
- }
- else
- {
- element.style.display = 'block';
- }
- }
- }
-
- // Searches for the passed string. If there is no parameter,
- // it takes it from the URL query.
- //
- // Always returns true, since other documents may try to call it
- // and that may or may not be possible.
- this.Search = function(search)
- {
- if (!search) // get search word from URL
- {
- search = window.location.search;
- search = search.substring(1); // Remove the leading '?'
- search = unescape(search);
- }
-
- search = search.replace(/^ +/, ""); // strip leading spaces
- search = search.replace(/ +$/, ""); // strip trailing spaces
- search = search.toLowerCase();
- search = convertToId(search);
-
- var resultRows = document.getElementsByTagName("div");
- var matches = 0;
-
- var i = 0;
- while (i < resultRows.length)
- {
- var row = resultRows.item(i);
- if (row.className == "SRResult")
- {
- var rowMatchName = row.id.toLowerCase();
- rowMatchName = rowMatchName.replace(/^sr\d*_/, ''); // strip 'sr123_'
-
- if (search.length<=rowMatchName.length &&
- rowMatchName.substr(0, search.length)==search)
- {
- row.style.display = 'block';
- matches++;
- }
- else
- {
- row.style.display = 'none';
- }
- }
- i++;
- }
- document.getElementById("Searching").style.display='none';
- if (matches == 0) // no results
- {
- document.getElementById("NoMatches").style.display='block';
- }
- else // at least one result
- {
- document.getElementById("NoMatches").style.display='none';
- }
- this.lastMatchCount = matches;
- return true;
- }
-
- // return the first item with index index or higher that is visible
- this.NavNext = function(index)
- {
- var focusItem;
- while (1)
- {
- var focusName = 'Item'+index;
- focusItem = document.getElementById(focusName);
- if (focusItem && focusItem.parentNode.parentNode.style.display=='block')
- {
- break;
- }
- else if (!focusItem) // last element
- {
- break;
- }
- focusItem=null;
- index++;
- }
- return focusItem;
- }
-
- this.NavPrev = function(index)
- {
- var focusItem;
- while (1)
- {
- var focusName = 'Item'+index;
- focusItem = document.getElementById(focusName);
- if (focusItem && focusItem.parentNode.parentNode.style.display=='block')
- {
- break;
- }
- else if (!focusItem) // last element
- {
- break;
- }
- focusItem=null;
- index--;
- }
- return focusItem;
- }
-
- this.ProcessKeys = function(e)
- {
- if (e.type == "keydown")
- {
- this.repeatOn = false;
- this.lastKey = e.keyCode;
- }
- else if (e.type == "keypress")
- {
- if (!this.repeatOn)
- {
- if (this.lastKey) this.repeatOn = true;
- return false; // ignore first keypress after keydown
- }
- }
- else if (e.type == "keyup")
- {
- this.lastKey = 0;
- this.repeatOn = false;
- }
- return this.lastKey!=0;
- }
-
- this.Nav = function(evt,itemIndex)
- {
- var e = (evt) ? evt : window.event; // for IE
- if (e.keyCode==13) return true;
- if (!this.ProcessKeys(e)) return false;
-
- if (this.lastKey==38) // Up
- {
- var newIndex = itemIndex-1;
- var focusItem = this.NavPrev(newIndex);
- if (focusItem)
- {
- var child = this.FindChildElement(focusItem.parentNode.parentNode.id);
- if (child && child.style.display == 'block') // children visible
- {
- var n=0;
- var tmpElem;
- while (1) // search for last child
- {
- tmpElem = document.getElementById('Item'+newIndex+'_c'+n);
- if (tmpElem)
- {
- focusItem = tmpElem;
- }
- else // found it!
- {
- break;
- }
- n++;
- }
- }
- }
- if (focusItem)
- {
- focusItem.focus();
- }
- else // return focus to search field
- {
- parent.document.getElementById("MSearchField").focus();
- }
- }
- else if (this.lastKey==40) // Down
- {
- var newIndex = itemIndex+1;
- var focusItem;
- var item = document.getElementById('Item'+itemIndex);
- var elem = this.FindChildElement(item.parentNode.parentNode.id);
- if (elem && elem.style.display == 'block') // children visible
- {
- focusItem = document.getElementById('Item'+itemIndex+'_c0');
- }
- if (!focusItem) focusItem = this.NavNext(newIndex);
- if (focusItem) focusItem.focus();
- }
- else if (this.lastKey==39) // Right
- {
- var item = document.getElementById('Item'+itemIndex);
- var elem = this.FindChildElement(item.parentNode.parentNode.id);
- if (elem) elem.style.display = 'block';
- }
- else if (this.lastKey==37) // Left
- {
- var item = document.getElementById('Item'+itemIndex);
- var elem = this.FindChildElement(item.parentNode.parentNode.id);
- if (elem) elem.style.display = 'none';
- }
- else if (this.lastKey==27) // Escape
- {
- parent.searchBox.CloseResultsWindow();
- parent.document.getElementById("MSearchField").focus();
- }
- else if (this.lastKey==13) // Enter
- {
- return true;
- }
- return false;
- }
-
- this.NavChild = function(evt,itemIndex,childIndex)
- {
- var e = (evt) ? evt : window.event; // for IE
- if (e.keyCode==13) return true;
- if (!this.ProcessKeys(e)) return false;
-
- if (this.lastKey==38) // Up
- {
- if (childIndex>0)
- {
- var newIndex = childIndex-1;
- document.getElementById('Item'+itemIndex+'_c'+newIndex).focus();
- }
- else // already at first child, jump to parent
- {
- document.getElementById('Item'+itemIndex).focus();
- }
- }
- else if (this.lastKey==40) // Down
- {
- var newIndex = childIndex+1;
- var elem = document.getElementById('Item'+itemIndex+'_c'+newIndex);
- if (!elem) // last child, jump to parent next parent
- {
- elem = this.NavNext(itemIndex+1);
- }
- if (elem)
- {
- elem.focus();
- }
- }
- else if (this.lastKey==27) // Escape
- {
- parent.searchBox.CloseResultsWindow();
- parent.document.getElementById("MSearchField").focus();
- }
- else if (this.lastKey==13) // Enter
- {
- return true;
- }
- return false;
- }
-}
-
-function setKeyActions(elem,action)
-{
- elem.setAttribute('onkeydown',action);
- elem.setAttribute('onkeypress',action);
- elem.setAttribute('onkeyup',action);
-}
-
-function setClassAttr(elem,attr)
-{
- elem.setAttribute('class',attr);
- elem.setAttribute('className',attr);
-}
-
-function createResults()
-{
- var results = document.getElementById("SRResults");
- for (var e=0; e<searchData.length; e++)
- {
- var id = searchData[e][0];
- var srResult = document.createElement('div');
- srResult.setAttribute('id','SR_'+id);
- setClassAttr(srResult,'SRResult');
- var srEntry = document.createElement('div');
- setClassAttr(srEntry,'SREntry');
- var srLink = document.createElement('a');
- srLink.setAttribute('id','Item'+e);
- setKeyActions(srLink,'return searchResults.Nav(event,'+e+')');
- setClassAttr(srLink,'SRSymbol');
- srLink.innerHTML = searchData[e][1][0];
- srEntry.appendChild(srLink);
- if (searchData[e][1].length==2) // single result
- {
- srLink.setAttribute('href',searchData[e][1][1][0]);
- if (searchData[e][1][1][1])
- {
- srLink.setAttribute('target','_parent');
- }
- var srScope = document.createElement('span');
- setClassAttr(srScope,'SRScope');
- srScope.innerHTML = searchData[e][1][1][2];
- srEntry.appendChild(srScope);
- }
- else // multiple results
- {
- srLink.setAttribute('href','javascript:searchResults.Toggle("SR_'+id+'")');
- var srChildren = document.createElement('div');
- setClassAttr(srChildren,'SRChildren');
- for (var c=0; c<searchData[e][1].length-1; c++)
- {
- var srChild = document.createElement('a');
- srChild.setAttribute('id','Item'+e+'_c'+c);
- setKeyActions(srChild,'return searchResults.NavChild(event,'+e+','+c+')');
- setClassAttr(srChild,'SRScope');
- srChild.setAttribute('href',searchData[e][1][c+1][0]);
- if (searchData[e][1][c+1][1])
- {
- srChild.setAttribute('target','_parent');
- }
- srChild.innerHTML = searchData[e][1][c+1][2];
- srChildren.appendChild(srChild);
- }
- srEntry.appendChild(srChildren);
- }
- srResult.appendChild(srEntry);
- results.appendChild(srResult);
- }
-}
-
-function init_search()
-{
- var results = document.getElementById("MSearchSelectWindow");
- for (var key in indexSectionLabels)
- {
- var link = document.createElement('a');
- link.setAttribute('class','SelectItem');
- link.setAttribute('onclick','searchBox.OnSelectItem('+key+')');
- link.href='javascript:void(0)';
- link.innerHTML='<span class="SelectionMark"> </span>'+indexSectionLabels[key];
- results.appendChild(link);
- }
- searchBox.OnSelectItem(0);
-}
-
diff --git a/docs/html/search/search_l.png b/docs/html/search/search_l.png
deleted file mode 100644
index c872f4d..0000000
--- a/docs/html/search/search_l.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/search/search_m.png b/docs/html/search/search_m.png
deleted file mode 100644
index b429a16..0000000
--- a/docs/html/search/search_m.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/search/search_r.png b/docs/html/search/search_r.png
deleted file mode 100644
index 97ee8b4..0000000
--- a/docs/html/search/search_r.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/search/searchdata.js b/docs/html/search/searchdata.js
deleted file mode 100644
index 8384325..0000000
--- a/docs/html/search/searchdata.js
+++ /dev/null
@@ -1,36 +0,0 @@
-var indexSectionsWithContent =
-{
- 0: "acegiklmprs",
- 1: "p",
- 2: "c",
- 3: "p",
- 4: "e",
- 5: "p",
- 6: "p",
- 7: "aegiklmrs"
-};
-
-var indexSectionNames =
-{
- 0: "all",
- 1: "classes",
- 2: "files",
- 3: "functions",
- 4: "variables",
- 5: "typedefs",
- 6: "defines",
- 7: "groups"
-};
-
-var indexSectionLabels =
-{
- 0: "All",
- 1: "Classes",
- 2: "Files",
- 3: "Functions",
- 4: "Variables",
- 5: "Typedefs",
- 6: "Macros",
- 7: "Modules"
-};
-
diff --git a/docs/html/search/typedefs_0.html b/docs/html/search/typedefs_0.html
deleted file mode 100644
index fb07195..0000000
--- a/docs/html/search/typedefs_0.html
+++ /dev/null
@@ -1,26 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html><head><title></title>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<link rel="stylesheet" type="text/css" href="search.css"/>
-<script type="text/javascript" src="typedefs_0.js"></script>
-<script type="text/javascript" src="search.js"></script>
-</head>
-<body class="SRPage">
-<div id="SRIndex">
-<div class="SRStatus" id="Loading">Loading...</div>
-<div id="SRResults"></div>
-<script type="text/javascript"><!--
-createResults();
---></script>
-<div class="SRStatus" id="Searching">Searching...</div>
-<div class="SRStatus" id="NoMatches">No Matches</div>
-<script type="text/javascript"><!--
-document.getElementById("Loading").style.display="none";
-document.getElementById("NoMatches").style.display="none";
-var searchResults = new SearchResults("searchResults");
-searchResults.Search();
---></script>
-</div>
-</body>
-</html>
diff --git a/docs/html/search/typedefs_0.js b/docs/html/search/typedefs_0.js
deleted file mode 100644
index 5b2f6d2..0000000
--- a/docs/html/search/typedefs_0.js
+++ /dev/null
@@ -1,18 +0,0 @@
-var searchData=
-[
- ['psa_5faead_5foperation_5ft',['psa_aead_operation_t',['../group__aead.html#ga14f6a01afbaa8c5b3d8c5d345cbaa3ed',1,'crypto.h']]],
- ['psa_5falgorithm_5ft',['psa_algorithm_t',['../group__crypto__types.html#gac2e4d47f1300d73c2f829a6d99252d69',1,'crypto_types.h']]],
- ['psa_5fcipher_5foperation_5ft',['psa_cipher_operation_t',['../group__cipher.html#ga1399de29db657e3737bb09927aae51fa',1,'crypto.h']]],
- ['psa_5fcrypto_5fgenerator_5ft',['psa_crypto_generator_t',['../group__generators.html#ga1f894c4fba202ef8e307d72caf489e3b',1,'crypto.h']]],
- ['psa_5fecc_5fcurve_5ft',['psa_ecc_curve_t',['../group__crypto__types.html#ga4e8977c145cce5077c4bce7fec890ad9',1,'crypto_types.h']]],
- ['psa_5fhash_5foperation_5ft',['psa_hash_operation_t',['../group__hash.html#ga3c4205d2ce66c4095fc5c78c25273fab',1,'crypto.h']]],
- ['psa_5fkey_5fderivation_5fstep_5ft',['psa_key_derivation_step_t',['../group__derivation.html#gaac4eeacd36596c548b3a48fc06c5048b',1,'crypto_types.h']]],
- ['psa_5fkey_5fhandle_5ft',['psa_key_handle_t',['../group__platform.html#gabf6d5fd4e2ea89ecd425c88f057e7f75',1,'crypto.h']]],
- ['psa_5fkey_5fid_5ft',['psa_key_id_t',['../group__key__lifetimes.html#ga11e986351c65bd3dc3c0fe2cd9926e4b',1,'crypto_types.h']]],
- ['psa_5fkey_5flifetime_5ft',['psa_key_lifetime_t',['../group__key__lifetimes.html#ga6821ff6dd39dc2bc370ded760ad8b0cf',1,'crypto_types.h']]],
- ['psa_5fkey_5fpolicy_5ft',['psa_key_policy_t',['../group__policy.html#gaf553efd409845b6d09ff25ce2ba36607',1,'crypto.h']]],
- ['psa_5fkey_5ftype_5ft',['psa_key_type_t',['../group__crypto__types.html#ga578159487dfc7096cb191b0d2befe628',1,'crypto_types.h']]],
- ['psa_5fkey_5fusage_5ft',['psa_key_usage_t',['../group__policy.html#ga7bb9de71337e0e98de843aa7f9b55f25',1,'crypto_types.h']]],
- ['psa_5fmac_5foperation_5ft',['psa_mac_operation_t',['../group__MAC.html#ga78f0838b0c4e3db28b26355624d4bd37',1,'crypto.h']]],
- ['psa_5fstatus_5ft',['psa_status_t',['../group__error.html#ga05676e70ba5c6a7565aff3c36677c1f9',1,'crypto_types.h']]]
-];
diff --git a/docs/html/search/variables_0.html b/docs/html/search/variables_0.html
deleted file mode 100644
index 3835278..0000000
--- a/docs/html/search/variables_0.html
+++ /dev/null
@@ -1,26 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html><head><title></title>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<link rel="stylesheet" type="text/css" href="search.css"/>
-<script type="text/javascript" src="variables_0.js"></script>
-<script type="text/javascript" src="search.js"></script>
-</head>
-<body class="SRPage">
-<div id="SRIndex">
-<div class="SRStatus" id="Loading">Loading...</div>
-<div id="SRResults"></div>
-<script type="text/javascript"><!--
-createResults();
---></script>
-<div class="SRStatus" id="Searching">Searching...</div>
-<div class="SRStatus" id="NoMatches">No Matches</div>
-<script type="text/javascript"><!--
-document.getElementById("Loading").style.display="none";
-document.getElementById("NoMatches").style.display="none";
-var searchResults = new SearchResults("searchResults");
-searchResults.Search();
---></script>
-</div>
-</body>
-</html>
diff --git a/docs/html/search/variables_0.js b/docs/html/search/variables_0.js
deleted file mode 100644
index 9ba7121..0000000
--- a/docs/html/search/variables_0.js
+++ /dev/null
@@ -1,4 +0,0 @@
-var searchData=
-[
- ['e',['e',['../structpsa__generate__key__extra__rsa.html#a53ccb9e4375f3c9af6e3ecfe111ce11d',1,'psa_generate_key_extra_rsa']]]
-];
diff --git a/docs/html/searchindex.js b/docs/html/searchindex.js
new file mode 100644
index 0000000..9706da1
--- /dev/null
+++ b/docs/html/searchindex.js
@@ -0,0 +1 @@
+Search.setIndex({docnames:["from_doxygen","general","index"],envversion:{"sphinx.domains.c":1,"sphinx.domains.changeset":1,"sphinx.domains.cpp":1,"sphinx.domains.javascript":1,"sphinx.domains.math":2,"sphinx.domains.python":1,"sphinx.domains.rst":1,"sphinx.domains.std":1,"sphinx.ext.intersphinx":1,sphinx:55},filenames:["from_doxygen.rst","general.rst","index.rst"],objects:{"":{PSA_AEAD_DECRYPT_OUTPUT_SIZE:[0,0,1,"c.PSA_AEAD_DECRYPT_OUTPUT_SIZE"],PSA_AEAD_ENCRYPT_OUTPUT_SIZE:[0,0,1,"c.PSA_AEAD_ENCRYPT_OUTPUT_SIZE"],PSA_AEAD_FINISH_OUTPUT_SIZE:[0,0,1,"c.PSA_AEAD_FINISH_OUTPUT_SIZE"],PSA_AEAD_OPERATION_INIT:[0,0,1,"c.PSA_AEAD_OPERATION_INIT"],PSA_AEAD_TAG_LENGTH:[0,0,1,"c.PSA_AEAD_TAG_LENGTH"],PSA_AEAD_TAG_LENGTH_OFFSET:[0,0,1,"c.PSA_AEAD_TAG_LENGTH_OFFSET"],PSA_AEAD_UPDATE_OUTPUT_SIZE:[0,0,1,"c.PSA_AEAD_UPDATE_OUTPUT_SIZE"],PSA_AEAD_VERIFY_OUTPUT_SIZE:[0,0,1,"c.PSA_AEAD_VERIFY_OUTPUT_SIZE"],PSA_ALG_AEAD_FROM_BLOCK_FLAG:[0,0,1,"c.PSA_ALG_AEAD_FROM_BLOCK_FLAG"],PSA_ALG_AEAD_TAG_LENGTH_MASK:[0,0,1,"c.PSA_ALG_AEAD_TAG_LENGTH_MASK"],PSA_ALG_AEAD_WITH_DEFAULT_TAG_LENGTH:[0,0,1,"c.PSA_ALG_AEAD_WITH_DEFAULT_TAG_LENGTH"],PSA_ALG_AEAD_WITH_TAG_LENGTH:[0,0,1,"c.PSA_ALG_AEAD_WITH_TAG_LENGTH"],PSA_ALG_ANY_HASH:[0,0,1,"c.PSA_ALG_ANY_HASH"],PSA_ALG_ARC4:[0,0,1,"c.PSA_ALG_ARC4"],PSA_ALG_CATEGORY_AEAD:[0,0,1,"c.PSA_ALG_CATEGORY_AEAD"],PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION:[0,0,1,"c.PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION"],PSA_ALG_CATEGORY_CIPHER:[0,0,1,"c.PSA_ALG_CATEGORY_CIPHER"],PSA_ALG_CATEGORY_HASH:[0,0,1,"c.PSA_ALG_CATEGORY_HASH"],PSA_ALG_CATEGORY_KEY_AGREEMENT:[0,0,1,"c.PSA_ALG_CATEGORY_KEY_AGREEMENT"],PSA_ALG_CATEGORY_KEY_DERIVATION:[0,0,1,"c.PSA_ALG_CATEGORY_KEY_DERIVATION"],PSA_ALG_CATEGORY_MAC:[0,0,1,"c.PSA_ALG_CATEGORY_MAC"],PSA_ALG_CATEGORY_MASK:[0,0,1,"c.PSA_ALG_CATEGORY_MASK"],PSA_ALG_CATEGORY_SIGN:[0,0,1,"c.PSA_ALG_CATEGORY_SIGN"],PSA_ALG_CBC_MAC:[0,0,1,"c.PSA_ALG_CBC_MAC"],PSA_ALG_CBC_NO_PADDING:[0,0,1,"c.PSA_ALG_CBC_NO_PADDING"],PSA_ALG_CBC_PKCS7:[0,0,1,"c.PSA_ALG_CBC_PKCS7"],PSA_ALG_CCM:[0,0,1,"c.PSA_ALG_CCM"],PSA_ALG_CFB:[0,0,1,"c.PSA_ALG_CFB"],PSA_ALG_CHACHA20:[0,0,1,"c.PSA_ALG_CHACHA20"],PSA_ALG_CHACHA20_POLY1305:[0,0,1,"c.PSA_ALG_CHACHA20_POLY1305"],PSA_ALG_CIPHER_FROM_BLOCK_FLAG:[0,0,1,"c.PSA_ALG_CIPHER_FROM_BLOCK_FLAG"],PSA_ALG_CIPHER_MAC_BASE:[0,0,1,"c.PSA_ALG_CIPHER_MAC_BASE"],PSA_ALG_CIPHER_STREAM_FLAG:[0,0,1,"c.PSA_ALG_CIPHER_STREAM_FLAG"],PSA_ALG_CMAC:[0,0,1,"c.PSA_ALG_CMAC"],PSA_ALG_CTR:[0,0,1,"c.PSA_ALG_CTR"],PSA_ALG_DETERMINISTIC_ECDSA:[0,0,1,"c.PSA_ALG_DETERMINISTIC_ECDSA"],PSA_ALG_DETERMINISTIC_ECDSA_BASE:[0,0,1,"c.PSA_ALG_DETERMINISTIC_ECDSA_BASE"],PSA_ALG_ECDH:[0,0,1,"c.PSA_ALG_ECDH"],PSA_ALG_ECDSA:[0,0,1,"c.PSA_ALG_ECDSA"],PSA_ALG_ECDSA_ANY:[0,0,1,"c.PSA_ALG_ECDSA_ANY"],PSA_ALG_ECDSA_BASE:[0,0,1,"c.PSA_ALG_ECDSA_BASE"],PSA_ALG_ECDSA_IS_DETERMINISTIC:[0,0,1,"c.PSA_ALG_ECDSA_IS_DETERMINISTIC"],PSA_ALG_FFDH:[0,0,1,"c.PSA_ALG_FFDH"],PSA_ALG_FULL_LENGTH_MAC:[0,0,1,"c.PSA_ALG_FULL_LENGTH_MAC"],PSA_ALG_GCM:[0,0,1,"c.PSA_ALG_GCM"],PSA_ALG_GMAC:[0,0,1,"c.PSA_ALG_GMAC"],PSA_ALG_HASH_MASK:[0,0,1,"c.PSA_ALG_HASH_MASK"],PSA_ALG_HKDF:[0,0,1,"c.PSA_ALG_HKDF"],PSA_ALG_HKDF_BASE:[0,0,1,"c.PSA_ALG_HKDF_BASE"],PSA_ALG_HKDF_GET_HASH:[0,0,1,"c.PSA_ALG_HKDF_GET_HASH"],PSA_ALG_HMAC:[0,0,1,"c.PSA_ALG_HMAC"],PSA_ALG_HMAC_BASE:[0,0,1,"c.PSA_ALG_HMAC_BASE"],PSA_ALG_HMAC_GET_HASH:[0,0,1,"c.PSA_ALG_HMAC_GET_HASH"],PSA_ALG_IS_AEAD:[0,0,1,"c.PSA_ALG_IS_AEAD"],PSA_ALG_IS_AEAD_ON_BLOCK_CIPHER:[0,0,1,"c.PSA_ALG_IS_AEAD_ON_BLOCK_CIPHER"],PSA_ALG_IS_ASYMMETRIC_ENCRYPTION:[0,0,1,"c.PSA_ALG_IS_ASYMMETRIC_ENCRYPTION"],PSA_ALG_IS_BLOCK_CIPHER_MAC:[0,0,1,"c.PSA_ALG_IS_BLOCK_CIPHER_MAC"],PSA_ALG_IS_CIPHER:[0,0,1,"c.PSA_ALG_IS_CIPHER"],PSA_ALG_IS_DETERMINISTIC_ECDSA:[0,0,1,"c.PSA_ALG_IS_DETERMINISTIC_ECDSA"],PSA_ALG_IS_ECDH:[0,0,1,"c.PSA_ALG_IS_ECDH"],PSA_ALG_IS_ECDSA:[0,0,1,"c.PSA_ALG_IS_ECDSA"],PSA_ALG_IS_FFDH:[0,0,1,"c.PSA_ALG_IS_FFDH"],PSA_ALG_IS_HASH:[0,0,1,"c.PSA_ALG_IS_HASH"],PSA_ALG_IS_HASH_AND_SIGN:[0,0,1,"c.PSA_ALG_IS_HASH_AND_SIGN"],PSA_ALG_IS_HKDF:[0,0,1,"c.PSA_ALG_IS_HKDF"],PSA_ALG_IS_HMAC:[0,0,1,"c.PSA_ALG_IS_HMAC"],PSA_ALG_IS_KEY_AGREEMENT:[0,0,1,"c.PSA_ALG_IS_KEY_AGREEMENT"],PSA_ALG_IS_KEY_DERIVATION:[0,0,1,"c.PSA_ALG_IS_KEY_DERIVATION"],PSA_ALG_IS_KEY_DERIVATION_OR_AGREEMENT:[0,0,1,"c.PSA_ALG_IS_KEY_DERIVATION_OR_AGREEMENT"],PSA_ALG_IS_MAC:[0,0,1,"c.PSA_ALG_IS_MAC"],PSA_ALG_IS_RANDOMIZED_ECDSA:[0,0,1,"c.PSA_ALG_IS_RANDOMIZED_ECDSA"],PSA_ALG_IS_RAW_KEY_AGREEMENT:[0,0,1,"c.PSA_ALG_IS_RAW_KEY_AGREEMENT"],PSA_ALG_IS_RSA_OAEP:[0,0,1,"c.PSA_ALG_IS_RSA_OAEP"],PSA_ALG_IS_RSA_PKCS1V15_SIGN:[0,0,1,"c.PSA_ALG_IS_RSA_PKCS1V15_SIGN"],PSA_ALG_IS_RSA_PSS:[0,0,1,"c.PSA_ALG_IS_RSA_PSS"],PSA_ALG_IS_SIGN:[0,0,1,"c.PSA_ALG_IS_SIGN"],PSA_ALG_IS_STREAM_CIPHER:[0,0,1,"c.PSA_ALG_IS_STREAM_CIPHER"],PSA_ALG_IS_TLS12_PRF:[0,0,1,"c.PSA_ALG_IS_TLS12_PRF"],PSA_ALG_IS_TLS12_PSK_TO_MS:[0,0,1,"c.PSA_ALG_IS_TLS12_PSK_TO_MS"],PSA_ALG_IS_VENDOR_DEFINED:[0,0,1,"c.PSA_ALG_IS_VENDOR_DEFINED"],PSA_ALG_IS_WILDCARD:[0,0,1,"c.PSA_ALG_IS_WILDCARD"],PSA_ALG_KEY_AGREEMENT:[0,0,1,"c.PSA_ALG_KEY_AGREEMENT"],PSA_ALG_KEY_AGREEMENT_GET_BASE:[0,0,1,"c.PSA_ALG_KEY_AGREEMENT_GET_BASE"],PSA_ALG_KEY_AGREEMENT_GET_KDF:[0,0,1,"c.PSA_ALG_KEY_AGREEMENT_GET_KDF"],PSA_ALG_KEY_AGREEMENT_MASK:[0,0,1,"c.PSA_ALG_KEY_AGREEMENT_MASK"],PSA_ALG_KEY_DERIVATION_MASK:[0,0,1,"c.PSA_ALG_KEY_DERIVATION_MASK"],PSA_ALG_MAC_SUBCATEGORY_MASK:[0,0,1,"c.PSA_ALG_MAC_SUBCATEGORY_MASK"],PSA_ALG_MAC_TRUNCATION_MASK:[0,0,1,"c.PSA_ALG_MAC_TRUNCATION_MASK"],PSA_ALG_MD2:[0,0,1,"c.PSA_ALG_MD2"],PSA_ALG_MD4:[0,0,1,"c.PSA_ALG_MD4"],PSA_ALG_MD5:[0,0,1,"c.PSA_ALG_MD5"],PSA_ALG_OFB:[0,0,1,"c.PSA_ALG_OFB"],PSA_ALG_RIPEMD160:[0,0,1,"c.PSA_ALG_RIPEMD160"],PSA_ALG_RSA_OAEP:[0,0,1,"c.PSA_ALG_RSA_OAEP"],PSA_ALG_RSA_OAEP_BASE:[0,0,1,"c.PSA_ALG_RSA_OAEP_BASE"],PSA_ALG_RSA_OAEP_GET_HASH:[0,0,1,"c.PSA_ALG_RSA_OAEP_GET_HASH"],PSA_ALG_RSA_PKCS1V15_CRYPT:[0,0,1,"c.PSA_ALG_RSA_PKCS1V15_CRYPT"],PSA_ALG_RSA_PKCS1V15_SIGN:[0,0,1,"c.PSA_ALG_RSA_PKCS1V15_SIGN"],PSA_ALG_RSA_PKCS1V15_SIGN_BASE:[0,0,1,"c.PSA_ALG_RSA_PKCS1V15_SIGN_BASE"],PSA_ALG_RSA_PKCS1V15_SIGN_RAW:[0,0,1,"c.PSA_ALG_RSA_PKCS1V15_SIGN_RAW"],PSA_ALG_RSA_PSS:[0,0,1,"c.PSA_ALG_RSA_PSS"],PSA_ALG_RSA_PSS_BASE:[0,0,1,"c.PSA_ALG_RSA_PSS_BASE"],PSA_ALG_SHA3_224:[0,0,1,"c.PSA_ALG_SHA3_224"],PSA_ALG_SHA3_256:[0,0,1,"c.PSA_ALG_SHA3_256"],PSA_ALG_SHA3_384:[0,0,1,"c.PSA_ALG_SHA3_384"],PSA_ALG_SHA3_512:[0,0,1,"c.PSA_ALG_SHA3_512"],PSA_ALG_SHA_1:[0,0,1,"c.PSA_ALG_SHA_1"],PSA_ALG_SHA_224:[0,0,1,"c.PSA_ALG_SHA_224"],PSA_ALG_SHA_256:[0,0,1,"c.PSA_ALG_SHA_256"],PSA_ALG_SHA_384:[0,0,1,"c.PSA_ALG_SHA_384"],PSA_ALG_SHA_512:[0,0,1,"c.PSA_ALG_SHA_512"],PSA_ALG_SHA_512_224:[0,0,1,"c.PSA_ALG_SHA_512_224"],PSA_ALG_SHA_512_256:[0,0,1,"c.PSA_ALG_SHA_512_256"],PSA_ALG_SIGN_GET_HASH:[0,0,1,"c.PSA_ALG_SIGN_GET_HASH"],PSA_ALG_TLS12_PRF:[0,0,1,"c.PSA_ALG_TLS12_PRF"],PSA_ALG_TLS12_PRF_BASE:[0,0,1,"c.PSA_ALG_TLS12_PRF_BASE"],PSA_ALG_TLS12_PRF_GET_HASH:[0,0,1,"c.PSA_ALG_TLS12_PRF_GET_HASH"],PSA_ALG_TLS12_PSK_TO_MS:[0,0,1,"c.PSA_ALG_TLS12_PSK_TO_MS"],PSA_ALG_TLS12_PSK_TO_MS_BASE:[0,0,1,"c.PSA_ALG_TLS12_PSK_TO_MS_BASE"],PSA_ALG_TLS12_PSK_TO_MS_GET_HASH:[0,0,1,"c.PSA_ALG_TLS12_PSK_TO_MS_GET_HASH"],PSA_ALG_TLS12_PSK_TO_MS_MAX_PSK_LEN:[0,0,1,"c.PSA_ALG_TLS12_PSK_TO_MS_MAX_PSK_LEN"],PSA_ALG_TRUNCATED_MAC:[0,0,1,"c.PSA_ALG_TRUNCATED_MAC"],PSA_ALG_VENDOR_FLAG:[0,0,1,"c.PSA_ALG_VENDOR_FLAG"],PSA_ALG_XTS:[0,0,1,"c.PSA_ALG_XTS"],PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE:[0,0,1,"c.PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE"],PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE:[0,0,1,"c.PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE"],PSA_ASYMMETRIC_SIGNATURE_MAX_SIZE:[0,0,1,"c.PSA_ASYMMETRIC_SIGNATURE_MAX_SIZE"],PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE:[0,0,1,"c.PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE"],PSA_BITS_TO_BYTES:[0,0,1,"c.PSA_BITS_TO_BYTES"],PSA_BLOCK_CIPHER_BLOCK_SIZE:[0,0,1,"c.PSA_BLOCK_CIPHER_BLOCK_SIZE"],PSA_BYTES_TO_BITS:[0,0,1,"c.PSA_BYTES_TO_BITS"],PSA_CIPHER_OPERATION_INIT:[0,0,1,"c.PSA_CIPHER_OPERATION_INIT"],PSA_DH_GROUP_FFDHE2048:[0,0,1,"c.PSA_DH_GROUP_FFDHE2048"],PSA_DH_GROUP_FFDHE3072:[0,0,1,"c.PSA_DH_GROUP_FFDHE3072"],PSA_DH_GROUP_FFDHE4096:[0,0,1,"c.PSA_DH_GROUP_FFDHE4096"],PSA_DH_GROUP_FFDHE6144:[0,0,1,"c.PSA_DH_GROUP_FFDHE6144"],PSA_DH_GROUP_FFDHE8192:[0,0,1,"c.PSA_DH_GROUP_FFDHE8192"],PSA_ECC_CURVE_BITS:[0,0,1,"c.PSA_ECC_CURVE_BITS"],PSA_ECC_CURVE_BRAINPOOL_P256R1:[0,0,1,"c.PSA_ECC_CURVE_BRAINPOOL_P256R1"],PSA_ECC_CURVE_BRAINPOOL_P384R1:[0,0,1,"c.PSA_ECC_CURVE_BRAINPOOL_P384R1"],PSA_ECC_CURVE_BRAINPOOL_P512R1:[0,0,1,"c.PSA_ECC_CURVE_BRAINPOOL_P512R1"],PSA_ECC_CURVE_CURVE25519:[0,0,1,"c.PSA_ECC_CURVE_CURVE25519"],PSA_ECC_CURVE_CURVE448:[0,0,1,"c.PSA_ECC_CURVE_CURVE448"],PSA_ECC_CURVE_SECP160K1:[0,0,1,"c.PSA_ECC_CURVE_SECP160K1"],PSA_ECC_CURVE_SECP160R1:[0,0,1,"c.PSA_ECC_CURVE_SECP160R1"],PSA_ECC_CURVE_SECP160R2:[0,0,1,"c.PSA_ECC_CURVE_SECP160R2"],PSA_ECC_CURVE_SECP192K1:[0,0,1,"c.PSA_ECC_CURVE_SECP192K1"],PSA_ECC_CURVE_SECP192R1:[0,0,1,"c.PSA_ECC_CURVE_SECP192R1"],PSA_ECC_CURVE_SECP224K1:[0,0,1,"c.PSA_ECC_CURVE_SECP224K1"],PSA_ECC_CURVE_SECP224R1:[0,0,1,"c.PSA_ECC_CURVE_SECP224R1"],PSA_ECC_CURVE_SECP256K1:[0,0,1,"c.PSA_ECC_CURVE_SECP256K1"],PSA_ECC_CURVE_SECP256R1:[0,0,1,"c.PSA_ECC_CURVE_SECP256R1"],PSA_ECC_CURVE_SECP384R1:[0,0,1,"c.PSA_ECC_CURVE_SECP384R1"],PSA_ECC_CURVE_SECP521R1:[0,0,1,"c.PSA_ECC_CURVE_SECP521R1"],PSA_ECC_CURVE_SECT163K1:[0,0,1,"c.PSA_ECC_CURVE_SECT163K1"],PSA_ECC_CURVE_SECT163R1:[0,0,1,"c.PSA_ECC_CURVE_SECT163R1"],PSA_ECC_CURVE_SECT163R2:[0,0,1,"c.PSA_ECC_CURVE_SECT163R2"],PSA_ECC_CURVE_SECT193R1:[0,0,1,"c.PSA_ECC_CURVE_SECT193R1"],PSA_ECC_CURVE_SECT193R2:[0,0,1,"c.PSA_ECC_CURVE_SECT193R2"],PSA_ECC_CURVE_SECT233K1:[0,0,1,"c.PSA_ECC_CURVE_SECT233K1"],PSA_ECC_CURVE_SECT233R1:[0,0,1,"c.PSA_ECC_CURVE_SECT233R1"],PSA_ECC_CURVE_SECT239K1:[0,0,1,"c.PSA_ECC_CURVE_SECT239K1"],PSA_ECC_CURVE_SECT283K1:[0,0,1,"c.PSA_ECC_CURVE_SECT283K1"],PSA_ECC_CURVE_SECT283R1:[0,0,1,"c.PSA_ECC_CURVE_SECT283R1"],PSA_ECC_CURVE_SECT409K1:[0,0,1,"c.PSA_ECC_CURVE_SECT409K1"],PSA_ECC_CURVE_SECT409R1:[0,0,1,"c.PSA_ECC_CURVE_SECT409R1"],PSA_ECC_CURVE_SECT571K1:[0,0,1,"c.PSA_ECC_CURVE_SECT571K1"],PSA_ECC_CURVE_SECT571R1:[0,0,1,"c.PSA_ECC_CURVE_SECT571R1"],PSA_ECDSA_SIGNATURE_SIZE:[0,0,1,"c.PSA_ECDSA_SIGNATURE_SIZE"],PSA_ERROR_ALREADY_EXISTS:[0,0,1,"c.PSA_ERROR_ALREADY_EXISTS"],PSA_ERROR_BAD_STATE:[0,0,1,"c.PSA_ERROR_BAD_STATE"],PSA_ERROR_BUFFER_TOO_SMALL:[0,0,1,"c.PSA_ERROR_BUFFER_TOO_SMALL"],PSA_ERROR_COMMUNICATION_FAILURE:[0,0,1,"c.PSA_ERROR_COMMUNICATION_FAILURE"],PSA_ERROR_CORRUPTION_DETECTED:[0,0,1,"c.PSA_ERROR_CORRUPTION_DETECTED"],PSA_ERROR_DOES_NOT_EXIST:[0,0,1,"c.PSA_ERROR_DOES_NOT_EXIST"],PSA_ERROR_GENERIC_ERROR:[0,0,1,"c.PSA_ERROR_GENERIC_ERROR"],PSA_ERROR_HARDWARE_FAILURE:[0,0,1,"c.PSA_ERROR_HARDWARE_FAILURE"],PSA_ERROR_INSUFFICIENT_DATA:[0,0,1,"c.PSA_ERROR_INSUFFICIENT_DATA"],PSA_ERROR_INSUFFICIENT_ENTROPY:[0,0,1,"c.PSA_ERROR_INSUFFICIENT_ENTROPY"],PSA_ERROR_INSUFFICIENT_MEMORY:[0,0,1,"c.PSA_ERROR_INSUFFICIENT_MEMORY"],PSA_ERROR_INSUFFICIENT_STORAGE:[0,0,1,"c.PSA_ERROR_INSUFFICIENT_STORAGE"],PSA_ERROR_INVALID_ARGUMENT:[0,0,1,"c.PSA_ERROR_INVALID_ARGUMENT"],PSA_ERROR_INVALID_HANDLE:[0,0,1,"c.PSA_ERROR_INVALID_HANDLE"],PSA_ERROR_INVALID_PADDING:[0,0,1,"c.PSA_ERROR_INVALID_PADDING"],PSA_ERROR_INVALID_SIGNATURE:[0,0,1,"c.PSA_ERROR_INVALID_SIGNATURE"],PSA_ERROR_NOT_PERMITTED:[0,0,1,"c.PSA_ERROR_NOT_PERMITTED"],PSA_ERROR_NOT_SUPPORTED:[0,0,1,"c.PSA_ERROR_NOT_SUPPORTED"],PSA_ERROR_STORAGE_FAILURE:[0,0,1,"c.PSA_ERROR_STORAGE_FAILURE"],PSA_HASH_MAX_SIZE:[0,0,1,"c.PSA_HASH_MAX_SIZE"],PSA_HASH_OPERATION_INIT:[0,0,1,"c.PSA_HASH_OPERATION_INIT"],PSA_HASH_SIZE:[0,0,1,"c.PSA_HASH_SIZE"],PSA_HMAC_MAX_HASH_BLOCK_SIZE:[0,0,1,"c.PSA_HMAC_MAX_HASH_BLOCK_SIZE"],PSA_KEY_ATTRIBUTES_INIT:[0,0,1,"c.PSA_KEY_ATTRIBUTES_INIT"],PSA_KEY_DERIVATION_INPUT_INFO:[0,0,1,"c.PSA_KEY_DERIVATION_INPUT_INFO"],PSA_KEY_DERIVATION_INPUT_LABEL:[0,0,1,"c.PSA_KEY_DERIVATION_INPUT_LABEL"],PSA_KEY_DERIVATION_INPUT_SALT:[0,0,1,"c.PSA_KEY_DERIVATION_INPUT_SALT"],PSA_KEY_DERIVATION_INPUT_SECRET:[0,0,1,"c.PSA_KEY_DERIVATION_INPUT_SECRET"],PSA_KEY_DERIVATION_INPUT_SEED:[0,0,1,"c.PSA_KEY_DERIVATION_INPUT_SEED"],PSA_KEY_DERIVATION_OPERATION_INIT:[0,0,1,"c.PSA_KEY_DERIVATION_OPERATION_INIT"],PSA_KEY_DERIVATION_UNLIMITED_CAPACITY:[0,0,1,"c.PSA_KEY_DERIVATION_UNLIMITED_CAPACITY"],PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE:[0,0,1,"c.PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE"],PSA_KEY_EXPORT_DSA_KEY_PAIR_MAX_SIZE:[0,0,1,"c.PSA_KEY_EXPORT_DSA_KEY_PAIR_MAX_SIZE"],PSA_KEY_EXPORT_DSA_PUBLIC_KEY_MAX_SIZE:[0,0,1,"c.PSA_KEY_EXPORT_DSA_PUBLIC_KEY_MAX_SIZE"],PSA_KEY_EXPORT_ECC_KEY_PAIR_MAX_SIZE:[0,0,1,"c.PSA_KEY_EXPORT_ECC_KEY_PAIR_MAX_SIZE"],PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE:[0,0,1,"c.PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE"],PSA_KEY_EXPORT_MAX_SIZE:[0,0,1,"c.PSA_KEY_EXPORT_MAX_SIZE"],PSA_KEY_EXPORT_RSA_KEY_PAIR_MAX_SIZE:[0,0,1,"c.PSA_KEY_EXPORT_RSA_KEY_PAIR_MAX_SIZE"],PSA_KEY_EXPORT_RSA_PUBLIC_KEY_MAX_SIZE:[0,0,1,"c.PSA_KEY_EXPORT_RSA_PUBLIC_KEY_MAX_SIZE"],PSA_KEY_ID_USER_MAX:[0,0,1,"c.PSA_KEY_ID_USER_MAX"],PSA_KEY_ID_USER_MIN:[0,0,1,"c.PSA_KEY_ID_USER_MIN"],PSA_KEY_ID_VENDOR_MAX:[0,0,1,"c.PSA_KEY_ID_VENDOR_MAX"],PSA_KEY_ID_VENDOR_MIN:[0,0,1,"c.PSA_KEY_ID_VENDOR_MIN"],PSA_KEY_LIFETIME_PERSISTENT:[0,0,1,"c.PSA_KEY_LIFETIME_PERSISTENT"],PSA_KEY_LIFETIME_VOLATILE:[0,0,1,"c.PSA_KEY_LIFETIME_VOLATILE"],PSA_KEY_TYPE_AES:[0,0,1,"c.PSA_KEY_TYPE_AES"],PSA_KEY_TYPE_ARC4:[0,0,1,"c.PSA_KEY_TYPE_ARC4"],PSA_KEY_TYPE_CAMELLIA:[0,0,1,"c.PSA_KEY_TYPE_CAMELLIA"],PSA_KEY_TYPE_CATEGORY_FLAG_PAIR:[0,0,1,"c.PSA_KEY_TYPE_CATEGORY_FLAG_PAIR"],PSA_KEY_TYPE_CATEGORY_KEY_PAIR:[0,0,1,"c.PSA_KEY_TYPE_CATEGORY_KEY_PAIR"],PSA_KEY_TYPE_CATEGORY_MASK:[0,0,1,"c.PSA_KEY_TYPE_CATEGORY_MASK"],PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY:[0,0,1,"c.PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY"],PSA_KEY_TYPE_CATEGORY_RAW:[0,0,1,"c.PSA_KEY_TYPE_CATEGORY_RAW"],PSA_KEY_TYPE_CATEGORY_SYMMETRIC:[0,0,1,"c.PSA_KEY_TYPE_CATEGORY_SYMMETRIC"],PSA_KEY_TYPE_CHACHA20:[0,0,1,"c.PSA_KEY_TYPE_CHACHA20"],PSA_KEY_TYPE_DERIVE:[0,0,1,"c.PSA_KEY_TYPE_DERIVE"],PSA_KEY_TYPE_DES:[0,0,1,"c.PSA_KEY_TYPE_DES"],PSA_KEY_TYPE_DH_GROUP_MASK:[0,0,1,"c.PSA_KEY_TYPE_DH_GROUP_MASK"],PSA_KEY_TYPE_DH_KEY_PAIR:[0,0,1,"c.PSA_KEY_TYPE_DH_KEY_PAIR"],PSA_KEY_TYPE_DH_KEY_PAIR_BASE:[0,0,1,"c.PSA_KEY_TYPE_DH_KEY_PAIR_BASE"],PSA_KEY_TYPE_DH_PUBLIC_KEY:[0,0,1,"c.PSA_KEY_TYPE_DH_PUBLIC_KEY"],PSA_KEY_TYPE_DH_PUBLIC_KEY_BASE:[0,0,1,"c.PSA_KEY_TYPE_DH_PUBLIC_KEY_BASE"],PSA_KEY_TYPE_ECC_CURVE_MASK:[0,0,1,"c.PSA_KEY_TYPE_ECC_CURVE_MASK"],PSA_KEY_TYPE_ECC_KEY_PAIR:[0,0,1,"c.PSA_KEY_TYPE_ECC_KEY_PAIR"],PSA_KEY_TYPE_ECC_KEY_PAIR_BASE:[0,0,1,"c.PSA_KEY_TYPE_ECC_KEY_PAIR_BASE"],PSA_KEY_TYPE_ECC_PUBLIC_KEY:[0,0,1,"c.PSA_KEY_TYPE_ECC_PUBLIC_KEY"],PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE:[0,0,1,"c.PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE"],PSA_KEY_TYPE_GET_CURVE:[0,0,1,"c.PSA_KEY_TYPE_GET_CURVE"],PSA_KEY_TYPE_GET_GROUP:[0,0,1,"c.PSA_KEY_TYPE_GET_GROUP"],PSA_KEY_TYPE_HMAC:[0,0,1,"c.PSA_KEY_TYPE_HMAC"],PSA_KEY_TYPE_IS_ASYMMETRIC:[0,0,1,"c.PSA_KEY_TYPE_IS_ASYMMETRIC"],PSA_KEY_TYPE_IS_DH:[0,0,1,"c.PSA_KEY_TYPE_IS_DH"],PSA_KEY_TYPE_IS_DH_KEY_PAIR:[0,0,1,"c.PSA_KEY_TYPE_IS_DH_KEY_PAIR"],PSA_KEY_TYPE_IS_DH_PUBLIC_KEY:[0,0,1,"c.PSA_KEY_TYPE_IS_DH_PUBLIC_KEY"],PSA_KEY_TYPE_IS_ECC:[0,0,1,"c.PSA_KEY_TYPE_IS_ECC"],PSA_KEY_TYPE_IS_ECC_KEY_PAIR:[0,0,1,"c.PSA_KEY_TYPE_IS_ECC_KEY_PAIR"],PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY:[0,0,1,"c.PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY"],PSA_KEY_TYPE_IS_KEY_PAIR:[0,0,1,"c.PSA_KEY_TYPE_IS_KEY_PAIR"],PSA_KEY_TYPE_IS_PUBLIC_KEY:[0,0,1,"c.PSA_KEY_TYPE_IS_PUBLIC_KEY"],PSA_KEY_TYPE_IS_RSA:[0,0,1,"c.PSA_KEY_TYPE_IS_RSA"],PSA_KEY_TYPE_IS_UNSTRUCTURED:[0,0,1,"c.PSA_KEY_TYPE_IS_UNSTRUCTURED"],PSA_KEY_TYPE_IS_VENDOR_DEFINED:[0,0,1,"c.PSA_KEY_TYPE_IS_VENDOR_DEFINED"],PSA_KEY_TYPE_KEY_PAIR_OF_PUBLIC_KEY:[0,0,1,"c.PSA_KEY_TYPE_KEY_PAIR_OF_PUBLIC_KEY"],PSA_KEY_TYPE_NONE:[0,0,1,"c.PSA_KEY_TYPE_NONE"],PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR:[0,0,1,"c.PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR"],PSA_KEY_TYPE_RAW_DATA:[0,0,1,"c.PSA_KEY_TYPE_RAW_DATA"],PSA_KEY_TYPE_RSA_KEY_PAIR:[0,0,1,"c.PSA_KEY_TYPE_RSA_KEY_PAIR"],PSA_KEY_TYPE_RSA_PUBLIC_KEY:[0,0,1,"c.PSA_KEY_TYPE_RSA_PUBLIC_KEY"],PSA_KEY_TYPE_VENDOR_FLAG:[0,0,1,"c.PSA_KEY_TYPE_VENDOR_FLAG"],PSA_KEY_USAGE_COPY:[0,0,1,"c.PSA_KEY_USAGE_COPY"],PSA_KEY_USAGE_DECRYPT:[0,0,1,"c.PSA_KEY_USAGE_DECRYPT"],PSA_KEY_USAGE_DERIVE:[0,0,1,"c.PSA_KEY_USAGE_DERIVE"],PSA_KEY_USAGE_ENCRYPT:[0,0,1,"c.PSA_KEY_USAGE_ENCRYPT"],PSA_KEY_USAGE_EXPORT:[0,0,1,"c.PSA_KEY_USAGE_EXPORT"],PSA_KEY_USAGE_SIGN:[0,0,1,"c.PSA_KEY_USAGE_SIGN"],PSA_KEY_USAGE_VERIFY:[0,0,1,"c.PSA_KEY_USAGE_VERIFY"],PSA_MAC_FINAL_SIZE:[0,0,1,"c.PSA_MAC_FINAL_SIZE"],PSA_MAC_MAX_SIZE:[0,0,1,"c.PSA_MAC_MAX_SIZE"],PSA_MAC_OPERATION_INIT:[0,0,1,"c.PSA_MAC_OPERATION_INIT"],PSA_MAC_TRUNCATED_LENGTH:[0,0,1,"c.PSA_MAC_TRUNCATED_LENGTH"],PSA_MAC_TRUNCATION_OFFSET:[0,0,1,"c.PSA_MAC_TRUNCATION_OFFSET"],PSA_MAX_BLOCK_CIPHER_BLOCK_SIZE:[0,0,1,"c.PSA_MAX_BLOCK_CIPHER_BLOCK_SIZE"],PSA_ROUND_UP_TO_MULTIPLE:[0,0,1,"c.PSA_ROUND_UP_TO_MULTIPLE"],PSA_RSA_MINIMUM_PADDING_SIZE:[0,0,1,"c.PSA_RSA_MINIMUM_PADDING_SIZE"],PSA_SUCCESS:[0,0,1,"c.PSA_SUCCESS"],PSA_VENDOR_ECC_MAX_CURVE_BITS:[0,0,1,"c.PSA_VENDOR_ECC_MAX_CURVE_BITS"],PSA_VENDOR_RSA_MAX_KEY_BITS:[0,0,1,"c.PSA_VENDOR_RSA_MAX_KEY_BITS"],PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE:[0,0,1,"c.PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE"],psa_aead_abort:[0,1,1,"c.psa_aead_abort"],psa_aead_decrypt:[0,1,1,"c.psa_aead_decrypt"],psa_aead_decrypt_setup:[0,1,1,"c.psa_aead_decrypt_setup"],psa_aead_encrypt:[0,1,1,"c.psa_aead_encrypt"],psa_aead_encrypt_setup:[0,1,1,"c.psa_aead_encrypt_setup"],psa_aead_finish:[0,1,1,"c.psa_aead_finish"],psa_aead_generate_nonce:[0,1,1,"c.psa_aead_generate_nonce"],psa_aead_operation_init:[0,1,1,"c.psa_aead_operation_init"],psa_aead_operation_t:[0,2,1,"c.psa_aead_operation_t"],psa_aead_set_lengths:[0,1,1,"c.psa_aead_set_lengths"],psa_aead_set_nonce:[0,1,1,"c.psa_aead_set_nonce"],psa_aead_update:[0,1,1,"c.psa_aead_update"],psa_aead_update_ad:[0,1,1,"c.psa_aead_update_ad"],psa_aead_verify:[0,1,1,"c.psa_aead_verify"],psa_algorithm_t:[0,2,1,"c.psa_algorithm_t"],psa_asymmetric_decrypt:[0,1,1,"c.psa_asymmetric_decrypt"],psa_asymmetric_encrypt:[0,1,1,"c.psa_asymmetric_encrypt"],psa_asymmetric_sign:[0,1,1,"c.psa_asymmetric_sign"],psa_asymmetric_verify:[0,1,1,"c.psa_asymmetric_verify"],psa_cipher_abort:[0,1,1,"c.psa_cipher_abort"],psa_cipher_decrypt:[0,1,1,"c.psa_cipher_decrypt"],psa_cipher_decrypt_setup:[0,1,1,"c.psa_cipher_decrypt_setup"],psa_cipher_encrypt:[0,1,1,"c.psa_cipher_encrypt"],psa_cipher_encrypt_setup:[0,1,1,"c.psa_cipher_encrypt_setup"],psa_cipher_finish:[0,1,1,"c.psa_cipher_finish"],psa_cipher_generate_iv:[0,1,1,"c.psa_cipher_generate_iv"],psa_cipher_operation_init:[0,1,1,"c.psa_cipher_operation_init"],psa_cipher_operation_t:[0,2,1,"c.psa_cipher_operation_t"],psa_cipher_set_iv:[0,1,1,"c.psa_cipher_set_iv"],psa_cipher_update:[0,1,1,"c.psa_cipher_update"],psa_close_key:[0,1,1,"c.psa_close_key"],psa_copy_key:[0,1,1,"c.psa_copy_key"],psa_crypto_init:[0,1,1,"c.psa_crypto_init"],psa_destroy_key:[0,1,1,"c.psa_destroy_key"],psa_dh_group_t:[0,2,1,"c.psa_dh_group_t"],psa_ecc_curve_t:[0,2,1,"c.psa_ecc_curve_t"],psa_export_key:[0,1,1,"c.psa_export_key"],psa_export_public_key:[0,1,1,"c.psa_export_public_key"],psa_generate_key:[0,1,1,"c.psa_generate_key"],psa_generate_random:[0,1,1,"c.psa_generate_random"],psa_get_key_algorithm:[0,1,1,"c.psa_get_key_algorithm"],psa_get_key_attributes:[0,1,1,"c.psa_get_key_attributes"],psa_get_key_bits:[0,1,1,"c.psa_get_key_bits"],psa_get_key_id:[0,1,1,"c.psa_get_key_id"],psa_get_key_lifetime:[0,1,1,"c.psa_get_key_lifetime"],psa_get_key_type:[0,1,1,"c.psa_get_key_type"],psa_get_key_usage_flags:[0,1,1,"c.psa_get_key_usage_flags"],psa_hash_abort:[0,1,1,"c.psa_hash_abort"],psa_hash_clone:[0,1,1,"c.psa_hash_clone"],psa_hash_compare:[0,1,1,"c.psa_hash_compare"],psa_hash_compute:[0,1,1,"c.psa_hash_compute"],psa_hash_finish:[0,1,1,"c.psa_hash_finish"],psa_hash_operation_init:[0,1,1,"c.psa_hash_operation_init"],psa_hash_operation_t:[0,2,1,"c.psa_hash_operation_t"],psa_hash_setup:[0,1,1,"c.psa_hash_setup"],psa_hash_update:[0,1,1,"c.psa_hash_update"],psa_hash_verify:[0,1,1,"c.psa_hash_verify"],psa_import_key:[0,1,1,"c.psa_import_key"],psa_key_attributes_init:[0,1,1,"c.psa_key_attributes_init"],psa_key_attributes_t:[0,2,1,"c.psa_key_attributes_t"],psa_key_derivation_abort:[0,1,1,"c.psa_key_derivation_abort"],psa_key_derivation_get_capacity:[0,1,1,"c.psa_key_derivation_get_capacity"],psa_key_derivation_input_bytes:[0,1,1,"c.psa_key_derivation_input_bytes"],psa_key_derivation_input_key:[0,1,1,"c.psa_key_derivation_input_key"],psa_key_derivation_key_agreement:[0,1,1,"c.psa_key_derivation_key_agreement"],psa_key_derivation_operation_init:[0,1,1,"c.psa_key_derivation_operation_init"],psa_key_derivation_operation_t:[0,2,1,"c.psa_key_derivation_operation_t"],psa_key_derivation_output_bytes:[0,1,1,"c.psa_key_derivation_output_bytes"],psa_key_derivation_output_key:[0,1,1,"c.psa_key_derivation_output_key"],psa_key_derivation_set_capacity:[0,1,1,"c.psa_key_derivation_set_capacity"],psa_key_derivation_setup:[0,1,1,"c.psa_key_derivation_setup"],psa_key_derivation_step_t:[0,2,1,"c.psa_key_derivation_step_t"],psa_key_handle_t:[0,2,1,"c.psa_key_handle_t"],psa_key_id_t:[0,2,1,"c.psa_key_id_t"],psa_key_lifetime_t:[0,2,1,"c.psa_key_lifetime_t"],psa_key_type_t:[0,2,1,"c.psa_key_type_t"],psa_key_usage_t:[0,2,1,"c.psa_key_usage_t"],psa_mac_abort:[0,1,1,"c.psa_mac_abort"],psa_mac_compute:[0,1,1,"c.psa_mac_compute"],psa_mac_operation_init:[0,1,1,"c.psa_mac_operation_init"],psa_mac_operation_t:[0,2,1,"c.psa_mac_operation_t"],psa_mac_sign_finish:[0,1,1,"c.psa_mac_sign_finish"],psa_mac_sign_setup:[0,1,1,"c.psa_mac_sign_setup"],psa_mac_update:[0,1,1,"c.psa_mac_update"],psa_mac_verify:[0,1,1,"c.psa_mac_verify"],psa_mac_verify_finish:[0,1,1,"c.psa_mac_verify_finish"],psa_mac_verify_setup:[0,1,1,"c.psa_mac_verify_setup"],psa_open_key:[0,1,1,"c.psa_open_key"],psa_raw_key_agreement:[0,1,1,"c.psa_raw_key_agreement"],psa_reset_key_attributes:[0,1,1,"c.psa_reset_key_attributes"],psa_set_key_algorithm:[0,1,1,"c.psa_set_key_algorithm"],psa_set_key_bits:[0,1,1,"c.psa_set_key_bits"],psa_set_key_id:[0,1,1,"c.psa_set_key_id"],psa_set_key_lifetime:[0,1,1,"c.psa_set_key_lifetime"],psa_set_key_type:[0,1,1,"c.psa_set_key_type"],psa_set_key_usage_flags:[0,1,1,"c.psa_set_key_usage_flags"],psa_status_t:[0,2,1,"c.psa_status_t"]}},objnames:{"0":["c","macro","C macro"],"1":["c","function","C function"],"2":["c","type","C type"]},objtypes:{"0":"c:macro","1":"c:function","2":"c:type"},terms:{"0x04":0,"3de":0,"56a":0,"byte":[0,1],"case":[0,2],"char":0,"const":[0,1],"default":[0,1],"export":[1,2],"function":2,"import":[1,2],"long":[0,1,2],"new":[0,1,2],"null":[0,1],"public":[0,1],"return":[0,2],"short":[0,1],"static":[0,1],"transient":0,"true":[0,1],"try":1,"void":[0,1],"while":[0,1,2],AES:[0,1],DES:0,For:[0,1],Its:0,NOT:0,Such:[0,1],TLS:[0,2],That:[0,1],The:[0,1,2],Then:0,There:[0,1],These:1,Use:[0,2],Using:1,XTS:0,_unsigned_integral_type_:0,abil:1,abl:[0,1],abort:[0,1],about:[0,1],abov:1,acceler:1,accept:0,access:[0,1,2],accessor:1,accident:0,accord:[0,1],accordingli:[0,1],account:[0,1],across:0,act:1,action:[0,1],activ:[0,1],actual:0,ad_length:0,add:[0,2],addit:[0,2],addition:1,additional_data:0,additional_data_length:0,adequ:1,adversari:0,aead:[1,2],aead_alg:0,affect:[0,1,2],aforement:1,after:[0,2],again:[0,1],against:[0,1],agil:1,agreement:[0,2],alarm:0,alg:[0,2],algorithm:2,align:[0,2],all:[0,1],alloc:[0,1,2],allow:[0,1,2],almost:1,alreadi:[0,1],also:[0,1,2],altern:1,although:0,altogeth:1,alwai:[0,2],among:1,amount:[0,1],analys:1,analysi:1,ani:[0,1],anoth:[0,1],ansi:0,anywher:0,apart:1,api:1,append:0,appli:[0,1],applic:[0,2],approach:1,appropri:[0,1],arbitrari:[0,1],arc4:0,architectur:[0,2],area:[0,1],argument:[0,1,2],arm:1,around:1,arrai:[0,1],ask:0,aspect:2,assembl:1,asset:1,assign:[0,1],associ:[1,2],assum:1,assumpt:[0,2],asymmetr:2,atom:1,attack:[0,2],attempt:[0,1],attest:2,attibut:1,attribut:[1,2],authent:2,author:1,automat:0,auxiliari:[0,2],avail:[0,1],avoid:[0,1,2],awar:[0,1],back:1,backend:1,bad:1,base:[0,1],becaus:[0,1],becom:[0,1],been:[0,1],befor:[0,1,2],begin:0,behav:1,behavior:[0,2],being:[0,1],below:1,benefit:0,bernstein:0,best:[0,1],beta:2,between:[0,2],bewar:0,beyond:[0,1],bias:[0,1],big:0,binari:0,bit:[0,1],bitmask:1,bitwis:0,block:[0,1,2],block_siz:0,bluetooth:1,bodi:1,boot:2,both:[0,1,2],bound:[0,1],boundari:[0,1],branch:1,breach:0,breakdown:0,broken:1,buffer:[0,2],buffer_length:0,buffer_s:0,build:[0,1,2],built:[0,1],burnt:1,bypass:0,c89:1,c99:1,cach:1,calcul:[0,1,2],call:[0,2],caller:[0,1],camellia:0,can:[0,1],candid:0,cannot:[0,1],capabl:1,capac:[0,1],care:[0,1],carefulli:1,carri:[0,1],categori:1,caus:[0,1],cbc:0,ccm:[0,1],ceil:0,certain:[0,1,2],chacha20:0,chacha20_poly1305:0,chain:0,chanc:1,chang:[0,1],channel:1,characterist:1,check:[0,2],chip:1,choic:[0,2],choos:[0,1],chosen:0,chunk:1,cipher:[1,2],ciphersuit:0,ciphertext:0,ciphertext_length:0,ciphertext_s:0,circumst:1,clarif:2,clarifi:2,clariti:2,clean:[0,2],cleanup:2,clear:1,clearli:0,cleartext:1,client:2,clienthello:0,clone:0,close:[0,1],code:[1,2],coeffici:0,collect:1,combin:[0,1],common:[0,1],commonli:1,commun:[0,1],compact:0,companion:1,compar:[0,1],comparison:0,compat:0,compil:[0,1],complet:[0,1],complex:1,complianc:0,compliant:1,compon:1,compos:[0,1],compris:0,compromis:[0,1],comput:[0,1],concaten:0,concatent:0,conceptu:1,concern:[0,1],concurr:2,condit:[0,1,2],confidenti:[0,1],conflict:1,conform:[0,1],connect:1,consequ:[0,1],consequenti:1,conserv:[0,1],consid:[0,1],consider:[0,2],consist:[0,1,2],constant:[0,1],constrain:2,constraint:[0,1],construct:[0,1],consum:0,consumpt:1,contain:[0,1,2],content:[0,1],context:1,continu:0,control:[0,1],convei:1,convent:2,convers:1,convert:0,coordin:0,copi:[0,1],copyabl:1,corner:2,correct:[0,1,2],correctli:[0,1],correspond:[0,1],corrupt:[0,1],could:[0,1],counter:[0,1],countermeasur:0,cover:1,creat:[0,1,2],creation:[0,2],credenti:2,crypto:1,crypto_platform:1,crypto_struct:1,cryptograph:[0,2],cryptoprocessor:[0,2],csprng:1,ctr:0,current:[0,1,2],curv:[0,2],curve25519:0,curve448:0,curve_bit:0,custom:[0,1],d_a:0,d_b:0,danger:1,data:[1,2],data_length:0,data_s:0,date:2,debug:1,declar:[0,1,2],decreas:0,decrypt:[0,1],defend:1,defin:[0,1,2],definit:[1,2],delai:0,deliveri:1,deni:0,depend:[0,1],deploi:1,deprec:0,der:0,derefer:1,deriv:2,describ:[0,1],descript:[0,1,2],design:[0,2],desir:[0,1],destroi:[0,1,2],destruct:[0,1],detail:[0,1],detect:[0,2],detector:0,determin:[0,1],determinist:[0,1],develop:1,devic:[0,2],diagnos:1,did:1,dies:0,differ:[0,1],diffi:[0,1],difficult:1,digest:[1,2],digestinfo:0,direct:[0,1],directli:[0,1,2],discard:0,disclosur:1,discoveri:1,dispatch:1,distinguish:0,document:[0,1],doe:[0,1,2],doesn:0,domain:0,don:1,done:1,down:[0,1],draft:1,draw:0,drawn:0,driver:1,dsa:0,due:[0,1],dure:[0,1],dynam:1,each:[0,1],eas:2,easi:1,ecc:0,ecdh:0,ecdsa:0,eci:1,ecpoint:0,ecprivatekei:0,ed448:0,eddsa:1,edit:1,effect:0,effort:0,either:[0,1],element:[0,1,2],ellipt:0,emiss:1,empti:0,enabl:1,encod:[0,1],encompass:0,encourag:[0,1],encrypt:2,end:[0,1],endian:0,enforc:[0,1],english:2,enough:[0,1],ensur:[0,1],enter:0,enterpris:1,entir:1,entri:0,entropi:[0,1],enumer:[0,1],environ:1,equal:0,equival:[0,1],eras:0,err:0,erron:0,error:2,especi:1,essenti:0,establish:1,etc:[0,1],evalu:0,even:[0,1],event:0,eventu:0,everi:1,everyth:1,exactli:[0,1],exampl:[0,2],except:[0,1],exchang:[0,1],exclus:[0,1],execut:[0,1],exhaust:1,exist:[0,1,2],expand:[0,1],expans:[0,1],expect:[0,1],explain:1,explicitli:[0,1],expon:0,exponent1:0,exponent2:0,expos:[0,1],express:1,extend:0,extens:[0,1],extent:1,extern:[0,1],extract:[0,1],f_p:0,f_q:0,facilit:1,fact:0,factori:[0,2],fail:[0,1],failur:[0,1],fals:0,famili:[0,1],far:[0,1],fashion:1,favor:1,featur:1,few:1,fewer:0,field:[0,1],file:1,fill:2,finish:[0,1],finit:[0,1],fip:0,firmwar:1,first:[0,1,2],fit:0,flag:[0,1],flaw:1,flow:1,follow:[0,1,2],foo:1,foo_length:1,foo_siz:1,forbid:2,forbidden:0,forc:0,forcibl:0,form:[0,1],format:[0,1,2],forward:0,fragment:0,free:[0,1,2],freed:1,freedom:1,freeli:0,freshli:0,friendli:1,from:[0,1],frontend:1,full:[0,1],fulli:1,further:1,furthermor:0,futur:[0,2],gcm:[0,1],gener:2,get:0,give:[0,1,2],given:[0,1,2],glitch:1,global:0,goal:[0,2],goldilock:0,good:1,group:0,guarante:[0,1],guess:0,habitu:1,had:[0,1],half:2,halt:1,hamburg:0,handl:[0,2],handle_error:0,handshak:0,happen:[0,1],harder:1,hardwar:[0,2],has:[0,1],hash:[0,2],hash_alg:0,hash_length:0,hash_siz:0,have:[0,1,2],header:1,heap:1,hellman:[0,1],here:[0,1,2],high:1,higher:1,highest:1,highli:[0,1],hkdf:0,hkdf_alg:0,hmac:[0,1],hmac_alg:0,hold:[0,1],holist:1,host:0,how:[0,1,2],howev:[0,1],hsm:1,hybrid:1,ident:[0,1],identifi:[0,1,2],illustr:0,immedi:1,impact:1,implement:2,implic:0,imposs:[0,1],improp:0,improv:2,inact:[0,1],includ:[0,1],incompat:0,incorrect:0,independ:[0,1],index:2,indic:[0,1,2],indiffer:0,indirect:0,indirectli:1,indistinguish:0,individu:[0,1],industri:1,inescap:1,info:0,inform:[0,1],initi:[1,2],input:[0,2],input_length:0,insecur:1,insid:[0,1],instanc:1,instanti:1,instead:[0,1,2],insuffici:[0,1],int32_t:0,integ:[0,1],integr:[0,1],intend:0,interchang:1,interest:0,interfac:[0,2],intermedi:[0,1],intern:1,interoper:1,interpret:0,interrupt:1,introduct:2,invalid:[0,1],invers:0,involv:[0,1],iot:1,isn:1,isol:[0,2],issu:1,item:0,its:[0,1,2],itself:0,iv_length:0,iv_siz:0,just:0,ka_alg:0,kdf_alg:0,keep:[0,1],kei:2,kept:1,kernel:1,key_bit:0,key_typ:0,keystor:[0,2],kind:[0,1],known:1,label:0,lack:[0,1],land:1,languag:[1,2],larg:0,larger:[0,1],last:[0,1],later:0,latest:1,latter:0,layer:1,lead:0,leak:[0,1],leakag:1,least:[0,1],leav:1,led:0,left:0,legaci:[0,1],length:[0,1,2],less:0,let:0,level:1,librari:2,lifecycl:1,lifetim:[1,2],like:0,limit:1,link:1,linkag:0,list:[0,1,2],literatur:1,littl:[0,1],lnc:0,local:1,locat:[0,1],log:[0,1],log_2:0,logic:[0,1],longer:[0,1,2],loss:0,low:1,lowest:1,mac:[0,1],mac_alg:0,mac_length:0,mac_siz:0,machin:1,macro:2,made:0,mai:[0,1,2],main:1,major:1,make:[0,1,2],malici:1,malloc:0,manag:2,mandat:2,mandatori:[0,1],mani:[0,1,2],manipul:1,manner:1,manufactur:1,marker:0,mask:0,master:[0,1],mastersecret:0,match:0,materi:[0,1,2],maximum:[0,1,2],mean:[0,1],meant:1,mechan:[0,1],media:0,meet:[1,2],memcmp:0,memori:[0,2],memset:0,mention:1,mere:[0,1],messag:[1,2],metadata:[0,1,2],method:[0,1,2],mgf1:0,microcontrol:1,middl:0,might:0,mind:0,minim:[0,1],minimum:[0,2],miss:2,mistak:1,misus:1,mod:0,mode:[0,1],model:1,modern:1,modifi:[0,1],modul:0,modular:1,modulu:0,montgomeri:[0,2],more:[0,1,2],most:[0,1,2],much:[0,1],multi:2,multipart:[0,2],multipl:[0,1,2],multiprocess:1,multitask:1,multithread:1,must:[0,1],mutual:1,name:[0,1,2],nearest:0,necessari:[0,1],need:[0,1],neg:0,neither:0,network:2,never:[0,1],newli:0,next:[0,1],nfc:1,nist:0,non:[0,1],nonc:[0,1,2],nonce_length:0,nonce_s:0,none:0,nonvolatil:1,nonzero:0,nor:[0,1],norm:1,normal:[0,1],note:[0,1],now:[0,1,2],number:[0,1,2],oaep:0,obei:1,object:[0,1,2],observ:[0,1],obsolet:2,obtain:1,occur:[0,1],octet:[0,1],offer:[0,1],offset:1,often:1,omit:[0,1],onc:[0,1],one:[0,1],ones:1,ongo:0,onli:[0,1],onward:0,opaqu:[0,1],open:[0,1,2],oper:[0,2],opposit:1,optim:1,option:[0,2],oracl:0,order:[0,1],origin:[0,1],other:2,otherwis:[0,1],out:[0,1],outcom:1,output:[0,2],output_length:0,output_s:0,outsid:[0,1],over:[0,1],overal:1,overflow:0,overlap:2,overview:2,overwrit:0,own:[0,1],ownership:1,pad:0,pai:1,pair:[0,2],paramet:[0,2],parametr:[0,1],pariti:0,part:[0,1,2],parti:[0,1],partial:1,particular:[0,1],partit:2,pass:[0,1,2],past:1,pattern:[0,1],peer:[0,1],peer_kei:0,peer_key_length:0,per:0,perfom:0,perform:[0,1],period:1,perman:0,permiss:[0,1],permit:[0,1,2],persist:[0,2],phase:[0,1],philosophi:2,physic:[0,1],pkc:0,pkcs1:0,place:[0,1],plain:0,plaintext:[0,1],plaintext_length:[0,2],plaintext_s:0,plan:1,platform:2,pleas:1,plu:1,point:[0,1],pointer:[0,2],polici:2,poly1305:0,popul:[0,1],port:2,possibl:[0,1],potenti:1,power:[0,1],practic:[0,1],pre:[0,1],preced:0,precis:[0,1],predefin:1,predict:1,prefer:0,prepar:0,prepend:0,present:[0,1],preserv:0,presharedkei:0,prevent:1,previou:[0,1,2],previous:0,prf:0,primari:1,primarili:0,prime1:0,prime2:0,prime:0,primit:1,privat:[0,1],private_kei:0,privateexpon:0,privatekei:0,privileg:1,prng:0,probabilist:0,procedur:1,process:[0,1],processor:2,produc:[0,1],product:0,profil:2,programm:1,proper:0,properli:1,proprietari:[0,1],protect:[0,1],protocol:[0,1],prove:1,provid:[0,1],provis:[0,2],psa:[0,1],psa__alg_aead_with_default_tag_length__cas:2,psa_abort_xxx:1,psa_aead_abort:2,psa_aead_decrypt:[1,2],psa_aead_decrypt_output_s:2,psa_aead_decrypt_setup:[1,2],psa_aead_encrypt:[1,2],psa_aead_encrypt_output_s:2,psa_aead_encrypt_setup:[1,2],psa_aead_finish:[1,2],psa_aead_finish_output_s:2,psa_aead_generate_iv:1,psa_aead_generate_nonc:[1,2],psa_aead_operation_:0,psa_aead_operation_init:2,psa_aead_operation_t:2,psa_aead_set_length:[1,2],psa_aead_set_nonc:[1,2],psa_aead_tag_length:2,psa_aead_tag_length_offset:2,psa_aead_upd:[1,2],psa_aead_update_ad:[1,2],psa_aead_update_output_s:2,psa_aead_verifi:[1,2],psa_aead_verify_output_s:2,psa_aead_xxx:0,psa_alg_aead_from_block_flag:2,psa_alg_aead_tag_length_mask:2,psa_alg_aead_with_default_tag_length:2,psa_alg_aead_with_tag_length:2,psa_alg_any_hash:2,psa_alg_arc4:2,psa_alg_category_aead:2,psa_alg_category_asymmetric_encrypt:2,psa_alg_category_ciph:2,psa_alg_category_hash:2,psa_alg_category_key_agr:2,psa_alg_category_key_deriv:2,psa_alg_category_mac:2,psa_alg_category_mask:2,psa_alg_category_sign:2,psa_alg_cbc_mac:2,psa_alg_cbc_no_pad:2,psa_alg_cbc_pkcs7:2,psa_alg_ccm:2,psa_alg_cfb:2,psa_alg_chacha20:2,psa_alg_chacha20_poly1305:2,psa_alg_cipher_from_block_flag:2,psa_alg_cipher_mac_bas:2,psa_alg_cipher_stream_flag:2,psa_alg_cmac:2,psa_alg_ctr:2,psa_alg_deterministic_ecdsa:2,psa_alg_deterministic_ecdsa_bas:2,psa_alg_dsa_deterministic_flag:0,psa_alg_ecdh:2,psa_alg_ecdsa:2,psa_alg_ecdsa_ani:2,psa_alg_ecdsa_bas:2,psa_alg_ecdsa_is_determinist:2,psa_alg_ffdh:2,psa_alg_full_length_mac:2,psa_alg_gcm:[1,2],psa_alg_gmac:2,psa_alg_hash_mask:2,psa_alg_hkdf:[1,2],psa_alg_hkdf_bas:2,psa_alg_hkdf_get_hash:2,psa_alg_hmac:2,psa_alg_hmac_bas:2,psa_alg_hmac_get_hash:2,psa_alg_is_aead:2,psa_alg_is_aead_on_block_ciph:2,psa_alg_is_asymmetric_encrypt:2,psa_alg_is_block_cipher_mac:2,psa_alg_is_ciph:2,psa_alg_is_deterministic_ecdsa:2,psa_alg_is_ecdh:2,psa_alg_is_ecdsa:2,psa_alg_is_ffdh:2,psa_alg_is_hash:2,psa_alg_is_hash_and_sign:2,psa_alg_is_hkdf:2,psa_alg_is_hmac:2,psa_alg_is_key_agr:2,psa_alg_is_key_deriv:2,psa_alg_is_key_derivation_or_agr:2,psa_alg_is_key_select:2,psa_alg_is_mac:2,psa_alg_is_randomized_ecdsa:2,psa_alg_is_raw_key_agr:2,psa_alg_is_rsa_oaep:2,psa_alg_is_rsa_pkcs1v15_sign:2,psa_alg_is_rsa_pss:2,psa_alg_is_sign:2,psa_alg_is_stream_ciph:2,psa_alg_is_tls12_prf:2,psa_alg_is_tls12_psk_to_m:2,psa_alg_is_vendor_defin:2,psa_alg_is_wildcard:2,psa_alg_key_agr:2,psa_alg_key_agreement_get_bas:2,psa_alg_key_agreement_get_kdf:2,psa_alg_key_agreement_mask:2,psa_alg_key_derivation_mask:2,psa_alg_mac_subcategory_mask:2,psa_alg_mac_truncation_mask:2,psa_alg_md2:2,psa_alg_md4:2,psa_alg_md5:2,psa_alg_ofb:2,psa_alg_ripemd160:2,psa_alg_rsa_oaep:2,psa_alg_rsa_oaep_bas:2,psa_alg_rsa_oaep_get_hash:2,psa_alg_rsa_pkcs1v15_crypt:2,psa_alg_rsa_pkcs1v15_sign:2,psa_alg_rsa_pkcs1v15_sign_bas:2,psa_alg_rsa_pkcs1v15_sign_raw:2,psa_alg_rsa_pss:2,psa_alg_rsa_pss_bas:2,psa_alg_sha256:0,psa_alg_sha3_224:2,psa_alg_sha3_256:2,psa_alg_sha3_384:2,psa_alg_sha3_512:2,psa_alg_sha_1:2,psa_alg_sha_224:2,psa_alg_sha_256:2,psa_alg_sha_384:2,psa_alg_sha_512:2,psa_alg_sha_512_224:2,psa_alg_sha_512_256:2,psa_alg_sign_get_hash:[1,2],psa_alg_tls12_prf:2,psa_alg_tls12_prf_bas:2,psa_alg_tls12_prf_get_hash:2,psa_alg_tls12_psk_to_m:2,psa_alg_tls12_psk_to_ms_bas:2,psa_alg_tls12_psk_to_ms_get_hash:2,psa_alg_tls12_psk_to_ms_max_psk_len:2,psa_alg_truncated_mac:2,psa_alg_vendor_flag:2,psa_alg_xt:2,psa_alg_xxx:0,psa_algorithm_t:[1,2],psa_asymmetric_decrypt:[1,2],psa_asymmetric_decrypt_output_s:2,psa_asymmetric_encrypt:[1,2],psa_asymmetric_encrypt_output_s:2,psa_asymmetric_sign:[1,2],psa_asymmetric_sign_output_s:2,psa_asymmetric_signature_max_s:2,psa_asymmetric_verifi:[1,2],psa_bits_to_byt:2,psa_block_cipher_block_s:2,psa_bytes_to_bit:2,psa_cipher_abort:2,psa_cipher_decrypt:[1,2],psa_cipher_decrypt_setup:[1,2],psa_cipher_encrypt:[1,2],psa_cipher_encrypt_setup:[1,2],psa_cipher_finish:[1,2],psa_cipher_generate_iv:[1,2],psa_cipher_operation_:0,psa_cipher_operation_init:[1,2],psa_cipher_operation_t:[1,2],psa_cipher_set_iv:[1,2],psa_cipher_upd:[1,2],psa_cipher_xxx:0,psa_close_kei:[1,2],psa_copy_kei:[1,2],psa_create_kei:2,psa_crypto_generator_init:2,psa_crypto_generator_t:2,psa_crypto_init:[1,2],psa_destroy_kei:[1,2],psa_dh_group_ffdhe2048:2,psa_dh_group_ffdhe3072:2,psa_dh_group_ffdhe4096:2,psa_dh_group_ffdhe6144:2,psa_dh_group_ffdhe8192:2,psa_dh_group_t:2,psa_ecc_curve_bit:2,psa_ecc_curve_brainpool_p256r1:2,psa_ecc_curve_brainpool_p384r1:2,psa_ecc_curve_brainpool_p512r1:2,psa_ecc_curve_brainpool_pxxx:0,psa_ecc_curve_curve25519:2,psa_ecc_curve_curve448:2,psa_ecc_curve_curvexxx:0,psa_ecc_curve_secp160k1:2,psa_ecc_curve_secp160r1:2,psa_ecc_curve_secp160r2:2,psa_ecc_curve_secp192k1:2,psa_ecc_curve_secp192r1:2,psa_ecc_curve_secp224k1:2,psa_ecc_curve_secp224r1:2,psa_ecc_curve_secp256k1:2,psa_ecc_curve_secp256r1:2,psa_ecc_curve_secp384r1:2,psa_ecc_curve_secp521r1:2,psa_ecc_curve_secpxxx:0,psa_ecc_curve_sect163k1:2,psa_ecc_curve_sect163r1:2,psa_ecc_curve_sect163r2:2,psa_ecc_curve_sect193r1:2,psa_ecc_curve_sect193r2:2,psa_ecc_curve_sect233k1:2,psa_ecc_curve_sect233r1:2,psa_ecc_curve_sect239k1:2,psa_ecc_curve_sect283k1:2,psa_ecc_curve_sect283r1:2,psa_ecc_curve_sect409k1:2,psa_ecc_curve_sect409r1:2,psa_ecc_curve_sect571k1:2,psa_ecc_curve_sect571r1:2,psa_ecc_curve_sectxxx:0,psa_ecc_curve_t:2,psa_ecdsa_signature_s:2,psa_encrypt_generate_iv:1,psa_error_already_exist:2,psa_error_bad_st:[1,2],psa_error_buffer_too_smal:[1,2],psa_error_communication_failur:[1,2],psa_error_corruption_detect:2,psa_error_does_not_exist:2,psa_error_empty_slot:2,psa_error_generic_error:2,psa_error_hardware_failur:[1,2],psa_error_insufficient_capac:[1,2],psa_error_insufficient_data:2,psa_error_insufficient_entropi:2,psa_error_insufficient_memori:[1,2],psa_error_insufficient_storag:2,psa_error_invalid_argu:2,psa_error_invalid_handl:2,psa_error_invalid_pad:2,psa_error_invalid_signatur:2,psa_error_not_permit:2,psa_error_not_support:2,psa_error_occupied_slot:2,psa_error_storage_failur:[1,2],psa_error_tampering_detect:[1,2],psa_error_unknown_error:2,psa_error_xxx:0,psa_export_kei:[1,2],psa_export_public_kei:[1,2],psa_generate_derived_kei:2,psa_generate_kei:[1,2],psa_generate_random:[1,2],psa_generate_random_kei:[],psa_generator_abort:2,psa_generator_import_kei:2,psa_generator_read:2,psa_generator_unbridled_capac:2,psa_get_generator_capac:2,psa_get_key_algorithm:2,psa_get_key_attribut:[1,2],psa_get_key_bit:2,psa_get_key_id:2,psa_get_key_inform:2,psa_get_key_lifetim:2,psa_get_key_typ:2,psa_get_key_usage_flag:2,psa_get_key_xxx:[0,1],psa_hash_abort:2,psa_hash_clon:2,psa_hash_compar:[1,2],psa_hash_comput:[1,2],psa_hash_finish:[1,2],psa_hash_max_s:2,psa_hash_operation_:0,psa_hash_operation_init:2,psa_hash_operation_t:2,psa_hash_s:2,psa_hash_setup:[1,2],psa_hash_upd:[1,2],psa_hash_verifi:[1,2],psa_hmac_max_hash_block_s:2,psa_import_kei:[1,2],psa_kdf_step_info:[],psa_kdf_step_secret:[],psa_kdf_step_xxx:2,psa_key_agr:2,psa_key_agreement_raw_shared_secret:2,psa_key_attributes_:0,psa_key_attributes_init:2,psa_key_attributes_t:[1,2],psa_key_deriv:[],psa_key_derivation_:0,psa_key_derivation_abort:[1,2],psa_key_derivation_get_capac:2,psa_key_derivation_input_byt:[1,2],psa_key_derivation_input_info:[1,2],psa_key_derivation_input_kei:[1,2],psa_key_derivation_input_label:2,psa_key_derivation_input_salt:2,psa_key_derivation_input_se:2,psa_key_derivation_input_secret:[1,2],psa_key_derivation_input_xxx:2,psa_key_derivation_key_agr:[1,2],psa_key_derivation_operaiton_init:1,psa_key_derivation_operation_init:[1,2],psa_key_derivation_operation_t:[1,2],psa_key_derivation_output_byt:[1,2],psa_key_derivation_output_kei:[1,2],psa_key_derivation_set_capac:2,psa_key_derivation_setup:[1,2],psa_key_derivation_step_t:2,psa_key_derivation_unlimited_capac:2,psa_key_export_asn1_integer_max_s:2,psa_key_export_dsa_key_pair_max_s:2,psa_key_export_dsa_public_key_max_s:2,psa_key_export_ecc_key_pair_max_s:2,psa_key_export_ecc_public_key_max_s:2,psa_key_export_max_s:2,psa_key_export_rsa_key_pair_max_s:2,psa_key_export_rsa_public_key_max_s:2,psa_key_handle_t:[1,2],psa_key_id_t:2,psa_key_id_user_max:2,psa_key_id_user_min:2,psa_key_id_vendor_max:2,psa_key_id_vendor_min:2,psa_key_lifetime_persist:[1,2],psa_key_lifetime_t:2,psa_key_lifetime_volatil:[1,2],psa_key_policy_t:2,psa_key_type_a:[1,2],psa_key_type_arc4:2,psa_key_type_camellia:2,psa_key_type_category_flag_pair:2,psa_key_type_category_key_pair:2,psa_key_type_category_mask:2,psa_key_type_category_public_kei:2,psa_key_type_category_raw:2,psa_key_type_category_symmetr:2,psa_key_type_chacha20:2,psa_key_type_d:2,psa_key_type_der:2,psa_key_type_dh_group_mask:2,psa_key_type_dh_key_pair:2,psa_key_type_dh_key_pair_bas:2,psa_key_type_dh_public_kei:2,psa_key_type_dh_public_key_bas:2,psa_key_type_dsa_key_pair:0,psa_key_type_dsa_public_kei:0,psa_key_type_ecc_curve_mask:2,psa_key_type_ecc_key_pair:2,psa_key_type_ecc_key_pair_bas:2,psa_key_type_ecc_public_kei:2,psa_key_type_ecc_public_key_bas:2,psa_key_type_get_curv:2,psa_key_type_get_group:2,psa_key_type_hmac:2,psa_key_type_is_asymmetr:2,psa_key_type_is_dh:2,psa_key_type_is_dh_key_pair:2,psa_key_type_is_dh_public_kei:2,psa_key_type_is_ecc:2,psa_key_type_is_ecc_key_pair:2,psa_key_type_is_ecc_public_kei:2,psa_key_type_is_key_pair:2,psa_key_type_is_public_kei:2,psa_key_type_is_rsa:2,psa_key_type_is_unstructur:2,psa_key_type_is_vendor_defin:2,psa_key_type_key_pair_of_public_kei:2,psa_key_type_non:2,psa_key_type_public_key_of_key_pair:2,psa_key_type_raw_data:2,psa_key_type_rsa_key_pair:2,psa_key_type_rsa_public_kei:2,psa_key_type_t:[1,2],psa_key_type_vendor_flag:2,psa_key_usage_copi:[1,2],psa_key_usage_decrypt:2,psa_key_usage_der:2,psa_key_usage_encrypt:[1,2],psa_key_usage_export:[1,2],psa_key_usage_sign:[1,2],psa_key_usage_t:[1,2],psa_key_usage_verifi:2,psa_mac_abort:2,psa_mac_comput:[1,2],psa_mac_final_s:2,psa_mac_max_s:2,psa_mac_operation_:0,psa_mac_operation_init:2,psa_mac_operation_t:2,psa_mac_sign_finish:[1,2],psa_mac_sign_setup:[1,2],psa_mac_truncated_length:2,psa_mac_truncation_offset:2,psa_mac_upd:[1,2],psa_mac_verifi:[1,2],psa_mac_verify_finish:[1,2],psa_mac_verify_setup:[1,2],psa_make_key_persist:[],psa_max_block_cipher_block_s:2,psa_open_kei:[1,2],psa_raw_key_agr:[1,2],psa_reset_key_attribut:2,psa_round_up_to_multipl:2,psa_rsa_minimum_padding_s:2,psa_set_generator_capac:2,psa_set_key_algorithm:2,psa_set_key_bit:2,psa_set_key_id:2,psa_set_key_lifetim:2,psa_set_key_polici:2,psa_set_key_typ:2,psa_set_key_usage_flag:2,psa_set_key_xxx:0,psa_status_t:[1,2],psa_success:[1,2],psa_vendor_ecc_max_curve_bit:2,psa_vendor_rsa_max_key_bit:2,psa_xxx_abort:1,psa_xxx_init:1,psa_xxx_key_pair:2,psa_xxx_keypair:2,psa_xxx_signatur:0,psa_xxx_siz:0,pseudo:1,pseudorandom:[1,2],psk:0,pss:0,public_key_typ:0,publicexpon:0,pure:0,purpos:[0,1],q_a:0,q_b:0,qualiti:1,queri:[0,1],quot:0,radio:1,rais:1,ram:1,random:2,randomli:0,rang:[0,1,2],rate:1,rather:[0,1],rational:1,raw:0,rc4:0,reach:1,read:[0,1],readabl:[0,1],reader:1,readi:0,realiz:1,realm:0,reason:1,receiv:[0,1],recip:1,recogn:0,recommend:[0,2],record:0,recov:[0,1],recover:0,reduc:[0,1],ref:0,refer:[0,1],refurbish:0,regard:2,regardless:0,regul:1,reject:0,relat:[1,2],releas:[0,1,2],relev:1,remain:0,remot:1,remov:[1,2],renam:2,repeat:0,replac:2,report:[0,1],repres:[0,1],represent:[0,1],request:[0,1],requir:[0,2],research:1,reseed:[0,1],reserv:0,reset:[0,1],resid:1,resist:2,resort:0,resourc:[0,2],respect:[0,1],rest:0,restart:0,restrict:[0,1],result:[0,1],retain:1,retent:1,retriev:[0,1,2],reus:0,reveal:[0,1],rewound:1,rfc:[0,1],risk:[0,1],riski:0,robust:1,roll:1,round:0,rsa:0,rsae:0,rsaprivatekei:0,rsapublickei:0,rsassa:0,run:1,runtim:0,safe:[0,2],safeti:0,said:0,salt:[0,1],salt_length:0,same:[0,1,2],sampl:2,save:0,scalabl:1,schedul:0,scheme:0,scope:1,search:2,sec1:0,secret:[0,1],sect:0,section:[0,1],secur:[0,2],see:0,seed:[0,1],segment:1,select:[0,1],sens:2,sensibl:0,sensit:1,separ:[0,1,2],sequenc:[0,1],seri:1,serv:1,server:1,serverhello:0,servic:1,session:1,set:[0,1,2],setup:[0,1],sever:[1,2],sha2:0,sha3:0,sha:0,shall:0,share:[0,2],shorten:0,shot:1,should:[0,1],shouldn:1,side:[0,1],sign:[0,2],signatur:[0,1],signature_length:0,signature_s:0,signific:0,similar:[0,1],simpl:0,simpler:1,simpli:1,simultan:1,sinc:[0,1],singl:[0,2],siv:1,size:[0,2],size_t:[0,1],sizeof:0,skip:0,small:0,smaller:0,smartcard:1,softwar:1,some:[0,1,2],sometim:1,soon:1,sourc:[0,1],source_handl:0,source_oper:0,space:[0,1],special:[0,1],specifi:[0,1,2],speed:0,split:1,spuriou:2,stabil:2,stack:1,stage:0,stakehold:1,standalon:1,standard:[0,2],start:[0,1],state:[0,1,2],statu:[0,2],status:1,stdint:1,step:[0,1],steup:0,still:[0,1],storag:[0,2],store:[0,1],strategi:1,stream:[0,1],string:0,strip:0,strive:[0,1],strongli:[0,1],struct:[0,1],structur:[0,2],style:1,subject:0,subprim:0,subsequ:0,subset:[0,1],subtl:1,succe:0,succeed:0,success:[0,1],successfulli:[0,1],suffici:[0,1],suitabl:[0,2],summari:[1,2],suppli:1,support:[0,2],suppos:0,symmetr:2,synonym:1,system:[0,1],systemat:1,tag:[0,1],tag_length:0,tag_siz:0,take:[0,1,2],taken:0,tamper:0,target:[0,1],target_handl:0,target_oper:0,task:1,technolog:1,temporari:1,tend:1,tent:0,term:1,termin:[0,1],terminolog:2,test:[0,1],than:[0,1],thei:[0,1],them:[0,1,2],themselv:1,theoret:1,therebi:0,therefor:[0,1],thi:[0,1,2],thin:1,those:[0,1],though:1,thread:1,threat:1,three:[0,1],through:[0,1],thu:[0,1],time:[0,1,2],titl:0,token:2,too:0,took:0,top:[0,1],total:0,trail:0,translat:1,treat:0,tripl:0,trng:1,truncat:0,trust:1,turn:0,twice:0,two:[0,1],type:2,typedef:0,typic:[0,1],uint16_t:[0,1],uint32_t:[0,1],uint8_t:[0,1],unambigu:0,unauthent:[0,1],unbound:1,unchang:[0,1],uncompress:0,undefin:[0,1],under:[0,1],underli:[0,1],undetermin:[0,1],undo:0,undon:0,unexpect:0,uninstal:0,uniqu:1,unless:[0,1],unlik:1,unlock:1,unmodifi:1,unsign:[0,1],unspecifi:[0,1],unstructur:0,unsupport:[0,1],unsur:0,until:[0,1],untrunc:0,untrust:0,untrustworthi:1,unusu:2,updat:1,upon:1,usabl:1,usag:[0,2],usage_flag:0,use:[0,2],used:[0,1,2],useful:[0,1,2],user:1,uses:[0,1],using:[0,1],usual:[0,1],v1_5:0,valid:[0,1],valu:[0,1,2],variabl:0,variant:1,variou:[1,2],vast:1,vector:[0,1],vendor:[0,1],veri:1,verif:[0,1],verifi:[0,1],versa:1,version:[0,1],via:[0,1],vice:1,view:0,violat:1,virtual:1,visibl:1,volatil:[0,2],wai:[0,1,2],want:0,warn:1,weak:[0,1],weierstrass:0,well:[0,1],were:1,what:[0,1],when:[0,1,2],whenev:0,whenver:0,where:[0,1,2],whether:[0,1,2],which:[0,1],who:[0,1],whole:[0,1],whose:[0,1],wide:1,wildcard:0,wipe:[0,1],wireless:1,wish:1,within:1,without:[0,1],word:[0,1],work:1,workflow:0,workshop:0,world:1,would:[0,1],wrap:[0,1],writabl:1,write:[0,1],writer:[0,1],written:[0,1],wrong:0,wrote:1,x00000000:0,x00000001:0,x00000002:0,x000000ff:0,x00000100:0,x00000200:0,x00000400:0,x00000800:0,x00001000:0,x00003f00:0,x0000ffff:0,x0001:0,x0002:0,x0003:0,x0004:0,x0005:0,x0006:0,x0007:0,x0008:0,x0009:0,x000a:0,x000b:0,x000c:0,x000d:0,x000e:0,x000f:0,x0010:0,x0011:0,x0012:0,x0013:0,x0014:0,x0015:0,x0016:0,x0017:0,x0018:0,x0019:0,x001a:0,x001b:0,x001c:0,x001d:0,x001e:0,x00400000:0,x00800000:0,x00c00000:0,x01000000:0,x01000001:0,x01000002:0,x01000003:0,x01000004:0,x01000005:0,x01000008:0,x01000009:0,x0100000a:0,x0100000b:0,x0100000c:0,x0100000d:0,x01000010:0,x01000011:0,x01000012:0,x01000013:0,x010000ff:0,x0100:0,x0101:0,x0102:0,x0103:0,x0104:0,x02000000:0,x0201:0,x0202:0,x0203:0,x0204:0,x02800000:0,x02c00000:0,x02c00001:0,x02c00002:0,x02c00003:0,x04000000:0,x044000ff:0,x04600100:0,x04600101:0,x04800001:0,x04800005:0,x04c00001:0,x04c00002:0,x04c00003:0,x06000000:0,x06001005:0,x06401001:0,x06401002:0,x0803ffff:0,x10000000:0,x10020000:0,x10030000:0,x10060000:0,x10070000:0,x10fc0000:0,x12000000:0,x12020000:0,x12030000:0,x20000000:0,x20000100:0,x20000200:0,x20000300:0,x25519:0,x30000000:0,x30100000:0,x30200000:0,x3fffffff:0,x40000000:0,x40000001:0,x40000002:0,x40000003:0,x40000004:0,x40000005:0,x448:0,x50000000:0,x50000001:0,x51000000:0,x52000000:0,x60000000:0,x60010000:0,x60030000:0,x60040000:0,x70000000:0,x70010000:0,x70030000:0,x70040000:0,x7f000000:0,x7fffffff:0,x80000000:0,x_p:0,xor:0,y_p:0,yet:[0,1],you:[0,1],zero:[0,1,2]},titles:["Implementation-specific definitions","Introduction","PSA Cryptography API Specification"],titleterms:{"case":1,"export":0,"function":[0,1],"import":0,"return":1,TLS:1,addit:1,aead:0,after:1,agreement:1,algorithm:[0,1],alwai:1,api:2,applic:1,architectur:1,aspect:1,associ:0,assumpt:1,asymmetr:[0,1],attack:1,attest:1,attribut:0,authent:[0,1],behavior:1,between:1,boot:1,buffer:1,call:1,chang:2,check:1,choic:1,cipher:0,clean:1,cleanup:1,client:1,code:0,concurr:1,consider:1,constrain:1,convent:1,credenti:1,cryptograph:1,cryptographi:[0,1,2],cryptoprocessor:1,data:0,definit:0,deriv:[0,1],design:1,detect:1,devic:1,digest:0,document:2,eas:1,encrypt:[0,1],error:[0,1],exampl:1,factori:1,futur:1,gener:[0,1],goal:1,handl:1,hardwar:1,hash:1,histori:2,implement:[0,1],initi:0,input:1,interfac:1,introduct:1,isol:1,kei:[0,1],keystor:1,librari:[0,1],lifetim:0,macro:[0,1],manag:[0,1],memori:1,messag:0,minimum:1,multi:1,multipart:1,network:1,oper:1,option:1,other:[0,1],output:1,overlap:1,overview:1,pair:1,paramet:1,partit:1,persist:1,philosophi:1,plan:2,platform:1,pointer:1,polici:[0,1],port:1,processor:1,profil:1,provis:1,psa:2,psa__alg_aead_with_default_tag_length__cas:0,psa_aead_abort:0,psa_aead_decrypt:0,psa_aead_decrypt_output_s:0,psa_aead_decrypt_setup:0,psa_aead_encrypt:0,psa_aead_encrypt_output_s:0,psa_aead_encrypt_setup:0,psa_aead_finish:0,psa_aead_finish_output_s:0,psa_aead_generate_nonc:0,psa_aead_operation_init:0,psa_aead_operation_t:0,psa_aead_set_length:0,psa_aead_set_nonc:0,psa_aead_tag_length:0,psa_aead_tag_length_offset:0,psa_aead_upd:0,psa_aead_update_ad:0,psa_aead_update_output_s:0,psa_aead_verifi:0,psa_aead_verify_output_s:0,psa_alg_aead_from_block_flag:0,psa_alg_aead_tag_length_mask:0,psa_alg_aead_with_default_tag_length:0,psa_alg_aead_with_tag_length:0,psa_alg_any_hash:0,psa_alg_arc4:0,psa_alg_category_aead:0,psa_alg_category_asymmetric_encrypt:0,psa_alg_category_ciph:0,psa_alg_category_hash:0,psa_alg_category_key_agr:0,psa_alg_category_key_deriv:0,psa_alg_category_mac:0,psa_alg_category_mask:0,psa_alg_category_sign:0,psa_alg_cbc_mac:0,psa_alg_cbc_no_pad:0,psa_alg_cbc_pkcs7:0,psa_alg_ccm:0,psa_alg_cfb:0,psa_alg_chacha20:0,psa_alg_chacha20_poly1305:0,psa_alg_cipher_from_block_flag:0,psa_alg_cipher_mac_bas:0,psa_alg_cipher_stream_flag:0,psa_alg_cmac:0,psa_alg_ctr:0,psa_alg_deterministic_ecdsa:0,psa_alg_deterministic_ecdsa_bas:0,psa_alg_ecdh:0,psa_alg_ecdsa:0,psa_alg_ecdsa_ani:0,psa_alg_ecdsa_bas:0,psa_alg_ecdsa_is_determinist:0,psa_alg_ffdh:0,psa_alg_full_length_mac:0,psa_alg_gcm:0,psa_alg_gmac:0,psa_alg_hash_mask:0,psa_alg_hkdf:0,psa_alg_hkdf_bas:0,psa_alg_hkdf_get_hash:0,psa_alg_hmac:0,psa_alg_hmac_bas:0,psa_alg_hmac_get_hash:0,psa_alg_is_aead:0,psa_alg_is_aead_on_block_ciph:0,psa_alg_is_asymmetric_encrypt:0,psa_alg_is_block_cipher_mac:0,psa_alg_is_ciph:0,psa_alg_is_deterministic_ecdsa:0,psa_alg_is_ecdh:0,psa_alg_is_ecdsa:0,psa_alg_is_ffdh:0,psa_alg_is_hash:0,psa_alg_is_hash_and_sign:0,psa_alg_is_hkdf:0,psa_alg_is_hmac:0,psa_alg_is_key_agr:0,psa_alg_is_key_deriv:0,psa_alg_is_key_derivation_or_agr:0,psa_alg_is_mac:0,psa_alg_is_randomized_ecdsa:0,psa_alg_is_raw_key_agr:0,psa_alg_is_rsa_oaep:0,psa_alg_is_rsa_pkcs1v15_sign:0,psa_alg_is_rsa_pss:0,psa_alg_is_sign:0,psa_alg_is_stream_ciph:0,psa_alg_is_tls12_prf:0,psa_alg_is_tls12_psk_to_m:0,psa_alg_is_vendor_defin:0,psa_alg_is_wildcard:0,psa_alg_key_agr:0,psa_alg_key_agreement_get_bas:0,psa_alg_key_agreement_get_kdf:0,psa_alg_key_agreement_mask:0,psa_alg_key_derivation_mask:0,psa_alg_mac_subcategory_mask:0,psa_alg_mac_truncation_mask:0,psa_alg_md2:0,psa_alg_md4:0,psa_alg_md5:0,psa_alg_ofb:0,psa_alg_ripemd160:0,psa_alg_rsa_oaep:0,psa_alg_rsa_oaep_bas:0,psa_alg_rsa_oaep_get_hash:0,psa_alg_rsa_pkcs1v15_crypt:0,psa_alg_rsa_pkcs1v15_sign:0,psa_alg_rsa_pkcs1v15_sign_bas:0,psa_alg_rsa_pkcs1v15_sign_raw:0,psa_alg_rsa_pss:0,psa_alg_rsa_pss_bas:0,psa_alg_sha3_224:0,psa_alg_sha3_256:0,psa_alg_sha3_384:0,psa_alg_sha3_512:0,psa_alg_sha_1:0,psa_alg_sha_224:0,psa_alg_sha_256:0,psa_alg_sha_384:0,psa_alg_sha_512:0,psa_alg_sha_512_224:0,psa_alg_sha_512_256:0,psa_alg_sign_get_hash:0,psa_alg_tls12_prf:0,psa_alg_tls12_prf_bas:0,psa_alg_tls12_prf_get_hash:0,psa_alg_tls12_psk_to_m:0,psa_alg_tls12_psk_to_ms_bas:0,psa_alg_tls12_psk_to_ms_get_hash:0,psa_alg_tls12_psk_to_ms_max_psk_len:0,psa_alg_truncated_mac:0,psa_alg_vendor_flag:0,psa_alg_xt:0,psa_algorithm_t:0,psa_asymmetric_decrypt:0,psa_asymmetric_decrypt_output_s:0,psa_asymmetric_encrypt:0,psa_asymmetric_encrypt_output_s:0,psa_asymmetric_sign:0,psa_asymmetric_sign_output_s:0,psa_asymmetric_signature_max_s:0,psa_asymmetric_verifi:0,psa_bits_to_byt:0,psa_block_cipher_block_s:0,psa_bytes_to_bit:0,psa_cipher_abort:0,psa_cipher_decrypt:0,psa_cipher_decrypt_setup:0,psa_cipher_encrypt:0,psa_cipher_encrypt_setup:0,psa_cipher_finish:0,psa_cipher_generate_iv:0,psa_cipher_operation_init:0,psa_cipher_operation_t:0,psa_cipher_set_iv:0,psa_cipher_upd:0,psa_close_kei:0,psa_copy_kei:0,psa_crypto_init:0,psa_destroy_kei:0,psa_dh_group_ffdhe2048:0,psa_dh_group_ffdhe3072:0,psa_dh_group_ffdhe4096:0,psa_dh_group_ffdhe6144:0,psa_dh_group_ffdhe8192:0,psa_dh_group_t:0,psa_ecc_curve_bit:0,psa_ecc_curve_brainpool_p256r1:0,psa_ecc_curve_brainpool_p384r1:0,psa_ecc_curve_brainpool_p512r1:0,psa_ecc_curve_curve25519:0,psa_ecc_curve_curve448:0,psa_ecc_curve_secp160k1:0,psa_ecc_curve_secp160r1:0,psa_ecc_curve_secp160r2:0,psa_ecc_curve_secp192k1:0,psa_ecc_curve_secp192r1:0,psa_ecc_curve_secp224k1:0,psa_ecc_curve_secp224r1:0,psa_ecc_curve_secp256k1:0,psa_ecc_curve_secp256r1:0,psa_ecc_curve_secp384r1:0,psa_ecc_curve_secp521r1:0,psa_ecc_curve_sect163k1:0,psa_ecc_curve_sect163r1:0,psa_ecc_curve_sect163r2:0,psa_ecc_curve_sect193r1:0,psa_ecc_curve_sect193r2:0,psa_ecc_curve_sect233k1:0,psa_ecc_curve_sect233r1:0,psa_ecc_curve_sect239k1:0,psa_ecc_curve_sect283k1:0,psa_ecc_curve_sect283r1:0,psa_ecc_curve_sect409k1:0,psa_ecc_curve_sect409r1:0,psa_ecc_curve_sect571k1:0,psa_ecc_curve_sect571r1:0,psa_ecc_curve_t:0,psa_ecdsa_signature_s:0,psa_error_already_exist:0,psa_error_bad_st:0,psa_error_buffer_too_smal:0,psa_error_communication_failur:0,psa_error_corruption_detect:0,psa_error_does_not_exist:0,psa_error_generic_error:0,psa_error_hardware_failur:0,psa_error_insufficient_data:0,psa_error_insufficient_entropi:0,psa_error_insufficient_memori:0,psa_error_insufficient_storag:0,psa_error_invalid_argu:0,psa_error_invalid_handl:0,psa_error_invalid_pad:0,psa_error_invalid_signatur:0,psa_error_not_permit:0,psa_error_not_support:0,psa_error_storage_failur:0,psa_export_kei:0,psa_export_public_kei:0,psa_generate_kei:0,psa_generate_random:0,psa_get_key_algorithm:0,psa_get_key_attribut:0,psa_get_key_bit:0,psa_get_key_id:0,psa_get_key_lifetim:0,psa_get_key_typ:0,psa_get_key_usage_flag:0,psa_hash_abort:0,psa_hash_clon:0,psa_hash_compar:0,psa_hash_comput:0,psa_hash_finish:0,psa_hash_max_s:0,psa_hash_operation_init:0,psa_hash_operation_t:0,psa_hash_s:0,psa_hash_setup:0,psa_hash_upd:0,psa_hash_verifi:0,psa_hmac_max_hash_block_s:0,psa_import_kei:0,psa_key_attributes_init:0,psa_key_attributes_t:0,psa_key_derivation_abort:0,psa_key_derivation_get_capac:0,psa_key_derivation_input_byt:0,psa_key_derivation_input_info:0,psa_key_derivation_input_kei:0,psa_key_derivation_input_label:0,psa_key_derivation_input_salt:0,psa_key_derivation_input_se:0,psa_key_derivation_input_secret:0,psa_key_derivation_key_agr:0,psa_key_derivation_operation_init:0,psa_key_derivation_operation_t:0,psa_key_derivation_output_byt:0,psa_key_derivation_output_kei:0,psa_key_derivation_set_capac:0,psa_key_derivation_setup:0,psa_key_derivation_step_t:0,psa_key_derivation_unlimited_capac:0,psa_key_export_asn1_integer_max_s:0,psa_key_export_dsa_key_pair_max_s:0,psa_key_export_dsa_public_key_max_s:0,psa_key_export_ecc_key_pair_max_s:0,psa_key_export_ecc_public_key_max_s:0,psa_key_export_max_s:0,psa_key_export_rsa_key_pair_max_s:0,psa_key_export_rsa_public_key_max_s:0,psa_key_handle_t:0,psa_key_id_t:0,psa_key_id_user_max:0,psa_key_id_user_min:0,psa_key_id_vendor_max:0,psa_key_id_vendor_min:0,psa_key_lifetime_persist:0,psa_key_lifetime_t:0,psa_key_lifetime_volatil:0,psa_key_type_a:0,psa_key_type_arc4:0,psa_key_type_camellia:0,psa_key_type_category_flag_pair:0,psa_key_type_category_key_pair:0,psa_key_type_category_mask:0,psa_key_type_category_public_kei:0,psa_key_type_category_raw:0,psa_key_type_category_symmetr:0,psa_key_type_chacha20:0,psa_key_type_d:0,psa_key_type_der:0,psa_key_type_dh_group_mask:0,psa_key_type_dh_key_pair:0,psa_key_type_dh_key_pair_bas:0,psa_key_type_dh_public_kei:0,psa_key_type_dh_public_key_bas:0,psa_key_type_ecc_curve_mask:0,psa_key_type_ecc_key_pair:0,psa_key_type_ecc_key_pair_bas:0,psa_key_type_ecc_public_kei:0,psa_key_type_ecc_public_key_bas:0,psa_key_type_get_curv:0,psa_key_type_get_group:0,psa_key_type_hmac:0,psa_key_type_is_asymmetr:0,psa_key_type_is_dh:0,psa_key_type_is_dh_key_pair:0,psa_key_type_is_dh_public_kei:0,psa_key_type_is_ecc:0,psa_key_type_is_ecc_key_pair:0,psa_key_type_is_ecc_public_kei:0,psa_key_type_is_key_pair:0,psa_key_type_is_public_kei:0,psa_key_type_is_rsa:0,psa_key_type_is_unstructur:0,psa_key_type_is_vendor_defin:0,psa_key_type_key_pair_of_public_kei:0,psa_key_type_non:0,psa_key_type_public_key_of_key_pair:0,psa_key_type_raw_data:0,psa_key_type_rsa_key_pair:0,psa_key_type_rsa_public_kei:0,psa_key_type_t:0,psa_key_type_vendor_flag:0,psa_key_usage_copi:0,psa_key_usage_decrypt:0,psa_key_usage_der:0,psa_key_usage_encrypt:0,psa_key_usage_export:0,psa_key_usage_sign:0,psa_key_usage_t:0,psa_key_usage_verifi:0,psa_mac_abort:0,psa_mac_comput:0,psa_mac_final_s:0,psa_mac_max_s:0,psa_mac_operation_init:0,psa_mac_operation_t:0,psa_mac_sign_finish:0,psa_mac_sign_setup:0,psa_mac_truncated_length:0,psa_mac_truncation_offset:0,psa_mac_upd:0,psa_mac_verifi:0,psa_mac_verify_finish:0,psa_mac_verify_setup:0,psa_max_block_cipher_block_s:0,psa_open_kei:0,psa_raw_key_agr:0,psa_reset_key_attribut:0,psa_round_up_to_multipl:0,psa_rsa_minimum_padding_s:0,psa_set_key_algorithm:0,psa_set_key_bit:0,psa_set_key_id:0,psa_set_key_lifetim:0,psa_set_key_typ:0,psa_set_key_usage_flag:0,psa_status_t:0,psa_success:0,psa_vendor_ecc_max_curve_bit:0,psa_vendor_rsa_max_key_bit:0,pseudorandom:0,random:[0,1],recommend:1,requir:1,resist:1,resourc:1,safe:1,sampl:1,secur:1,share:1,sign:1,singl:1,size:1,specif:[0,1,2],stabil:1,standard:1,statu:1,storag:1,structur:1,suitabl:1,support:1,symmetr:[0,1],token:1,type:[0,1],usag:1,use:1,version:2,volatil:1}})
\ No newline at end of file
diff --git a/docs/html/splitbar.png b/docs/html/splitbar.png
deleted file mode 100644
index fe895f2..0000000
--- a/docs/html/splitbar.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/structpsa__generate__key__extra__rsa-members.html b/docs/html/structpsa__generate__key__extra__rsa-members.html
deleted file mode 100644
index f03b6de..0000000
--- a/docs/html/structpsa__generate__key__extra__rsa-members.html
+++ /dev/null
@@ -1,102 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: Member List</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li><a href="modules.html"><span>Modules</span></a></li>
- <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
- <li><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
- <div id="navrow2" class="tabs2">
- <ul class="tablist">
- <li><a href="annotated.html"><span>Class List</span></a></li>
- <li><a href="classes.html"><span>Class Index</span></a></li>
- <li><a href="functions.html"><span>Class Members</span></a></li>
- </ul>
- </div>
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-</div><!-- top -->
-<div class="header">
- <div class="headertitle">
-<div class="title">psa_generate_key_extra_rsa Member List</div> </div>
-</div><!--header-->
-<div class="contents">
-
-<p>This is the complete list of members for <a class="el" href="structpsa__generate__key__extra__rsa.html">psa_generate_key_extra_rsa</a>, including all inherited members.</p>
-<table class="directory">
- <tr class="even"><td class="entry"><a class="el" href="structpsa__generate__key__extra__rsa.html#a53ccb9e4375f3c9af6e3ecfe111ce11d">e</a></td><td class="entry"><a class="el" href="structpsa__generate__key__extra__rsa.html">psa_generate_key_extra_rsa</a></td><td class="entry"></td></tr>
-</table></div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/structpsa__generate__key__extra__rsa.html b/docs/html/structpsa__generate__key__extra__rsa.html
deleted file mode 100644
index 4121301..0000000
--- a/docs/html/structpsa__generate__key__extra__rsa.html
+++ /dev/null
@@ -1,129 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen 1.8.11"/>
-<title>Platform Security Architecture — cryptography and keystore interface: psa_generate_key_extra_rsa Struct Reference</title>
-<link href="tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="jquery.js"></script>
-<script type="text/javascript" src="dynsections.js"></script>
-<link href="search/search.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="search/searchdata.js"></script>
-<script type="text/javascript" src="search/search.js"></script>
-<script type="text/javascript">
- $(document).ready(function() { init_search(); });
-</script>
-<link href="doxygen.css" rel="stylesheet" type="text/css" />
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
- <td id="projectalign" style="padding-left: 0.5em;">
- <div id="projectname">Platform Security Architecture — cryptography and keystore interface
-  <span id="projectnumber">beta 2 — 2019-02-22</span>
- </div>
- </td>
- </tr>
- </tbody>
-</table>
-</div>
-<!-- end header part -->
-<!-- Generated by Doxygen 1.8.11 -->
-<script type="text/javascript">
-var searchBox = new SearchBox("searchBox", "search",false,'Search');
-</script>
- <div id="navrow1" class="tabs">
- <ul class="tablist">
- <li><a href="index.html"><span>Main Page</span></a></li>
- <li><a href="modules.html"><span>Modules</span></a></li>
- <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
- <li><a href="files.html"><span>Files</span></a></li>
- <li>
- <div id="MSearchBox" class="MSearchBoxInactive">
- <span class="left">
- <img id="MSearchSelect" src="search/mag_sel.png"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- alt=""/>
- <input type="text" id="MSearchField" value="Search" accesskey="S"
- onfocus="searchBox.OnSearchFieldFocus(true)"
- onblur="searchBox.OnSearchFieldFocus(false)"
- onkeyup="searchBox.OnSearchFieldChange(event)"/>
- </span><span class="right">
- <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
- </span>
- </div>
- </li>
- </ul>
- </div>
- <div id="navrow2" class="tabs2">
- <ul class="tablist">
- <li><a href="annotated.html"><span>Class List</span></a></li>
- <li><a href="classes.html"><span>Class Index</span></a></li>
- <li><a href="functions.html"><span>Class Members</span></a></li>
- </ul>
- </div>
-<!-- window showing the filter options -->
-<div id="MSearchSelectWindow"
- onmouseover="return searchBox.OnSearchSelectShow()"
- onmouseout="return searchBox.OnSearchSelectHide()"
- onkeydown="return searchBox.OnSearchSelectKey(event)">
-</div>
-
-<!-- iframe showing the search results (closed by default) -->
-<div id="MSearchResultsWindow">
-<iframe src="javascript:void(0)" frameborder="0"
- name="MSearchResults" id="MSearchResults">
-</iframe>
-</div>
-
-</div><!-- top -->
-<div class="header">
- <div class="summary">
-<a href="#pub-attribs">Public Attributes</a> |
-<a href="structpsa__generate__key__extra__rsa-members.html">List of all members</a> </div>
- <div class="headertitle">
-<div class="title">psa_generate_key_extra_rsa Struct Reference<div class="ingroups"><a class="el" href="group__random.html">Random generation</a></div></div> </div>
-</div><!--header-->
-<div class="contents">
-
-<p><code>#include <<a class="el" href="crypto_8h_source.html">crypto.h</a>></code></p>
-<table class="memberdecls">
-<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
-Public Attributes</h2></td></tr>
-<tr class="memitem:a53ccb9e4375f3c9af6e3ecfe111ce11d"><td class="memItemLeft" align="right" valign="top">uint32_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structpsa__generate__key__extra__rsa.html#a53ccb9e4375f3c9af6e3ecfe111ce11d">e</a></td></tr>
-<tr class="separator:a53ccb9e4375f3c9af6e3ecfe111ce11d"><td class="memSeparator" colspan="2"> </td></tr>
-</table>
-<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
-<div class="textblock"><p>Extra parameters for RSA key generation.</p>
-<p>You may pass a pointer to a structure of this type as the <code>extra</code> parameter to <a class="el" href="group__random.html#ga72921520494b4f007a3afb904cd9ecdd" title="Generate a key or key pair. ">psa_generate_key()</a>. </p>
-</div><h2 class="groupheader">Member Data Documentation</h2>
-<a class="anchor" id="a53ccb9e4375f3c9af6e3ecfe111ce11d"></a>
-<div class="memitem">
-<div class="memproto">
- <table class="memname">
- <tr>
- <td class="memname">uint32_t psa_generate_key_extra_rsa::e</td>
- </tr>
- </table>
-</div><div class="memdoc">
-<p>Public exponent value. Default: 65537. </p>
-
-</div>
-</div>
-<hr/>The documentation for this struct was generated from the following file:<ul>
-<li>psa/<a class="el" href="crypto_8h_source.html">crypto.h</a></li>
-</ul>
-</div><!-- contents -->
-<!-- start footer part -->
-<hr class="footer"/><address class="footer"><small>
-Generated by  <a href="http://www.doxygen.org/index.html">
-<img class="footer" src="doxygen.png" alt="doxygen"/>
-</a> 1.8.11
-</small></address>
-</body>
-</html>
diff --git a/docs/html/sync_off.png b/docs/html/sync_off.png
deleted file mode 100644
index 3b443fc..0000000
--- a/docs/html/sync_off.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/sync_on.png b/docs/html/sync_on.png
deleted file mode 100644
index e08320f..0000000
--- a/docs/html/sync_on.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/tab_a.png b/docs/html/tab_a.png
deleted file mode 100644
index 3b725c4..0000000
--- a/docs/html/tab_a.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/tab_b.png b/docs/html/tab_b.png
deleted file mode 100644
index e2b4a86..0000000
--- a/docs/html/tab_b.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/tab_h.png b/docs/html/tab_h.png
deleted file mode 100644
index fd5cb70..0000000
--- a/docs/html/tab_h.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/tab_s.png b/docs/html/tab_s.png
deleted file mode 100644
index ab478c9..0000000
--- a/docs/html/tab_s.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/tabs.css b/docs/html/tabs.css
deleted file mode 100644
index 9cf578f..0000000
--- a/docs/html/tabs.css
+++ /dev/null
@@ -1,60 +0,0 @@
-.tabs, .tabs2, .tabs3 {
- background-image: url('tab_b.png');
- width: 100%;
- z-index: 101;
- font-size: 13px;
- font-family: 'Lucida Grande',Geneva,Helvetica,Arial,sans-serif;
-}
-
-.tabs2 {
- font-size: 10px;
-}
-.tabs3 {
- font-size: 9px;
-}
-
-.tablist {
- margin: 0;
- padding: 0;
- display: table;
-}
-
-.tablist li {
- float: left;
- display: table-cell;
- background-image: url('tab_b.png');
- line-height: 36px;
- list-style: none;
-}
-
-.tablist a {
- display: block;
- padding: 0 20px;
- font-weight: bold;
- background-image:url('tab_s.png');
- background-repeat:no-repeat;
- background-position:right;
- color: #283A5D;
- text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9);
- text-decoration: none;
- outline: none;
-}
-
-.tabs3 .tablist a {
- padding: 0 10px;
-}
-
-.tablist a:hover {
- background-image: url('tab_h.png');
- background-repeat:repeat-x;
- color: #fff;
- text-shadow: 0px 1px 1px rgba(0, 0, 0, 1.0);
- text-decoration: none;
-}
-
-.tablist li.current a {
- background-image: url('tab_a.png');
- background-repeat:repeat-x;
- color: #fff;
- text-shadow: 0px 1px 1px rgba(0, 0, 0, 1.0);
-}
