WolfSSL
/
wolfcrypt-py
mirror of https://github.com/wolfSSL/wolfcrypt-py.git
1
0
Fork 0
Code Issues Releases Wiki Activity

docs v3.14.0-1

gh-pages
Moisés Guimarães 2018-03-19 22:12:11 +01:00
parent 7d8e69e83f
commit b8145f8185
23 changed files with 10891 additions and 218 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.buildinfo
View File

@ -1,4 +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: 93adee6956bfe283f5bcbe61989f74ca
config: 69b5be43a2132d7f3f306a65e6f88738
tags: 645f666f9bcd5a90fca523b33c5a78b7

8
_modules/index.html
View File

@ -8,7 +8,7 @@
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Overview: module code &mdash; wolfcrypt Python 3.13.0-1 documentation</title>
<title>Overview: module code &mdash; wolfcrypt Python 3.14.0-1 documentation</title>
@ -35,7 +35,7 @@
<link rel="index" title="Index"
href="../genindex.html"/>
<link rel="search" title="Search" href="../search.html"/>
<link rel="top" title="wolfcrypt Python 3.13.0-1 documentation" href="../index.html"/>
<link rel="top" title="wolfcrypt Python 3.14.0-1 documentation" href="../index.html"/>
<script src="../_static/js/modernizr.min.js"></script>
@ -64,7 +64,7 @@
<div class="version">
3.13.0-1
3.14.0-1
</div>
@ -195,7 +195,7 @@
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT:'../',
VERSION:'3.13.0-1',
VERSION:'3.14.0-1',
COLLAPSE_INDEX:false,
FILE_SUFFIX:'.html',
HAS_SOURCE: true,

310
_modules/wolfcrypt/ciphers.html
View File

@ -8,7 +8,7 @@
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>wolfcrypt.ciphers &mdash; wolfcrypt Python 3.13.0-1 documentation</title>
<title>wolfcrypt.ciphers &mdash; wolfcrypt Python 3.14.0-1 documentation</title>
@ -35,7 +35,7 @@
<link rel="index" title="Index"
href="../../genindex.html"/>
<link rel="search" title="Search" href="../../search.html"/>
<link rel="top" title="wolfcrypt Python 3.13.0-1 documentation" href="../../index.html"/>
<link rel="top" title="wolfcrypt Python 3.14.0-1 documentation" href="../../index.html"/>
<link rel="up" title="Module code" href="../index.html"/>
@ -65,7 +65,7 @@
<div class="version">
3.13.0-1
3.14.0-1
</div>
@ -221,16 +221,18 @@
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">key_size</span><span class="p">:</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">key_size</span> <span class="o">!=</span> <span class="nb">len</span><span class="p">(</span><span class="n">key</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;key must be </span><span class="si">%d</span><span class="s2"> in length&quot;</span> <span class="o">%</span> <span class="bp">self</span><span class="o">.</span><span class="n">key_size</span><span class="p">)</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;key must be </span><span class="si">%d</span><span class="s2"> in length, not </span><span class="si">%d</span><span class="s2">&quot;</span> <span class="o">%</span>
<span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">key_size</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">key</span><span class="p">)))</span>
<span class="k">elif</span> <span class="bp">self</span><span class="o">.</span><span class="n">_key_sizes</span><span class="p">:</span>
<span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">key</span><span class="p">)</span> <span class="ow">not</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">_key_sizes</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;key must be </span><span class="si">%s</span><span class="s2"> in length&quot;</span> <span class="o">%</span> <span class="bp">self</span><span class="o">.</span><span class="n">_key_sizes</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">key</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;key must not be 0 in length&quot;</span><span class="p">)</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;key must be </span><span class="si">%s</span><span class="s2"> in length, not </span><span class="si">%d</span><span class="s2">&quot;</span> <span class="o">%</span>
<span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_key_sizes</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">key</span><span class="p">)))</span>
<span class="k">elif</span> <span class="ow">not</span> <span class="n">key</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;key must not be 0 in length&quot;</span><span class="p">)</span>
<span class="k">if</span> <span class="n">IV</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span> <span class="ow">and</span> <span class="nb">len</span><span class="p">(</span><span class="n">IV</span><span class="p">)</span> <span class="o">!=</span> <span class="bp">self</span><span class="o">.</span><span class="n">block_size</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;IV must be </span><span class="si">%d</span><span class="s2"> in length&quot;</span> <span class="o">%</span> <span class="bp">self</span><span class="o">.</span><span class="n">block_size</span><span class="p">)</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;IV must be </span><span class="si">%d</span><span class="s2"> in length, not </span><span class="si">%d</span><span class="s2">&quot;</span> <span class="o">%</span>
<span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">block_size</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">IV</span><span class="p">)))</span>
<span class="bp">self</span><span class="o">.</span><span class="n">_native_object</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_native_type</span><span class="p">)</span>
<span class="bp">self</span><span class="o">.</span><span class="n">_enc</span> <span class="o">=</span> <span class="kc">None</span>
@ -239,8 +241,8 @@
<span class="k">if</span> <span class="n">IV</span><span class="p">:</span>
<span class="bp">self</span><span class="o">.</span><span class="n">_IV</span> <span class="o">=</span> <span class="n">t2b</span><span class="p">(</span><span class="n">IV</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="bp">self</span><span class="o">.</span><span class="n">_IV</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s1">&#39;byte[</span><span class="si">%d</span><span class="s1">]&#39;</span> <span class="o">%</span> <span class="bp">self</span><span class="o">.</span><span class="n">block_size</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="bp">self</span><span class="o">.</span><span class="n">_IV</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s2">&quot;byte[</span><span class="si">%d</span><span class="s2">]&quot;</span> <span class="o">%</span> <span class="bp">self</span><span class="o">.</span><span class="n">block_size</span><span class="p">)</span>
<div class="viewcode-block" id="_Cipher.new"><a class="viewcode-back" href="../../symmetric.html#wolfcrypt.ciphers._Cipher.new">[docs]</a> <span class="nd">@classmethod</span>
<span class="k">def</span> <span class="nf">new</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">mode</span><span class="p">,</span> <span class="n">IV</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">):</span> <span class="c1"># pylint: disable=W0613</span>
@ -253,16 +255,18 @@
<span class="sd"> must be a string of the same length as the block size. Not</span>
<span class="sd"> providing a value of **IV** will result in a ValueError exception</span>
<span class="sd"> being raised.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">return</span> <span class="bp">cls</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">mode</span><span class="p">,</span> <span class="n">IV</span><span class="p">)</span></div>
<span class="sd"> &quot;&quot;&quot;</span></div>
<span class="k">return</span> <span class="bp">cls</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">mode</span><span class="p">,</span> <span class="n">IV</span><span class="p">)</span>
<div class="viewcode-block" id="_Cipher.encrypt"><a class="viewcode-back" href="../../symmetric.html#wolfcrypt.ciphers._Cipher.encrypt">[docs]</a> <span class="k">def</span> <span class="nf">encrypt</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">string</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="sd"> Encrypts a non-empty string, using the key-dependent data in</span>
<span class="sd"> the object, and with the appropriate feedback mode. The</span>
<span class="sd"> string&#39;s length must be an exact multiple of the algorithm&#39;s</span>
<span class="sd"> block size or, in CFB mode, of the segment size. Returns a</span>
<span class="sd"> string containing the ciphertext.</span>
<span class="sd"> the object, and with the appropriate feedback mode.</span>
<span class="sd"> The string&#39;s length must be an exact multiple of the algorithm&#39;s</span>
<span class="sd"> block size or, in CFB mode, of the segment size.</span>
<span class="sd"> Returns a string containing the ciphertext.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">string</span> <span class="o">=</span> <span class="n">t2b</span><span class="p">(</span><span class="n">string</span><span class="p">)</span>
@ -273,23 +277,25 @@
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">_enc</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="bp">self</span><span class="o">.</span><span class="n">_enc</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_native_type</span><span class="p">)</span>
<span class="n">ret</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_set_key</span><span class="p">(</span><span class="n">_ENCRYPTION</span><span class="p">)</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Invalid key error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
<span class="n">result</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s1">&#39;byte[</span><span class="si">%d</span><span class="s1">]&#39;</span> <span class="o">%</span> <span class="nb">len</span><span class="p">(</span><span class="n">string</span><span class="p">))</span>
<span class="n">result</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s2">&quot;byte[</span><span class="si">%d</span><span class="s2">]&quot;</span> <span class="o">%</span> <span class="nb">len</span><span class="p">(</span><span class="n">string</span><span class="p">))</span>
<span class="n">ret</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_encrypt</span><span class="p">(</span><span class="n">result</span><span class="p">,</span> <span class="n">string</span><span class="p">)</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Encryption error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
<span class="k">return</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">buffer</span><span class="p">(</span><span class="n">result</span><span class="p">)[:]</span></div>
</div>
<span class="k">return</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">buffer</span><span class="p">(</span><span class="n">result</span><span class="p">)[:]</span>
<div class="viewcode-block" id="_Cipher.decrypt"><a class="viewcode-back" href="../../symmetric.html#wolfcrypt.ciphers._Cipher.decrypt">[docs]</a> <span class="k">def</span> <span class="nf">decrypt</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">string</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="sd"> Decrypts **string**, using the key-dependent data in the</span>
<span class="sd"> object and with the appropriate feedback mode. The string&#39;s</span>
<span class="sd"> length must be an exact multiple of the algorithm&#39;s block</span>
<span class="sd"> size or, in CFB mode, of the segment size. Returns a string</span>
<span class="sd"> containing the plaintext.</span>
<span class="sd"> object and with the appropriate feedback mode.</span>
<span class="sd"> The string&#39;s length must be an exact multiple of the algorithm&#39;s</span>
<span class="sd"> block size or, in CFB mode, of the segment size.</span>
<span class="sd"> Returns a string containing the plaintext.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">string</span> <span class="o">=</span> <span class="n">t2b</span><span class="p">(</span><span class="n">string</span><span class="p">)</span>
@ -300,15 +306,15 @@
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">_dec</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="bp">self</span><span class="o">.</span><span class="n">_dec</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_native_type</span><span class="p">)</span>
<span class="n">ret</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_set_key</span><span class="p">(</span><span class="n">_DECRYPTION</span><span class="p">)</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Invalid key error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
<span class="n">result</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s1">&#39;byte[</span><span class="si">%d</span><span class="s1">]&#39;</span> <span class="o">%</span> <span class="nb">len</span><span class="p">(</span><span class="n">string</span><span class="p">))</span>
<span class="n">result</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s2">&quot;byte[</span><span class="si">%d</span><span class="s2">]&quot;</span> <span class="o">%</span> <span class="nb">len</span><span class="p">(</span><span class="n">string</span><span class="p">))</span>
<span class="n">ret</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_decrypt</span><span class="p">(</span><span class="n">result</span><span class="p">,</span> <span class="n">string</span><span class="p">)</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Decryption error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
<span class="k">return</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">buffer</span><span class="p">(</span><span class="n">result</span><span class="p">)[:]</span></div></div>
</div></div>
<span class="k">return</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">buffer</span><span class="p">(</span><span class="n">result</span><span class="p">)[:]</span>
<div class="viewcode-block" id="Aes"><a class="viewcode-back" href="../../symmetric.html#wolfcrypt.ciphers.Aes">[docs]</a><span class="k">class</span> <span class="nc">Aes</span><span class="p">(</span><span class="n">_Cipher</span><span class="p">):</span>
@ -334,8 +340,8 @@
<span class="n">source</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">source</span><span class="p">))</span>
<span class="k">def</span> <span class="nf">_decrypt</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">destination</span><span class="p">,</span> <span class="n">source</span><span class="p">):</span>
<span class="k">return</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_AesCbcDecrypt</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_dec</span><span class="p">,</span> <span class="n">destination</span><span class="p">,</span>
<span class="n">source</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">source</span><span class="p">))</span></div>
<span class="k">return</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_AesCbcDecrypt</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_dec</span><span class="p">,</span> <span class="n">destination</span><span class="p">,</span></div>
<span class="n">source</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">source</span><span class="p">))</span>
<div class="viewcode-block" id="Des3"><a class="viewcode-back" href="../../symmetric.html#wolfcrypt.ciphers.Des3">[docs]</a><span class="k">class</span> <span class="nc">Des3</span><span class="p">(</span><span class="n">_Cipher</span><span class="p">):</span>
@ -362,8 +368,8 @@
<span class="n">source</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">source</span><span class="p">))</span>
<span class="k">def</span> <span class="nf">_decrypt</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">destination</span><span class="p">,</span> <span class="n">source</span><span class="p">):</span>
<span class="k">return</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_Des3_CbcDecrypt</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_dec</span><span class="p">,</span> <span class="n">destination</span><span class="p">,</span>
<span class="n">source</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">source</span><span class="p">))</span></div>
<span class="k">return</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_Des3_CbcDecrypt</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_dec</span><span class="p">,</span> <span class="n">destination</span><span class="p">,</span></div>
<span class="n">source</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">source</span><span class="p">))</span>
<span class="k">class</span> <span class="nc">_Rsa</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span> <span class="c1"># pylint: disable=too-few-public-methods</span>
@ -372,12 +378,12 @@
<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">native_object</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s2">&quot;RsaKey *&quot;</span><span class="p">)</span>
<span class="n">ret</span> <span class="o">=</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_InitRsaKey</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">native_object</span><span class="p">,</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">NULL</span><span class="p">)</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Invalid key error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
<span class="bp">self</span><span class="o">.</span><span class="n">_random</span> <span class="o">=</span> <span class="n">Random</span><span class="p">()</span>
<span class="n">ret</span> <span class="o">=</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_RsaSetRNG</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">native_object</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">_random</span><span class="o">.</span><span class="n">native_object</span><span class="p">)</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Key initialization error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">__del__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
@ -400,7 +406,7 @@
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Invalid key error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
<span class="bp">self</span><span class="o">.</span><span class="n">output_size</span> <span class="o">=</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_RsaEncryptSize</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">native_object</span><span class="p">)</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">output_size</span> <span class="o">&lt;=</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">output_size</span> <span class="o">&lt;=</span> <span class="mi">0</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Invalid key error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="bp">self</span><span class="o">.</span><span class="n">output_size</span><span class="p">)</span>
<div class="viewcode-block" id="RsaPublic.encrypt"><a class="viewcode-back" href="../../asymmetric.html#wolfcrypt.ciphers.RsaPublic.encrypt">[docs]</a> <span class="k">def</span> <span class="nf">encrypt</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">plaintext</span><span class="p">):</span>
@ -414,17 +420,17 @@
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">plaintext</span> <span class="o">=</span> <span class="n">t2b</span><span class="p">(</span><span class="n">plaintext</span><span class="p">)</span>
<span class="n">ciphertext</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s1">&#39;byte[</span><span class="si">%d</span><span class="s1">]&#39;</span> <span class="o">%</span> <span class="bp">self</span><span class="o">.</span><span class="n">output_size</span><span class="p">)</span>
<span class="n">ciphertext</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s2">&quot;byte[</span><span class="si">%d</span><span class="s2">]&quot;</span> <span class="o">%</span> <span class="bp">self</span><span class="o">.</span><span class="n">output_size</span><span class="p">)</span>
<span class="n">ret</span> <span class="o">=</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_RsaPublicEncrypt</span><span class="p">(</span><span class="n">plaintext</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">plaintext</span><span class="p">),</span>
<span class="n">ciphertext</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">output_size</span><span class="p">,</span>
<span class="bp">self</span><span class="o">.</span><span class="n">native_object</span><span class="p">,</span>
<span class="bp">self</span><span class="o">.</span><span class="n">_random</span><span class="o">.</span><span class="n">native_object</span><span class="p">)</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">!=</span> <span class="bp">self</span><span class="o">.</span><span class="n">output_size</span><span class="p">:</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">!=</span> <span class="bp">self</span><span class="o">.</span><span class="n">output_size</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Encryption error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
<span class="k">return</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">buffer</span><span class="p">(</span><span class="n">ciphertext</span><span class="p">)[:]</span></div>
</div>
<span class="k">return</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">buffer</span><span class="p">(</span><span class="n">ciphertext</span><span class="p">)[:]</span>
<div class="viewcode-block" id="RsaPublic.verify"><a class="viewcode-back" href="../../asymmetric.html#wolfcrypt.ciphers.RsaPublic.verify">[docs]</a> <span class="k">def</span> <span class="nf">verify</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">signature</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;</span>
@ -436,16 +442,16 @@
<span class="sd"> Returns a string containing the plaintext.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">signature</span> <span class="o">=</span> <span class="n">t2b</span><span class="p">(</span><span class="n">signature</span><span class="p">)</span>
<span class="n">plaintext</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s1">&#39;byte[</span><span class="si">%d</span><span class="s1">]&#39;</span> <span class="o">%</span> <span class="bp">self</span><span class="o">.</span><span class="n">output_size</span><span class="p">)</span>
<span class="n">plaintext</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s2">&quot;byte[</span><span class="si">%d</span><span class="s2">]&quot;</span> <span class="o">%</span> <span class="bp">self</span><span class="o">.</span><span class="n">output_size</span><span class="p">)</span>
<span class="n">ret</span> <span class="o">=</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_RsaSSL_Verify</span><span class="p">(</span><span class="n">signature</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">signature</span><span class="p">),</span>
<span class="n">plaintext</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">output_size</span><span class="p">,</span>
<span class="bp">self</span><span class="o">.</span><span class="n">native_object</span><span class="p">)</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Verify error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
<span class="k">return</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">buffer</span><span class="p">(</span><span class="n">plaintext</span><span class="p">,</span> <span class="n">ret</span><span class="p">)[:]</span></div></div>
</div></div>
<span class="k">return</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">buffer</span><span class="p">(</span><span class="n">plaintext</span><span class="p">,</span> <span class="n">ret</span><span class="p">)[:]</span>
<div class="viewcode-block" id="RsaPrivate"><a class="viewcode-back" href="../../asymmetric.html#wolfcrypt.ciphers.RsaPrivate">[docs]</a><span class="k">class</span> <span class="nc">RsaPrivate</span><span class="p">(</span><span class="n">RsaPublic</span><span class="p">):</span>
@ -463,7 +469,7 @@
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Invalid key error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
<span class="bp">self</span><span class="o">.</span><span class="n">output_size</span> <span class="o">=</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_RsaEncryptSize</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">native_object</span><span class="p">)</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">output_size</span> <span class="o">&lt;=</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">output_size</span> <span class="o">&lt;=</span> <span class="mi">0</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Invalid key error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="bp">self</span><span class="o">.</span><span class="n">output_size</span><span class="p">)</span>
<div class="viewcode-block" id="RsaPrivate.decrypt"><a class="viewcode-back" href="../../asymmetric.html#wolfcrypt.ciphers.RsaPrivate.decrypt">[docs]</a> <span class="k">def</span> <span class="nf">decrypt</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">ciphertext</span><span class="p">):</span>
@ -476,16 +482,16 @@
<span class="sd"> Returns a string containing the plaintext.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">ciphertext</span> <span class="o">=</span> <span class="n">t2b</span><span class="p">(</span><span class="n">ciphertext</span><span class="p">)</span>
<span class="n">plaintext</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s1">&#39;byte[</span><span class="si">%d</span><span class="s1">]&#39;</span> <span class="o">%</span> <span class="bp">self</span><span class="o">.</span><span class="n">output_size</span><span class="p">)</span>
<span class="n">plaintext</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s2">&quot;byte[</span><span class="si">%d</span><span class="s2">]&quot;</span> <span class="o">%</span> <span class="bp">self</span><span class="o">.</span><span class="n">output_size</span><span class="p">)</span>
<span class="n">ret</span> <span class="o">=</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_RsaPrivateDecrypt</span><span class="p">(</span><span class="n">ciphertext</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">ciphertext</span><span class="p">),</span>
<span class="n">plaintext</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">output_size</span><span class="p">,</span>
<span class="bp">self</span><span class="o">.</span><span class="n">native_object</span><span class="p">)</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Decryption error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
<span class="k">return</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">buffer</span><span class="p">(</span><span class="n">plaintext</span><span class="p">,</span> <span class="n">ret</span><span class="p">)[:]</span></div>
</div>
<span class="k">return</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">buffer</span><span class="p">(</span><span class="n">plaintext</span><span class="p">,</span> <span class="n">ret</span><span class="p">)[:]</span>
<div class="viewcode-block" id="RsaPrivate.sign"><a class="viewcode-back" href="../../asymmetric.html#wolfcrypt.ciphers.RsaPrivate.sign">[docs]</a> <span class="k">def</span> <span class="nf">sign</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">plaintext</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;</span>
@ -497,17 +503,211 @@
<span class="sd"> Returns a string containing the signature.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">plaintext</span> <span class="o">=</span> <span class="n">t2b</span><span class="p">(</span><span class="n">plaintext</span><span class="p">)</span>
<span class="n">signature</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s1">&#39;byte[</span><span class="si">%d</span><span class="s1">]&#39;</span> <span class="o">%</span> <span class="bp">self</span><span class="o">.</span><span class="n">output_size</span><span class="p">)</span>
<span class="n">signature</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s2">&quot;byte[</span><span class="si">%d</span><span class="s2">]&quot;</span> <span class="o">%</span> <span class="bp">self</span><span class="o">.</span><span class="n">output_size</span><span class="p">)</span>
<span class="n">ret</span> <span class="o">=</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_RsaSSL_Sign</span><span class="p">(</span><span class="n">plaintext</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">plaintext</span><span class="p">),</span>
<span class="n">signature</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">output_size</span><span class="p">,</span>
<span class="bp">self</span><span class="o">.</span><span class="n">native_object</span><span class="p">,</span>
<span class="bp">self</span><span class="o">.</span><span class="n">_random</span><span class="o">.</span><span class="n">native_object</span><span class="p">)</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">!=</span> <span class="bp">self</span><span class="o">.</span><span class="n">output_size</span><span class="p">:</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">!=</span> <span class="bp">self</span><span class="o">.</span><span class="n">output_size</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Signature error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
</div></div>
<span class="k">return</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">buffer</span><span class="p">(</span><span class="n">signature</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">output_size</span><span class="p">)[:]</span>
<span class="k">return</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">buffer</span><span class="p">(</span><span class="n">signature</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">output_size</span><span class="p">)[:]</span></div></div>
<span class="k">class</span> <span class="nc">_Ecc</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span> <span class="c1"># pylint: disable=too-few-public-methods</span>
<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">native_object</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s2">&quot;ecc_key *&quot;</span><span class="p">)</span>
<span class="n">ret</span> <span class="o">=</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_ecc_init</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">native_object</span><span class="p">)</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Invalid key error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">__del__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">native_object</span><span class="p">:</span>
<span class="n">_lib</span><span class="o">.</span><span class="n">wc_ecc_free</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">native_object</span><span class="p">)</span>
<span class="nd">@property</span>
<span class="k">def</span> <span class="nf">size</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">return</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_ecc_size</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">native_object</span><span class="p">)</span>
<span class="nd">@property</span>
<span class="k">def</span> <span class="nf">max_signature_size</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">return</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_ecc_sig_size</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">native_object</span><span class="p">)</span>
<div class="viewcode-block" id="EccPublic"><a class="viewcode-back" href="../../asymmetric.html#wolfcrypt.ciphers.EccPublic">[docs]</a><span class="k">class</span> <span class="nc">EccPublic</span><span class="p">(</span><span class="n">_Ecc</span><span class="p">):</span>
<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="n">_Ecc</span><span class="o">.</span><span class="fm">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
<span class="k">if</span> <span class="n">key</span><span class="p">:</span>
<span class="bp">self</span><span class="o">.</span><span class="n">decode_key</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
<div class="viewcode-block" id="EccPublic.decode_key"><a class="viewcode-back" href="../../asymmetric.html#wolfcrypt.ciphers.EccPublic.decode_key">[docs]</a> <span class="k">def</span> <span class="nf">decode_key</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="sd"> Decodes an ECC public key from an ASN sequence.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">key</span> <span class="o">=</span> <span class="n">t2b</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
<span class="n">idx</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s2">&quot;word32*&quot;</span><span class="p">)</span>
<span class="n">idx</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="mi">0</span>
<span class="n">ret</span> <span class="o">=</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_EccPublicKeyDecode</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">idx</span><span class="p">,</span>
<span class="bp">self</span><span class="o">.</span><span class="n">native_object</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">key</span><span class="p">))</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Key decode error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">size</span> <span class="o">&lt;=</span> <span class="mi">0</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Key decode error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="bp">self</span><span class="o">.</span><span class="n">size</span><span class="p">)</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">max_signature_size</span> <span class="o">&lt;=</span> <span class="mi">0</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span></div>
<span class="s2">&quot;Key decode error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="bp">self</span><span class="o">.</span><span class="n">max_signature_size</span><span class="p">)</span>
<div class="viewcode-block" id="EccPublic.encode_key"><a class="viewcode-back" href="../../asymmetric.html#wolfcrypt.ciphers.EccPublic.encode_key">[docs]</a> <span class="k">def</span> <span class="nf">encode_key</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">with_curve</span><span class="o">=</span><span class="kc">True</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="sd"> Encodes the ECC public key in an ASN sequence.</span>
<span class="sd"> Returns the encoded key.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">key</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s2">&quot;byte[</span><span class="si">%d</span><span class="s2">]&quot;</span> <span class="o">%</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">size</span> <span class="o">*</span> <span class="mi">4</span><span class="p">))</span>
<span class="n">ret</span> <span class="o">=</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_EccPublicKeyToDer</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">native_object</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">key</span><span class="p">),</span>
<span class="n">with_curve</span><span class="p">)</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;=</span> <span class="mi">0</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Key encode error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
</div>
<span class="k">return</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">buffer</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">ret</span><span class="p">)[:]</span>
<div class="viewcode-block" id="EccPublic.import_x963"><a class="viewcode-back" href="../../asymmetric.html#wolfcrypt.ciphers.EccPublic.import_x963">[docs]</a> <span class="k">def</span> <span class="nf">import_x963</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">x963</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="sd"> Imports an ECC public key in ANSI X9.63 format.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">ret</span> <span class="o">=</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_ecc_import_x963</span><span class="p">(</span><span class="n">x963</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">x963</span><span class="p">),</span> <span class="bp">self</span><span class="o">.</span><span class="n">native_object</span><span class="p">)</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">!=</span> <span class="mi">0</span><span class="p">:</span></div>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;x963 import error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
<div class="viewcode-block" id="EccPublic.export_x963"><a class="viewcode-back" href="../../asymmetric.html#wolfcrypt.ciphers.EccPublic.export_x963">[docs]</a> <span class="k">def</span> <span class="nf">export_x963</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="sd"> Exports the public key data of the object in ANSI X9.63 format.</span>
<span class="sd"> Returns the exported key.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">x963</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s2">&quot;byte[</span><span class="si">%d</span><span class="s2">]&quot;</span> <span class="o">%</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">size</span> <span class="o">*</span> <span class="mi">4</span><span class="p">))</span>
<span class="n">x963_size</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s2">&quot;word32[1]&quot;</span><span class="p">)</span>
<span class="n">x963_size</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">size</span> <span class="o">*</span> <span class="mi">4</span>
<span class="n">ret</span> <span class="o">=</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_ecc_export_x963</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">native_object</span><span class="p">,</span> <span class="n">x963</span><span class="p">,</span> <span class="n">x963_size</span><span class="p">)</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">!=</span> <span class="mi">0</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;x963 export error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
</div>
<span class="k">return</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">buffer</span><span class="p">(</span><span class="n">x963</span><span class="p">,</span> <span class="n">x963_size</span><span class="p">[</span><span class="mi">0</span><span class="p">])[:]</span>
<div class="viewcode-block" id="EccPublic.verify"><a class="viewcode-back" href="../../asymmetric.html#wolfcrypt.ciphers.EccPublic.verify">[docs]</a> <span class="k">def</span> <span class="nf">verify</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">signature</span><span class="p">,</span> <span class="n">data</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="sd"> Verifies **signature**, using the public key data in the object.</span>
<span class="sd"> Returns **True** in case of a valid signature, otherwise **False**.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">data</span> <span class="o">=</span> <span class="n">t2b</span><span class="p">(</span><span class="n">data</span><span class="p">)</span>
<span class="n">status</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s2">&quot;int[1]&quot;</span><span class="p">)</span>
<span class="n">ret</span> <span class="o">=</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_ecc_verify_hash</span><span class="p">(</span><span class="n">signature</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">signature</span><span class="p">),</span>
<span class="n">data</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">data</span><span class="p">),</span>
<span class="n">status</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">native_object</span><span class="p">)</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Verify error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
</div></div>
<span class="k">return</span> <span class="n">status</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">==</span> <span class="mi">1</span>
<div class="viewcode-block" id="EccPrivate"><a class="viewcode-back" href="../../asymmetric.html#wolfcrypt.ciphers.EccPrivate">[docs]</a><span class="k">class</span> <span class="nc">EccPrivate</span><span class="p">(</span><span class="n">EccPublic</span><span class="p">):</span>
<div class="viewcode-block" id="EccPrivate.make_key"><a class="viewcode-back" href="../../asymmetric.html#wolfcrypt.ciphers.EccPrivate.make_key">[docs]</a> <span class="nd">@classmethod</span>
<span class="k">def</span> <span class="nf">make_key</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">size</span><span class="p">,</span> <span class="n">rng</span><span class="o">=</span><span class="n">Random</span><span class="p">()):</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="sd"> Generates a new key pair of desired length **size**.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">ecc</span> <span class="o">=</span> <span class="bp">cls</span><span class="p">()</span>
<span class="n">ret</span> <span class="o">=</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_ecc_make_key</span><span class="p">(</span><span class="n">rng</span><span class="o">.</span><span class="n">native_object</span><span class="p">,</span> <span class="n">size</span><span class="p">,</span> <span class="n">ecc</span><span class="o">.</span><span class="n">native_object</span><span class="p">)</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Key generation error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
</div>
<span class="k">return</span> <span class="n">ecc</span>
<div class="viewcode-block" id="EccPrivate.decode_key"><a class="viewcode-back" href="../../asymmetric.html#wolfcrypt.ciphers.EccPrivate.decode_key">[docs]</a> <span class="k">def</span> <span class="nf">decode_key</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="sd"> Decodes an ECC private key from an ASN sequence.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">key</span> <span class="o">=</span> <span class="n">t2b</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
<span class="n">idx</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s2">&quot;word32*&quot;</span><span class="p">)</span>
<span class="n">idx</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="mi">0</span>
<span class="n">ret</span> <span class="o">=</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_EccPrivateKeyDecode</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">idx</span><span class="p">,</span>
<span class="bp">self</span><span class="o">.</span><span class="n">native_object</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">key</span><span class="p">))</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Key decode error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">size</span> <span class="o">&lt;=</span> <span class="mi">0</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Key decode error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="bp">self</span><span class="o">.</span><span class="n">size</span><span class="p">)</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">max_signature_size</span> <span class="o">&lt;=</span> <span class="mi">0</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span></div>
<span class="s2">&quot;Key decode error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="bp">self</span><span class="o">.</span><span class="n">max_signature_size</span><span class="p">)</span>
<div class="viewcode-block" id="EccPrivate.encode_key"><a class="viewcode-back" href="../../asymmetric.html#wolfcrypt.ciphers.EccPrivate.encode_key">[docs]</a> <span class="k">def</span> <span class="nf">encode_key</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="sd"> Encodes the ECC private key in an ASN sequence.</span>
<span class="sd"> Returns the encoded key.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">key</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s2">&quot;byte[</span><span class="si">%d</span><span class="s2">]&quot;</span> <span class="o">%</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">size</span> <span class="o">*</span> <span class="mi">4</span><span class="p">))</span>
<span class="n">ret</span> <span class="o">=</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_EccKeyToDer</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">native_object</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">key</span><span class="p">))</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;=</span> <span class="mi">0</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Key encode error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
</div>
<span class="k">return</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">buffer</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">ret</span><span class="p">)[:]</span>
<div class="viewcode-block" id="EccPrivate.shared_secret"><a class="viewcode-back" href="../../asymmetric.html#wolfcrypt.ciphers.EccPrivate.shared_secret">[docs]</a> <span class="k">def</span> <span class="nf">shared_secret</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">peer</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="sd"> Generates a new secret key using the private key data in the object</span>
<span class="sd"> and the peer&#39;s public key.</span>
<span class="sd"> Returns the shared secret.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">shared_secret</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s2">&quot;byte[</span><span class="si">%d</span><span class="s2">]&quot;</span> <span class="o">%</span> <span class="bp">self</span><span class="o">.</span><span class="n">max_signature_size</span><span class="p">)</span>
<span class="n">secret_size</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s2">&quot;word32[1]&quot;</span><span class="p">)</span>
<span class="n">secret_size</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">max_signature_size</span>
<span class="n">ret</span> <span class="o">=</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_ecc_shared_secret</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">native_object</span><span class="p">,</span>
<span class="n">peer</span><span class="o">.</span><span class="n">native_object</span><span class="p">,</span>
<span class="n">shared_secret</span><span class="p">,</span> <span class="n">secret_size</span><span class="p">)</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">!=</span> <span class="mi">0</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Shared secret error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
</div>
<span class="k">return</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">buffer</span><span class="p">(</span><span class="n">shared_secret</span><span class="p">,</span> <span class="n">secret_size</span><span class="p">[</span><span class="mi">0</span><span class="p">])[:]</span>
<div class="viewcode-block" id="EccPrivate.sign"><a class="viewcode-back" href="../../asymmetric.html#wolfcrypt.ciphers.EccPrivate.sign">[docs]</a> <span class="k">def</span> <span class="nf">sign</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">plaintext</span><span class="p">,</span> <span class="n">rng</span><span class="o">=</span><span class="n">Random</span><span class="p">()):</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="sd"> Signs **plaintext**, using the private key data in the object.</span>
<span class="sd"> Returns the signature.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">plaintext</span> <span class="o">=</span> <span class="n">t2b</span><span class="p">(</span><span class="n">plaintext</span><span class="p">)</span>
<span class="n">signature</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s2">&quot;byte[</span><span class="si">%d</span><span class="s2">]&quot;</span> <span class="o">%</span> <span class="bp">self</span><span class="o">.</span><span class="n">max_signature_size</span><span class="p">)</span>
<span class="n">signature_size</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s2">&quot;word32[1]&quot;</span><span class="p">)</span>
<span class="n">signature_size</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">max_signature_size</span>
<span class="n">ret</span> <span class="o">=</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_ecc_sign_hash</span><span class="p">(</span><span class="n">plaintext</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">plaintext</span><span class="p">),</span>
<span class="n">signature</span><span class="p">,</span> <span class="n">signature_size</span><span class="p">,</span>
<span class="n">rng</span><span class="o">.</span><span class="n">native_object</span><span class="p">,</span>
<span class="bp">self</span><span class="o">.</span><span class="n">native_object</span><span class="p">)</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">!=</span> <span class="mi">0</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Signature error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
</div></div>
<span class="k">return</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">buffer</span><span class="p">(</span><span class="n">signature</span><span class="p">,</span> <span class="n">signature_size</span><span class="p">[</span><span class="mi">0</span><span class="p">])[:]</span>
</pre></div>
</div>
@ -544,7 +744,7 @@
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT:'../../',
VERSION:'3.13.0-1',
VERSION:'3.14.0-1',
COLLAPSE_INDEX:false,
FILE_SUFFIX:'.html',
HAS_SOURCE: true,

74
_modules/wolfcrypt/hashes.html
View File

@ -8,7 +8,7 @@
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>wolfcrypt.hashes &mdash; wolfcrypt Python 3.13.0-1 documentation</title>
<title>wolfcrypt.hashes &mdash; wolfcrypt Python 3.14.0-1 documentation</title>
@ -35,7 +35,7 @@
<link rel="index" title="Index"
href="../../genindex.html"/>
<link rel="search" title="Search" href="../../search.html"/>
<link rel="top" title="wolfcrypt Python 3.13.0-1 documentation" href="../../index.html"/>
<link rel="top" title="wolfcrypt Python 3.14.0-1 documentation" href="../../index.html"/>
<link rel="up" title="Module code" href="../index.html"/>
@ -65,7 +65,7 @@
<div class="version">
3.13.0-1
3.14.0-1
</div>
@ -196,7 +196,7 @@
<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">string</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">_native_object</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_native_type</span><span class="p">)</span>
<span class="n">ret</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_init</span><span class="p">()</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Hash init error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
<span class="k">if</span> <span class="n">string</span><span class="p">:</span>
@ -209,8 +209,8 @@
<span class="sd"> **string** parameter, if supplied, will be immediately</span>
<span class="sd"> hashed into the object&#39;s starting state, as if</span>
<span class="sd"> obj.update(string) was called.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">return</span> <span class="bp">cls</span><span class="p">(</span><span class="n">string</span><span class="p">)</span></div>
<span class="sd"> &quot;&quot;&quot;</span></div>
<span class="k">return</span> <span class="bp">cls</span><span class="p">(</span><span class="n">string</span><span class="p">)</span>
<div class="viewcode-block" id="_Hash.copy"><a class="viewcode-back" href="../../digest.html#wolfcrypt.hashes._Hash.copy">[docs]</a> <span class="k">def</span> <span class="nf">copy</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;</span>
@ -222,8 +222,8 @@
<span class="n">_ffi</span><span class="o">.</span><span class="n">memmove</span><span class="p">(</span><span class="n">copy</span><span class="o">.</span><span class="n">_native_object</span><span class="p">,</span> <span class="c1"># pylint: disable=protected-access</span>
<span class="bp">self</span><span class="o">.</span><span class="n">_native_object</span><span class="p">,</span>
<span class="bp">self</span><span class="o">.</span><span class="n">_native_size</span><span class="p">)</span>
<span class="k">return</span> <span class="n">copy</span></div>
</div>
<span class="k">return</span> <span class="n">copy</span>
<div class="viewcode-block" id="_Hash.update"><a class="viewcode-back" href="../../digest.html#wolfcrypt.hashes._Hash.update">[docs]</a> <span class="k">def</span> <span class="nf">update</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">string</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;</span>
@ -234,8 +234,8 @@
<span class="n">string</span> <span class="o">=</span> <span class="n">t2b</span><span class="p">(</span><span class="n">string</span><span class="p">)</span>
<span class="n">ret</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_update</span><span class="p">(</span><span class="n">string</span><span class="p">)</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Hash update error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span></div>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span> <span class="c1"># pragma: no cover</span></div>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Hash update error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
<div class="viewcode-block" id="_Hash.digest"><a class="viewcode-back" href="../../digest.html#wolfcrypt.hashes._Hash.digest">[docs]</a> <span class="k">def</span> <span class="nf">digest</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;</span>
@ -252,10 +252,10 @@
<span class="n">_ffi</span><span class="o">.</span><span class="n">memmove</span><span class="p">(</span><span class="n">obj</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">_native_object</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">_native_size</span><span class="p">)</span>
<span class="n">ret</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_final</span><span class="p">(</span><span class="n">obj</span><span class="p">,</span> <span class="n">result</span><span class="p">)</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Hash finalize error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
<span class="k">return</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">buffer</span><span class="p">(</span><span class="n">result</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">digest_size</span><span class="p">)[:]</span></div>
</div>
<span class="k">return</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">buffer</span><span class="p">(</span><span class="n">result</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">digest_size</span><span class="p">)[:]</span>
<div class="viewcode-block" id="_Hash.hexdigest"><a class="viewcode-back" href="../../digest.html#wolfcrypt.hashes._Hash.hexdigest">[docs]</a> <span class="k">def</span> <span class="nf">hexdigest</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;</span>
@ -263,8 +263,8 @@
<span class="sd"> containing hexadecimal digits. Lowercase letters are used</span>
<span class="sd"> for the digits &#39;a&#39; through &#39;f&#39;. Like the .digest() method,</span>
<span class="sd"> this method doesn&#39;t alter the object.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">return</span> <span class="n">b2h</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">digest</span><span class="p">())</span></div></div>
<span class="sd"> &quot;&quot;&quot;</span></div></div>
<span class="k">return</span> <span class="n">b2h</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">digest</span><span class="p">())</span>
<div class="viewcode-block" id="Sha"><a class="viewcode-back" href="../../digest.html#wolfcrypt.hashes.Sha">[docs]</a><span class="k">class</span> <span class="nc">Sha</span><span class="p">(</span><span class="n">_Hash</span><span class="p">):</span>
@ -283,8 +283,8 @@
<span class="k">def</span> <span class="nf">_update</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">data</span><span class="p">):</span>
<span class="k">return</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_ShaUpdate</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_native_object</span><span class="p">,</span> <span class="n">data</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">data</span><span class="p">))</span>
<span class="k">def</span> <span class="nf">_final</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">obj</span><span class="p">,</span> <span class="n">ret</span><span class="p">):</span>
<span class="k">return</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_ShaFinal</span><span class="p">(</span><span class="n">obj</span><span class="p">,</span> <span class="n">ret</span><span class="p">)</span></div>
<span class="k">def</span> <span class="nf">_final</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">obj</span><span class="p">,</span> <span class="n">ret</span><span class="p">):</span></div>
<span class="k">return</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_ShaFinal</span><span class="p">(</span><span class="n">obj</span><span class="p">,</span> <span class="n">ret</span><span class="p">)</span>
<div class="viewcode-block" id="Sha256"><a class="viewcode-back" href="../../digest.html#wolfcrypt.hashes.Sha256">[docs]</a><span class="k">class</span> <span class="nc">Sha256</span><span class="p">(</span><span class="n">_Hash</span><span class="p">):</span>
@ -304,8 +304,8 @@
<span class="k">def</span> <span class="nf">_update</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">data</span><span class="p">):</span>
<span class="k">return</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_Sha256Update</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_native_object</span><span class="p">,</span> <span class="n">data</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">data</span><span class="p">))</span>
<span class="k">def</span> <span class="nf">_final</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">obj</span><span class="p">,</span> <span class="n">ret</span><span class="p">):</span>
<span class="k">return</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_Sha256Final</span><span class="p">(</span><span class="n">obj</span><span class="p">,</span> <span class="n">ret</span><span class="p">)</span></div>
<span class="k">def</span> <span class="nf">_final</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">obj</span><span class="p">,</span> <span class="n">ret</span><span class="p">):</span></div>
<span class="k">return</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_Sha256Final</span><span class="p">(</span><span class="n">obj</span><span class="p">,</span> <span class="n">ret</span><span class="p">)</span>
<div class="viewcode-block" id="Sha384"><a class="viewcode-back" href="../../digest.html#wolfcrypt.hashes.Sha384">[docs]</a><span class="k">class</span> <span class="nc">Sha384</span><span class="p">(</span><span class="n">_Hash</span><span class="p">):</span>
@ -325,8 +325,8 @@
<span class="k">def</span> <span class="nf">_update</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">data</span><span class="p">):</span>
<span class="k">return</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_Sha384Update</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_native_object</span><span class="p">,</span> <span class="n">data</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">data</span><span class="p">))</span>
<span class="k">def</span> <span class="nf">_final</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">obj</span><span class="p">,</span> <span class="n">ret</span><span class="p">):</span>
<span class="k">return</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_Sha384Final</span><span class="p">(</span><span class="n">obj</span><span class="p">,</span> <span class="n">ret</span><span class="p">)</span></div>
<span class="k">def</span> <span class="nf">_final</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">obj</span><span class="p">,</span> <span class="n">ret</span><span class="p">):</span></div>
<span class="k">return</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_Sha384Final</span><span class="p">(</span><span class="n">obj</span><span class="p">,</span> <span class="n">ret</span><span class="p">)</span>
<div class="viewcode-block" id="Sha512"><a class="viewcode-back" href="../../digest.html#wolfcrypt.hashes.Sha512">[docs]</a><span class="k">class</span> <span class="nc">Sha512</span><span class="p">(</span><span class="n">_Hash</span><span class="p">):</span>
@ -346,8 +346,8 @@
<span class="k">def</span> <span class="nf">_update</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">data</span><span class="p">):</span>
<span class="k">return</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_Sha512Update</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_native_object</span><span class="p">,</span> <span class="n">data</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">data</span><span class="p">))</span>
<span class="k">def</span> <span class="nf">_final</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">obj</span><span class="p">,</span> <span class="n">ret</span><span class="p">):</span>
<span class="k">return</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_Sha512Final</span><span class="p">(</span><span class="n">obj</span><span class="p">,</span> <span class="n">ret</span><span class="p">)</span></div>
<span class="k">def</span> <span class="nf">_final</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">obj</span><span class="p">,</span> <span class="n">ret</span><span class="p">):</span></div>
<span class="k">return</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_Sha512Final</span><span class="p">(</span><span class="n">obj</span><span class="p">,</span> <span class="n">ret</span><span class="p">)</span>
<span class="c1"># Hmac types</span>
@ -373,7 +373,7 @@
<span class="bp">self</span><span class="o">.</span><span class="n">_native_object</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_native_type</span><span class="p">)</span>
<span class="n">ret</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_init</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_type</span><span class="p">,</span> <span class="n">key</span><span class="p">)</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;Hmac init error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
<span class="k">if</span> <span class="n">string</span><span class="p">:</span>
@ -387,8 +387,8 @@
<span class="sd"> to use. The optional **string** parameter, if supplied,</span>
<span class="sd"> will be immediately hashed into the object&#39;s starting</span>
<span class="sd"> state, as if obj.update(string) was called.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">return</span> <span class="bp">cls</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">string</span><span class="p">)</span></div>
<span class="sd"> &quot;&quot;&quot;</span></div>
<span class="k">return</span> <span class="bp">cls</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">string</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">_init</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">hmac</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
<span class="k">return</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_HmacSetKey</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_native_object</span><span class="p">,</span> <span class="n">hmac</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">key</span><span class="p">))</span>
@ -396,8 +396,8 @@
<span class="k">def</span> <span class="nf">_update</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">data</span><span class="p">):</span>
<span class="k">return</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_HmacUpdate</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_native_object</span><span class="p">,</span> <span class="n">data</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">data</span><span class="p">))</span>
<span class="k">def</span> <span class="nf">_final</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">obj</span><span class="p">,</span> <span class="n">ret</span><span class="p">):</span>
<span class="k">return</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_HmacFinal</span><span class="p">(</span><span class="n">obj</span><span class="p">,</span> <span class="n">ret</span><span class="p">)</span></div>
<span class="k">def</span> <span class="nf">_final</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">obj</span><span class="p">,</span> <span class="n">ret</span><span class="p">):</span></div>
<span class="k">return</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_HmacFinal</span><span class="p">(</span><span class="n">obj</span><span class="p">,</span> <span class="n">ret</span><span class="p">)</span>
<div class="viewcode-block" id="HmacSha"><a class="viewcode-back" href="../../mac.html#wolfcrypt.hashes.HmacSha">[docs]</a><span class="k">class</span> <span class="nc">HmacSha</span><span class="p">(</span><span class="n">_Hmac</span><span class="p">):</span>
@ -407,8 +407,8 @@
<span class="sd"> It produces a [ **512-bit | 64 bytes** ] message digest.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">_type</span> <span class="o">=</span> <span class="n">_TYPE_SHA</span>
<span class="n">digest_size</span> <span class="o">=</span> <span class="n">Sha</span><span class="o">.</span><span class="n">digest_size</span></div>
<span class="n">_type</span> <span class="o">=</span> <span class="n">_TYPE_SHA</span></div>
<span class="n">digest_size</span> <span class="o">=</span> <span class="n">Sha</span><span class="o">.</span><span class="n">digest_size</span>
<div class="viewcode-block" id="HmacSha256"><a class="viewcode-back" href="../../mac.html#wolfcrypt.hashes.HmacSha256">[docs]</a><span class="k">class</span> <span class="nc">HmacSha256</span><span class="p">(</span><span class="n">_Hmac</span><span class="p">):</span>
@ -418,8 +418,8 @@
<span class="sd"> It produces a [ **512-bit | 64 bytes** ] message digest.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">_type</span> <span class="o">=</span> <span class="n">_TYPE_SHA256</span>
<span class="n">digest_size</span> <span class="o">=</span> <span class="n">Sha256</span><span class="o">.</span><span class="n">digest_size</span></div>
<span class="n">_type</span> <span class="o">=</span> <span class="n">_TYPE_SHA256</span></div>
<span class="n">digest_size</span> <span class="o">=</span> <span class="n">Sha256</span><span class="o">.</span><span class="n">digest_size</span>
<div class="viewcode-block" id="HmacSha384"><a class="viewcode-back" href="../../mac.html#wolfcrypt.hashes.HmacSha384">[docs]</a><span class="k">class</span> <span class="nc">HmacSha384</span><span class="p">(</span><span class="n">_Hmac</span><span class="p">):</span>
@ -429,8 +429,8 @@
<span class="sd"> It produces a [ **512-bit | 64 bytes** ] message digest.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">_type</span> <span class="o">=</span> <span class="n">_TYPE_SHA384</span>
<span class="n">digest_size</span> <span class="o">=</span> <span class="n">Sha384</span><span class="o">.</span><span class="n">digest_size</span></div>
<span class="n">_type</span> <span class="o">=</span> <span class="n">_TYPE_SHA384</span></div>
<span class="n">digest_size</span> <span class="o">=</span> <span class="n">Sha384</span><span class="o">.</span><span class="n">digest_size</span>
<div class="viewcode-block" id="HmacSha512"><a class="viewcode-back" href="../../mac.html#wolfcrypt.hashes.HmacSha512">[docs]</a><span class="k">class</span> <span class="nc">HmacSha512</span><span class="p">(</span><span class="n">_Hmac</span><span class="p">):</span>
@ -440,8 +440,8 @@
<span class="sd"> It produces a [ **512-bit | 64 bytes** ] message digest.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">_type</span> <span class="o">=</span> <span class="n">_TYPE_SHA512</span>
<span class="n">digest_size</span> <span class="o">=</span> <span class="n">Sha512</span><span class="o">.</span><span class="n">digest_size</span></div>
<span class="n">_type</span> <span class="o">=</span> <span class="n">_TYPE_SHA512</span></div>
<span class="n">digest_size</span> <span class="o">=</span> <span class="n">Sha512</span><span class="o">.</span><span class="n">digest_size</span>
</pre></div>
</div>
@ -478,7 +478,7 @@
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT:'../../',
VERSION:'3.13.0-1',
VERSION:'3.14.0-1',
COLLAPSE_INDEX:false,
FILE_SUFFIX:'.html',
HAS_SOURCE: true,

24
_modules/wolfcrypt/random.html
View File

@ -8,7 +8,7 @@
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>wolfcrypt.random &mdash; wolfcrypt Python 3.13.0-1 documentation</title>
<title>wolfcrypt.random &mdash; wolfcrypt Python 3.14.0-1 documentation</title>
@ -35,7 +35,7 @@
<link rel="index" title="Index"
href="../../genindex.html"/>
<link rel="search" title="Search" href="../../search.html"/>
<link rel="top" title="wolfcrypt Python 3.13.0-1 documentation" href="../../index.html"/>
<link rel="top" title="wolfcrypt Python 3.14.0-1 documentation" href="../../index.html"/>
<link rel="up" title="Module code" href="../index.html"/>
@ -65,7 +65,7 @@
<div class="version">
3.13.0-1
3.14.0-1
</div>
@ -195,7 +195,7 @@
<span class="bp">self</span><span class="o">.</span><span class="n">native_object</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s2">&quot;WC_RNG *&quot;</span><span class="p">)</span>
<span class="n">ret</span> <span class="o">=</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_InitRng</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">native_object</span><span class="p">)</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="bp">self</span><span class="o">.</span><span class="n">native_object</span> <span class="o">=</span> <span class="kc">None</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;RNG init error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
@ -203,7 +203,7 @@
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">native_object</span><span class="p">:</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">_lib</span><span class="o">.</span><span class="n">wc_FreeRng</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">native_object</span><span class="p">)</span>
<span class="k">except</span> <span class="ne">AttributeError</span><span class="p">:</span>
<span class="k">except</span> <span class="ne">AttributeError</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="c1"># Can occur during interpreter shutdown</span>
<span class="k">pass</span>
@ -214,10 +214,10 @@
<span class="n">result</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s1">&#39;byte[1]&#39;</span><span class="p">)</span>
<span class="n">ret</span> <span class="o">=</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_RNG_GenerateByte</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">native_object</span><span class="p">,</span> <span class="n">result</span><span class="p">)</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;RNG generate byte error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
<span class="k">return</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">buffer</span><span class="p">(</span><span class="n">result</span><span class="p">,</span> <span class="mi">1</span><span class="p">)[:]</span></div>
</div>
<span class="k">return</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">buffer</span><span class="p">(</span><span class="n">result</span><span class="p">,</span> <span class="mi">1</span><span class="p">)[:]</span>
<div class="viewcode-block" id="Random.bytes"><a class="viewcode-back" href="../../random.html#wolfcrypt.random.Random.bytes">[docs]</a> <span class="k">def</span> <span class="nf">bytes</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">length</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;</span>
@ -226,10 +226,10 @@
<span class="n">result</span> <span class="o">=</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s1">&#39;byte[</span><span class="si">%d</span><span class="s1">]&#39;</span> <span class="o">%</span> <span class="n">length</span><span class="p">)</span>
<span class="n">ret</span> <span class="o">=</span> <span class="n">_lib</span><span class="o">.</span><span class="n">wc_RNG_GenerateBlock</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">native_object</span><span class="p">,</span> <span class="n">result</span><span class="p">,</span> <span class="n">length</span><span class="p">)</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">if</span> <span class="n">ret</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span> <span class="c1"># pragma: no cover</span>
<span class="k">raise</span> <span class="n">WolfCryptError</span><span class="p">(</span><span class="s2">&quot;RNG generate block error (</span><span class="si">%d</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="n">ret</span><span class="p">)</span>
<span class="k">return</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">buffer</span><span class="p">(</span><span class="n">result</span><span class="p">,</span> <span class="n">length</span><span class="p">)[:]</span></div></div>
</div></div>
<span class="k">return</span> <span class="n">_ffi</span><span class="o">.</span><span class="n">buffer</span><span class="p">(</span><span class="n">result</span><span class="p">,</span> <span class="n">length</span><span class="p">)[:]</span>
</pre></div>
</div>
@ -266,7 +266,7 @@
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT:'../../',
VERSION:'3.13.0-1',
VERSION:'3.14.0-1',
COLLAPSE_INDEX:false,
FILE_SUFFIX:'.html',
HAS_SOURCE: true,

19
_sources/asymmetric.rst.txt
View File

@ -9,8 +9,8 @@ one for data decryption and signature verification.
``wolfcrypt`` provides access to the following **Asymmetric Key Ciphers**:
Asymmetric Key Encryption Classes
---------------------------------
RSA
---
.. autoclass:: RsaPublic
:members:
@ -20,9 +20,7 @@ Asymmetric Key Encryption Classes
:members:
:inherited-members:
Example
-------
**Example:**
>>> from wolfcrypt.ciphers import RsaPrivate, RsaPublic
>>> from wolfcrypt.utils import h2b
@ -72,3 +70,14 @@ Example
>>>
>>> pub.verify(signature)
b'Everyone gets Friday off.'
ECC
---
.. autoclass:: EccPublic
:members:
:inherited-members:
.. autoclass:: EccPrivate
:members:
:inherited-members:

33
_sources/symmetric.rst.txt
View File

@ -4,11 +4,9 @@ Symmetric Key Algorithms
.. module:: wolfcrypt.ciphers
**Symmetric key algorithms** are encryption algorithms that use the **same
cryptographic keys** for both encryption and decryption of data.
cryptographic key** for both encryption and decryption of data.
This operation is also known as **Symmetric Key Encryption**.
``wolfcrypt`` provides access to the following **Symmetric Key Ciphers**:
Symmetric Key Encryption Classes
--------------------------------
@ -21,15 +19,13 @@ interface:
.. autoclass:: _Cipher
:members:
Classes
~~~~~~~
AES
~~~
.. autoclass:: Aes
:members:
.. autoclass:: Des3
Example
-------
**Example:**
.. doctest::
@ -41,3 +37,22 @@ Example
b'\x95\x94\x92W_B\x81S,\xcc\x9dFw\xa23\xcb'
>>> cipher.decrypt(ciphertext)
b'now is the time '
Triple DES
~~~~~~~~~~
.. autoclass:: Des3
:members:
**Example:**
.. doctest::
>>> from wolfcrypt.ciphers import Des3, MODE_CBC
>>>
>>> cipher = Des3(b'0123456789abcdeffedeba98', MODE_CBC, b'12345678')
>>> ciphertext = cipher.encrypt('now is the time ')
>>> ciphertext
b'l\x04\xd0$\xe8\x0c1\xd6\x1b\x07}V\xa6ty\xe8'
>>> cipher.decrypt(ciphertext)
b'now is the time '

24
_static/basic.css
View File

@ -82,9 +82,21 @@ div.sphinxsidebar input {
}
div.sphinxsidebar #searchbox input[type="text"] {
width: 170px;
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%;
@ -199,6 +211,11 @@ table.modindextable td {
/* -- 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;
@ -332,6 +349,11 @@ table.docutils {
border-collapse: collapse;
}
table.align-center {
margin-left: auto;
margin-right: auto;
}
table caption span.caption-number {
font-style: italic;
}

9
_static/documentation_options.js 100644
View File

@ -0,0 +1,9 @@
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '',
VERSION: '3.14.0-1',
LANGUAGE: 'None',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true,
SOURCELINK_SUFFIX: '.txt'
};

10253
_static/jquery-3.2.1.js vendored 100644
View File

File diff suppressed because it is too large Load Diff

8
_static/jquery.js vendored
View File

File diff suppressed because one or more lines are too long

2
_static/websupport.js
View File

@ -301,7 +301,7 @@
li.hide();
// Determine where in the parents children list to insert this comment.
for(i=0; i < siblings.length; i++) {
for(var i=0; i < siblings.length; i++) {
if (comp(comment, siblings[i]) <= 0) {
$('#cd' + siblings[i].id)
.parent()

144
asymmetric.html
View File

@ -8,7 +8,7 @@
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Asymmetric Key Algorithms &mdash; wolfcrypt Python 3.13.0-1 documentation</title>
<title>Asymmetric Key Algorithms &mdash; wolfcrypt Python 3.14.0-1 documentation</title>
@ -35,7 +35,7 @@
<link rel="index" title="Index"
href="genindex.html"/>
<link rel="search" title="Search" href="search.html"/>
<link rel="top" title="wolfcrypt Python 3.13.0-1 documentation" href="index.html"/>
<link rel="top" title="wolfcrypt Python 3.14.0-1 documentation" href="index.html"/>
<link rel="next" title="Message Digests" href="digest.html"/>
<link rel="prev" title="Symmetric Key Algorithms" href="symmetric.html"/>
@ -66,7 +66,7 @@
<div class="version">
3.13.0-1
3.14.0-1
</div>
@ -93,8 +93,8 @@
<ul class="current">
<li class="toctree-l1"><a class="reference internal" href="symmetric.html">Symmetric Key Algorithms</a></li>
<li class="toctree-l1 current"><a class="current reference internal" href="#">Asymmetric Key Algorithms</a><ul>
<li class="toctree-l2"><a class="reference internal" href="#asymmetric-key-encryption-classes">Asymmetric Key Encryption Classes</a></li>
<li class="toctree-l2"><a class="reference internal" href="#example">Example</a></li>
<li class="toctree-l2"><a class="reference internal" href="#rsa">RSA</a></li>
<li class="toctree-l2"><a class="reference internal" href="#ecc">ECC</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="digest.html">Message Digests</a></li>
@ -168,9 +168,9 @@
<p><strong>Asymmetric key algorithms</strong> are encryption algorithms that use <strong>a pair
of cryptographic keys</strong>, one for data encryption and signing and the other
one for data decryption and signature verification.</p>
<p><code class="docutils literal"><span class="pre">wolfcrypt</span></code> provides access to the following <strong>Asymmetric Key Ciphers</strong>:</p>
<div class="section" id="asymmetric-key-encryption-classes">
<h2>Asymmetric Key Encryption Classes<a class="headerlink" href="#asymmetric-key-encryption-classes" title="Permalink to this headline"></a></h2>
<p><code class="docutils literal notranslate"><span class="pre">wolfcrypt</span></code> provides access to the following <strong>Asymmetric Key Ciphers</strong>:</p>
<div class="section" id="rsa">
<h2>RSA<a class="headerlink" href="#rsa" title="Permalink to this headline"></a></h2>
<dl class="class">
<dt id="wolfcrypt.ciphers.RsaPublic">
<em class="property">class </em><code class="descclassname">wolfcrypt.ciphers.</code><code class="descname">RsaPublic</code><span class="sig-paren">(</span><em>key</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/wolfcrypt/ciphers.html#RsaPublic"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#wolfcrypt.ciphers.RsaPublic" title="Permalink to this definition"></a></dt>
@ -209,6 +209,16 @@ object. The ciphertext’s length must be equal to:</p>
<p>Returns a string containing the plaintext.</p>
</dd></dl>
<dl class="method">
<dt id="wolfcrypt.ciphers.RsaPrivate.sign">
<code class="descname">sign</code><span class="sig-paren">(</span><em>plaintext</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/wolfcrypt/ciphers.html#RsaPrivate.sign"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#wolfcrypt.ciphers.RsaPrivate.sign" title="Permalink to this definition"></a></dt>
<dd><p>Signs <strong>plaintext</strong>, using the private key data in the object.
The plaintext’s length must not be greater than:</p>
<blockquote>
<div><strong>self.output_size - self.RSA_MIN_PAD_SIZE</strong></div></blockquote>
<p>Returns a string containing the signature.</p>
</dd></dl>
<dl class="method">
<dt id="wolfcrypt.ciphers.RsaPrivate.encrypt">
<code class="descname">encrypt</code><span class="sig-paren">(</span><em>plaintext</em><span class="sig-paren">)</span><a class="headerlink" href="#wolfcrypt.ciphers.RsaPrivate.encrypt" title="Permalink to this definition"></a></dt>
@ -229,22 +239,10 @@ object. The signature’s length must be equal to:</p>
<p>Returns a string containing the plaintext.</p>
</dd></dl>
<dl class="method">
<dt id="wolfcrypt.ciphers.RsaPrivate.sign">
<code class="descname">sign</code><span class="sig-paren">(</span><em>plaintext</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/wolfcrypt/ciphers.html#RsaPrivate.sign"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#wolfcrypt.ciphers.RsaPrivate.sign" title="Permalink to this definition"></a></dt>
<dd><p>Signs <strong>plaintext</strong>, using the private key data in the object.
The plaintext’s length must not be greater than:</p>
<blockquote>
<div><strong>self.output_size - self.RSA_MIN_PAD_SIZE</strong></div></blockquote>
<p>Returns a string containing the signature.</p>
</dd></dl>
</dd></dl>
</div>
<div class="section" id="example">
<h2>Example<a class="headerlink" href="#example" title="Permalink to this headline"></a></h2>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">wolfcrypt.ciphers</span> <span class="k">import</span> <span class="n">RsaPrivate</span><span class="p">,</span> <span class="n">RsaPublic</span>
<p><strong>Example:</strong></p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">wolfcrypt.ciphers</span> <span class="k">import</span> <span class="n">RsaPrivate</span><span class="p">,</span> <span class="n">RsaPublic</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">wolfcrypt.utils</span> <span class="k">import</span> <span class="n">h2b</span>
<span class="go">&gt;&gt;&gt;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">private</span> <span class="o">=</span> <span class="s2">&quot;3082025C02010002818100BC730EA849F374A2A9EF18A5DA559921F9C8ECB36D&quot;</span> \
@ -294,6 +292,106 @@ The plaintext’s length must not be greater than:</p>
<span class="go">b&#39;Everyone gets Friday off.&#39;</span>
</pre></div>
</div>
</div>
<div class="section" id="ecc">
<h2>ECC<a class="headerlink" href="#ecc" title="Permalink to this headline"></a></h2>
<dl class="class">
<dt id="wolfcrypt.ciphers.EccPublic">
<em class="property">class </em><code class="descclassname">wolfcrypt.ciphers.</code><code class="descname">EccPublic</code><span class="sig-paren">(</span><em>key=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/wolfcrypt/ciphers.html#EccPublic"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#wolfcrypt.ciphers.EccPublic" title="Permalink to this definition"></a></dt>
<dd><dl class="method">
<dt id="wolfcrypt.ciphers.EccPublic.decode_key">
<code class="descname">decode_key</code><span class="sig-paren">(</span><em>key</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/wolfcrypt/ciphers.html#EccPublic.decode_key"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#wolfcrypt.ciphers.EccPublic.decode_key" title="Permalink to this definition"></a></dt>
<dd><p>Decodes an ECC public key from an ASN sequence.</p>
</dd></dl>
<dl class="method">
<dt id="wolfcrypt.ciphers.EccPublic.encode_key">
<code class="descname">encode_key</code><span class="sig-paren">(</span><em>with_curve=True</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/wolfcrypt/ciphers.html#EccPublic.encode_key"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#wolfcrypt.ciphers.EccPublic.encode_key" title="Permalink to this definition"></a></dt>
<dd><p>Encodes the ECC public key in an ASN sequence.</p>
<p>Returns the encoded key.</p>
</dd></dl>
<dl class="method">
<dt id="wolfcrypt.ciphers.EccPublic.import_x963">
<code class="descname">import_x963</code><span class="sig-paren">(</span><em>x963</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/wolfcrypt/ciphers.html#EccPublic.import_x963"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#wolfcrypt.ciphers.EccPublic.import_x963" title="Permalink to this definition"></a></dt>
<dd><p>Imports an ECC public key in ANSI X9.63 format.</p>
</dd></dl>
<dl class="method">
<dt id="wolfcrypt.ciphers.EccPublic.export_x963">
<code class="descname">export_x963</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/wolfcrypt/ciphers.html#EccPublic.export_x963"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#wolfcrypt.ciphers.EccPublic.export_x963" title="Permalink to this definition"></a></dt>
<dd><p>Exports the public key data of the object in ANSI X9.63 format.</p>
<p>Returns the exported key.</p>
</dd></dl>
<dl class="method">
<dt id="wolfcrypt.ciphers.EccPublic.verify">
<code class="descname">verify</code><span class="sig-paren">(</span><em>signature</em>, <em>data</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/wolfcrypt/ciphers.html#EccPublic.verify"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#wolfcrypt.ciphers.EccPublic.verify" title="Permalink to this definition"></a></dt>
<dd><p>Verifies <strong>signature</strong>, using the public key data in the object.</p>
<p>Returns <strong>True</strong> in case of a valid signature, otherwise <strong>False</strong>.</p>
</dd></dl>
</dd></dl>
<dl class="class">
<dt id="wolfcrypt.ciphers.EccPrivate">
<em class="property">class </em><code class="descclassname">wolfcrypt.ciphers.</code><code class="descname">EccPrivate</code><span class="sig-paren">(</span><em>key=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/wolfcrypt/ciphers.html#EccPrivate"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#wolfcrypt.ciphers.EccPrivate" title="Permalink to this definition"></a></dt>
<dd><dl class="classmethod">
<dt id="wolfcrypt.ciphers.EccPrivate.make_key">
<em class="property">classmethod </em><code class="descname">make_key</code><span class="sig-paren">(</span><em>size</em>, <em>rng=&lt;wolfcrypt.random.Random object&gt;</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/wolfcrypt/ciphers.html#EccPrivate.make_key"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#wolfcrypt.ciphers.EccPrivate.make_key" title="Permalink to this definition"></a></dt>
<dd><p>Generates a new key pair of desired length <strong>size</strong>.</p>
</dd></dl>
<dl class="method">
<dt id="wolfcrypt.ciphers.EccPrivate.decode_key">
<code class="descname">decode_key</code><span class="sig-paren">(</span><em>key</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/wolfcrypt/ciphers.html#EccPrivate.decode_key"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#wolfcrypt.ciphers.EccPrivate.decode_key" title="Permalink to this definition"></a></dt>
<dd><p>Decodes an ECC private key from an ASN sequence.</p>
</dd></dl>
<dl class="method">
<dt id="wolfcrypt.ciphers.EccPrivate.encode_key">
<code class="descname">encode_key</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/wolfcrypt/ciphers.html#EccPrivate.encode_key"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#wolfcrypt.ciphers.EccPrivate.encode_key" title="Permalink to this definition"></a></dt>
<dd><p>Encodes the ECC private key in an ASN sequence.</p>
<p>Returns the encoded key.</p>
</dd></dl>
<dl class="method">
<dt id="wolfcrypt.ciphers.EccPrivate.shared_secret">
<code class="descname">shared_secret</code><span class="sig-paren">(</span><em>peer</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/wolfcrypt/ciphers.html#EccPrivate.shared_secret"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#wolfcrypt.ciphers.EccPrivate.shared_secret" title="Permalink to this definition"></a></dt>
<dd><p>Generates a new secret key using the private key data in the object
and the peer’s public key.</p>
<p>Returns the shared secret.</p>
</dd></dl>
<dl class="method">
<dt id="wolfcrypt.ciphers.EccPrivate.export_x963">
<code class="descname">export_x963</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#wolfcrypt.ciphers.EccPrivate.export_x963" title="Permalink to this definition"></a></dt>
<dd><p>Exports the public key data of the object in ANSI X9.63 format.</p>
<p>Returns the exported key.</p>
</dd></dl>
<dl class="method">
<dt id="wolfcrypt.ciphers.EccPrivate.import_x963">
<code class="descname">import_x963</code><span class="sig-paren">(</span><em>x963</em><span class="sig-paren">)</span><a class="headerlink" href="#wolfcrypt.ciphers.EccPrivate.import_x963" title="Permalink to this definition"></a></dt>
<dd><p>Imports an ECC public key in ANSI X9.63 format.</p>
</dd></dl>
<dl class="method">
<dt id="wolfcrypt.ciphers.EccPrivate.sign">
<code class="descname">sign</code><span class="sig-paren">(</span><em>plaintext</em>, <em>rng=&lt;wolfcrypt.random.Random object&gt;</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/wolfcrypt/ciphers.html#EccPrivate.sign"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#wolfcrypt.ciphers.EccPrivate.sign" title="Permalink to this definition"></a></dt>
<dd><p>Signs <strong>plaintext</strong>, using the private key data in the object.</p>
<p>Returns the signature.</p>
</dd></dl>
<dl class="method">
<dt id="wolfcrypt.ciphers.EccPrivate.verify">
<code class="descname">verify</code><span class="sig-paren">(</span><em>signature</em>, <em>data</em><span class="sig-paren">)</span><a class="headerlink" href="#wolfcrypt.ciphers.EccPrivate.verify" title="Permalink to this definition"></a></dt>
<dd><p>Verifies <strong>signature</strong>, using the public key data in the object.</p>
<p>Returns <strong>True</strong> in case of a valid signature, otherwise <strong>False</strong>.</p>
</dd></dl>
</dd></dl>
</div>
</div>
@ -341,7 +439,7 @@ The plaintext’s length must not be greater than:</p>
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT:'./',
VERSION:'3.13.0-1',
VERSION:'3.14.0-1',
COLLAPSE_INDEX:false,
FILE_SUFFIX:'.html',
HAS_SOURCE: true,

10
digest.html
View File

@ -8,7 +8,7 @@
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Message Digests &mdash; wolfcrypt Python 3.13.0-1 documentation</title>
<title>Message Digests &mdash; wolfcrypt Python 3.14.0-1 documentation</title>
@ -35,7 +35,7 @@
<link rel="index" title="Index"
href="genindex.html"/>
<link rel="search" title="Search" href="search.html"/>
<link rel="top" title="wolfcrypt Python 3.13.0-1 documentation" href="index.html"/>
<link rel="top" title="wolfcrypt Python 3.14.0-1 documentation" href="index.html"/>
<link rel="next" title="Message Authentication Codes" href="mac.html"/>
<link rel="prev" title="Asymmetric Key Algorithms" href="asymmetric.html"/>
@ -66,7 +66,7 @@
<div class="version">
3.13.0-1
3.14.0-1
</div>
@ -276,7 +276,7 @@ are strongly suggested to use SHA-2 over SHA-1.</p>
</div>
<div class="section" id="example">
<h2>Example<a class="headerlink" href="#example" title="Permalink to this headline"></a></h2>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">wolfcrypt.hashes</span> <span class="k">import</span> <span class="n">Sha256</span>
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">wolfcrypt.hashes</span> <span class="kn">import</span> <span class="n">Sha256</span>
<span class="go">&gt;&gt;&gt;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">s</span> <span class="o">=</span> <span class="n">Sha256</span><span class="p">()</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">s</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="sa">b</span><span class="s1">&#39;wolf&#39;</span><span class="p">)</span>
@ -344,7 +344,7 @@ are strongly suggested to use SHA-2 over SHA-1.</p>
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT:'./',
VERSION:'3.13.0-1',
VERSION:'3.14.0-1',
COLLAPSE_INDEX:false,
FILE_SUFFIX:'.html',
HAS_SOURCE: true,

72
genindex.html
View File

@ -9,7 +9,7 @@
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Index &mdash; wolfcrypt Python 3.13.0-1 documentation</title>
<title>Index &mdash; wolfcrypt Python 3.14.0-1 documentation</title>
@ -36,7 +36,7 @@
<link rel="index" title="Index"
href="#"/>
<link rel="search" title="Search" href="search.html"/>
<link rel="top" title="wolfcrypt Python 3.13.0-1 documentation" href="index.html"/>
<link rel="top" title="wolfcrypt Python 3.14.0-1 documentation" href="index.html"/>
<script src="_static/js/modernizr.min.js"></script>
@ -65,7 +65,7 @@
<div class="version">
3.13.0-1
3.14.0-1
</div>
@ -167,6 +167,8 @@
| <a href="#D"><strong>D</strong></a>
| <a href="#E"><strong>E</strong></a>
| <a href="#H"><strong>H</strong></a>
| <a href="#I"><strong>I</strong></a>
| <a href="#M"><strong>M</strong></a>
| <a href="#N"><strong>N</strong></a>
| <a href="#R"><strong>R</strong></a>
| <a href="#S"><strong>S</strong></a>
@ -224,6 +226,12 @@
<h2 id="D">D</h2>
<table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="asymmetric.html#wolfcrypt.ciphers.EccPrivate.decode_key">decode_key() (wolfcrypt.ciphers.EccPrivate method)</a>
<ul>
<li><a href="asymmetric.html#wolfcrypt.ciphers.EccPublic.decode_key">(wolfcrypt.ciphers.EccPublic method)</a>
</li>
</ul></li>
<li><a href="symmetric.html#wolfcrypt.ciphers._Cipher.decrypt">decrypt() (wolfcrypt.ciphers._Cipher method)</a>
<ul>
@ -245,6 +253,18 @@
<h2 id="E">E</h2>
<table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="asymmetric.html#wolfcrypt.ciphers.EccPrivate">EccPrivate (class in wolfcrypt.ciphers)</a>
</li>
<li><a href="asymmetric.html#wolfcrypt.ciphers.EccPublic">EccPublic (class in wolfcrypt.ciphers)</a>
</li>
<li><a href="asymmetric.html#wolfcrypt.ciphers.EccPrivate.encode_key">encode_key() (wolfcrypt.ciphers.EccPrivate method)</a>
<ul>
<li><a href="asymmetric.html#wolfcrypt.ciphers.EccPublic.encode_key">(wolfcrypt.ciphers.EccPublic method)</a>
</li>
</ul></li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="symmetric.html#wolfcrypt.ciphers._Cipher.encrypt">encrypt() (wolfcrypt.ciphers._Cipher method)</a>
@ -252,6 +272,12 @@
<li><a href="asymmetric.html#wolfcrypt.ciphers.RsaPrivate.encrypt">(wolfcrypt.ciphers.RsaPrivate method)</a>
</li>
<li><a href="asymmetric.html#wolfcrypt.ciphers.RsaPublic.encrypt">(wolfcrypt.ciphers.RsaPublic method)</a>
</li>
</ul></li>
<li><a href="asymmetric.html#wolfcrypt.ciphers.EccPrivate.export_x963">export_x963() (wolfcrypt.ciphers.EccPrivate method)</a>
<ul>
<li><a href="asymmetric.html#wolfcrypt.ciphers.EccPublic.export_x963">(wolfcrypt.ciphers.EccPublic method)</a>
</li>
</ul></li>
</ul></td>
@ -279,6 +305,26 @@
</ul></td>
</tr></table>
<h2 id="I">I</h2>
<table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="asymmetric.html#wolfcrypt.ciphers.EccPrivate.import_x963">import_x963() (wolfcrypt.ciphers.EccPrivate method)</a>
<ul>
<li><a href="asymmetric.html#wolfcrypt.ciphers.EccPublic.import_x963">(wolfcrypt.ciphers.EccPublic method)</a>
</li>
</ul></li>
</ul></td>
</tr></table>
<h2 id="M">M</h2>
<table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="asymmetric.html#wolfcrypt.ciphers.EccPrivate.make_key">make_key() (wolfcrypt.ciphers.EccPrivate class method)</a>
</li>
</ul></td>
</tr></table>
<h2 id="N">N</h2>
<table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul>
@ -314,14 +360,20 @@
</li>
<li><a href="digest.html#wolfcrypt.hashes.Sha256">Sha256 (class in wolfcrypt.hashes)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="digest.html#wolfcrypt.hashes.Sha384">Sha384 (class in wolfcrypt.hashes)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="digest.html#wolfcrypt.hashes.Sha512">Sha512 (class in wolfcrypt.hashes)</a>
</li>
<li><a href="asymmetric.html#wolfcrypt.ciphers.RsaPrivate.sign">sign() (wolfcrypt.ciphers.RsaPrivate method)</a>
<li><a href="asymmetric.html#wolfcrypt.ciphers.EccPrivate.shared_secret">shared_secret() (wolfcrypt.ciphers.EccPrivate method)</a>
</li>
<li><a href="asymmetric.html#wolfcrypt.ciphers.EccPrivate.sign">sign() (wolfcrypt.ciphers.EccPrivate method)</a>
<ul>
<li><a href="asymmetric.html#wolfcrypt.ciphers.RsaPrivate.sign">(wolfcrypt.ciphers.RsaPrivate method)</a>
</li>
</ul></li>
</ul></td>
</tr></table>
@ -340,9 +392,13 @@
<h2 id="V">V</h2>
<table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="asymmetric.html#wolfcrypt.ciphers.RsaPrivate.verify">verify() (wolfcrypt.ciphers.RsaPrivate method)</a>
<li><a href="asymmetric.html#wolfcrypt.ciphers.EccPrivate.verify">verify() (wolfcrypt.ciphers.EccPrivate method)</a>
<ul>
<li><a href="asymmetric.html#wolfcrypt.ciphers.EccPublic.verify">(wolfcrypt.ciphers.EccPublic method)</a>
</li>
<li><a href="asymmetric.html#wolfcrypt.ciphers.RsaPrivate.verify">(wolfcrypt.ciphers.RsaPrivate method)</a>
</li>
<li><a href="asymmetric.html#wolfcrypt.ciphers.RsaPublic.verify">(wolfcrypt.ciphers.RsaPublic method)</a>
</li>
</ul></li>
@ -399,7 +455,7 @@
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT:'./',
VERSION:'3.13.0-1',
VERSION:'3.14.0-1',
COLLAPSE_INDEX:false,
FILE_SUFFIX:'.html',
HAS_SOURCE: true,

14
index.html
View File

@ -8,7 +8,7 @@
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>wolfcrypt: the wolfSSL Crypto Engine &mdash; wolfcrypt Python 3.13.0-1 documentation</title>
<title>wolfcrypt: the wolfSSL Crypto Engine &mdash; wolfcrypt Python 3.14.0-1 documentation</title>
@ -35,7 +35,7 @@
<link rel="index" title="Index"
href="genindex.html"/>
<link rel="search" title="Search" href="search.html"/>
<link rel="top" title="wolfcrypt Python 3.13.0-1 documentation" href="#"/>
<link rel="top" title="wolfcrypt Python 3.14.0-1 documentation" href="#"/>
<link rel="next" title="Symmetric Key Algorithms" href="symmetric.html"/>
@ -65,7 +65,7 @@
<div class="version">
3.13.0-1
3.14.0-1
</div>
@ -161,7 +161,7 @@
<div class="section" id="wolfcrypt-the-wolfssl-crypto-engine">
<h1>wolfcrypt: the wolfSSL Crypto Engine<a class="headerlink" href="#wolfcrypt-the-wolfssl-crypto-engine" title="Permalink to this headline"></a></h1>
<a class="reference external image-reference" href="https://travis-ci.org/wolfSSL/wolfcrypt-py"><img alt="https://travis-ci.org/wolfSSL/wolfcrypt-py.svg?branch=master" src="https://travis-ci.org/wolfSSL/wolfcrypt-py.svg?branch=master" /></a>
<p><strong>wolfCrypt Python</strong>, a.k.a. <code class="docutils literal"><span class="pre">wolfcrypt</span></code> is a Python module that encapsulates
<p><strong>wolfCrypt Python</strong>, a.k.a. <code class="docutils literal notranslate"><span class="pre">wolfcrypt</span></code> is a Python module that encapsulates
<strong>wolfSSL’s wolfCrypt API</strong>.</p>
<p><a class="reference external" href="https://wolfssl.com/wolfSSL/Products-wolfcrypt.html">wolfCrypt</a> is a
lightweight, portable, C-language-based crypto library
@ -172,13 +172,13 @@ library</a>.</p>
<div class="section" id="installation">
<h2>Installation<a class="headerlink" href="#installation" title="Permalink to this headline"></a></h2>
<p>We provide Python wheels (prebuilt binaries) for OSX 64 bits and Linux 64 bits:</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>$ pip install wolfcrypt
<div class="highlight-bash notranslate"><div class="highlight"><pre><span></span>$ pip install wolfcrypt
</pre></div>
</div>
</div>
<div class="section" id="testing">
<h2>Testing<a class="headerlink" href="#testing" title="Permalink to this headline"></a></h2>
<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">wolfcrypt.hashes</span> <span class="kn">import</span> <span class="n">Sha256</span>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">wolfcrypt.hashes</span> <span class="kn">import</span> <span class="n">Sha256</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">Sha256</span><span class="p">(</span><span class="s1">&#39;wolfcrypt&#39;</span><span class="p">)</span><span class="o">.</span><span class="n">hexdigest</span><span class="p">()</span>
<span class="go">b&#39;96e02e7b1cbcd6f104fe1fdb4652027a5505b68652b70095c6318f9dce0d1844&#39;</span>
</pre></div>
@ -260,7 +260,7 @@ licensing terms are also available at <a class="reference external" href="mailto
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT:'./',
VERSION:'3.13.0-1',
VERSION:'3.14.0-1',
COLLAPSE_INDEX:false,
FILE_SUFFIX:'.html',
HAS_SOURCE: true,

12
mac.html
View File

@ -8,7 +8,7 @@
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Message Authentication Codes &mdash; wolfcrypt Python 3.13.0-1 documentation</title>
<title>Message Authentication Codes &mdash; wolfcrypt Python 3.14.0-1 documentation</title>
@ -35,7 +35,7 @@
<link rel="index" title="Index"
href="genindex.html"/>
<link rel="search" title="Search" href="search.html"/>
<link rel="top" title="wolfcrypt Python 3.13.0-1 documentation" href="index.html"/>
<link rel="top" title="wolfcrypt Python 3.14.0-1 documentation" href="index.html"/>
<link rel="next" title="Random Number Generation" href="random.html"/>
<link rel="prev" title="Message Digests" href="digest.html"/>
@ -66,7 +66,7 @@
<div class="version">
3.13.0-1
3.14.0-1
</div>
@ -174,7 +174,7 @@
to authenticate a message — in other words, to confirm that the message came
from the stated sender (its authenticity) and has not been changed in transit
(its integrity).</p>
<p><code class="docutils literal"><span class="pre">wolfcrypt</span></code> implements the <strong>Hash-based message authentication code</strong> (HMAC),
<p><code class="docutils literal notranslate"><span class="pre">wolfcrypt</span></code> implements the <strong>Hash-based message authentication code</strong> (HMAC),
which uses a cryptographic hash function coupled with a secret key to produce
<strong>message authentication codes</strong>.</p>
<div class="section" id="hmac-classes">
@ -280,7 +280,7 @@ hash function.</p>
</div>
<div class="section" id="example">
<h2>Example<a class="headerlink" href="#example" title="Permalink to this headline"></a></h2>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">wolfcrypt.hashes</span> <span class="k">import</span> <span class="n">HmacSha256</span>
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">wolfcrypt.hashes</span> <span class="kn">import</span> <span class="n">HmacSha256</span>
<span class="go">&gt;&gt;&gt;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">h</span> <span class="o">=</span> <span class="n">HmacSha256</span><span class="p">(</span><span class="s1">&#39;secret&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">h</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="s2">&quot;wolf&quot;</span><span class="p">)</span>
@ -348,7 +348,7 @@ hash function.</p>
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT:'./',
VERSION:'3.13.0-1',
VERSION:'3.14.0-1',
COLLAPSE_INDEX:false,
FILE_SUFFIX:'.html',
HAS_SOURCE: true,

BIN
objects.inv
View File

Binary file not shown.

8
py-modindex.html
View File

@ -8,7 +8,7 @@
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Python Module Index &mdash; wolfcrypt Python 3.13.0-1 documentation</title>
<title>Python Module Index &mdash; wolfcrypt Python 3.14.0-1 documentation</title>
@ -35,7 +35,7 @@
<link rel="index" title="Index"
href="genindex.html"/>
<link rel="search" title="Search" href="search.html"/>
<link rel="top" title="wolfcrypt Python 3.13.0-1 documentation" href="index.html"/>
<link rel="top" title="wolfcrypt Python 3.14.0-1 documentation" href="index.html"/>
@ -67,7 +67,7 @@
<div class="version">
3.13.0-1
3.14.0-1
</div>
@ -227,7 +227,7 @@
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT:'./',
VERSION:'3.13.0-1',
VERSION:'3.14.0-1',
COLLAPSE_INDEX:false,
FILE_SUFFIX:'.html',
HAS_SOURCE: true,

12
random.html
View File

@ -8,7 +8,7 @@
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Random Number Generation &mdash; wolfcrypt Python 3.13.0-1 documentation</title>
<title>Random Number Generation &mdash; wolfcrypt Python 3.14.0-1 documentation</title>
@ -35,7 +35,7 @@
<link rel="index" title="Index"
href="genindex.html"/>
<link rel="search" title="Search" href="search.html"/>
<link rel="top" title="wolfcrypt Python 3.13.0-1 documentation" href="index.html"/>
<link rel="top" title="wolfcrypt Python 3.14.0-1 documentation" href="index.html"/>
<link rel="prev" title="Message Authentication Codes" href="mac.html"/>
@ -65,7 +65,7 @@
<div class="version">
3.13.0-1
3.14.0-1
</div>
@ -168,7 +168,7 @@
for use in cryptography.</p>
<p>Using the standard random module APIs for cryptographic keys or initialization
vectors can result in major security issues depending on the algorithms in use.</p>
<p><code class="docutils literal"><span class="pre">wolfcrypt</span></code> provides the following CSPRNG implementation:</p>
<p><code class="docutils literal notranslate"><span class="pre">wolfcrypt</span></code> provides the following CSPRNG implementation:</p>
<span class="target" id="module-wolfcrypt.random"></span><dl class="class">
<dt id="wolfcrypt.random.Random">
<em class="property">class </em><code class="descclassname">wolfcrypt.random.</code><code class="descname">Random</code><a class="reference internal" href="_modules/wolfcrypt/random.html#Random"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#wolfcrypt.random.Random" title="Permalink to this definition"></a></dt>
@ -189,7 +189,7 @@ vectors can result in major security issues depending on the algorithms in use.<
<div class="section" id="example">
<h2>Example<a class="headerlink" href="#example" title="Permalink to this headline"></a></h2>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">wolfcrypt.random</span> <span class="k">import</span> <span class="n">Random</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">wolfcrypt.random</span> <span class="k">import</span> <span class="n">Random</span>
<span class="go">&gt;&gt;&gt;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">r</span> <span class="o">=</span> <span class="n">Random</span><span class="p">()</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">r</span><span class="o">.</span><span class="n">byte</span><span class="p">()</span>
@ -245,7 +245,7 @@ vectors can result in major security issues depending on the algorithms in use.<
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT:'./',
VERSION:'3.13.0-1',
VERSION:'3.14.0-1',
COLLAPSE_INDEX:false,
FILE_SUFFIX:'.html',
HAS_SOURCE: true,

8
search.html
View File

@ -8,7 +8,7 @@
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Search &mdash; wolfcrypt Python 3.13.0-1 documentation</title>
<title>Search &mdash; wolfcrypt Python 3.14.0-1 documentation</title>
@ -35,7 +35,7 @@
<link rel="index" title="Index"
href="genindex.html"/>
<link rel="search" title="Search" href="#"/>
<link rel="top" title="wolfcrypt Python 3.13.0-1 documentation" href="index.html"/>
<link rel="top" title="wolfcrypt Python 3.14.0-1 documentation" href="index.html"/>
<script src="_static/js/modernizr.min.js"></script>
@ -64,7 +64,7 @@
<div class="version">
3.13.0-1
3.14.0-1
</div>
@ -201,7 +201,7 @@
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT:'./',
VERSION:'3.13.0-1',
VERSION:'3.14.0-1',
COLLAPSE_INDEX:false,
FILE_SUFFIX:'.html',
HAS_SOURCE: true,

2
searchindex.js
View File

File diff suppressed because one or more lines are too long

61
symmetric.html
View File

@ -8,7 +8,7 @@
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Symmetric Key Algorithms &mdash; wolfcrypt Python 3.13.0-1 documentation</title>
<title>Symmetric Key Algorithms &mdash; wolfcrypt Python 3.14.0-1 documentation</title>
@ -35,7 +35,7 @@
<link rel="index" title="Index"
href="genindex.html"/>
<link rel="search" title="Search" href="search.html"/>
<link rel="top" title="wolfcrypt Python 3.13.0-1 documentation" href="index.html"/>
<link rel="top" title="wolfcrypt Python 3.14.0-1 documentation" href="index.html"/>
<link rel="next" title="Asymmetric Key Algorithms" href="asymmetric.html"/>
<link rel="prev" title="wolfcrypt: the wolfSSL Crypto Engine" href="index.html"/>
@ -66,7 +66,7 @@
<div class="version">
3.13.0-1
3.14.0-1
</div>
@ -94,10 +94,10 @@
<li class="toctree-l1 current"><a class="current reference internal" href="#">Symmetric Key Algorithms</a><ul>
<li class="toctree-l2"><a class="reference internal" href="#symmetric-key-encryption-classes">Symmetric Key Encryption Classes</a><ul>
<li class="toctree-l3"><a class="reference internal" href="#interface">Interface</a></li>
<li class="toctree-l3"><a class="reference internal" href="#classes">Classes</a></li>
<li class="toctree-l3"><a class="reference internal" href="#aes">AES</a></li>
<li class="toctree-l3"><a class="reference internal" href="#triple-des">Triple DES</a></li>
</ul>
</li>
<li class="toctree-l2"><a class="reference internal" href="#example">Example</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="asymmetric.html">Asymmetric Key Algorithms</a></li>
@ -170,9 +170,8 @@
<div class="section" id="module-wolfcrypt.ciphers">
<span id="symmetric-key-algorithms"></span><h1>Symmetric Key Algorithms<a class="headerlink" href="#module-wolfcrypt.ciphers" title="Permalink to this headline"></a></h1>
<p><strong>Symmetric key algorithms</strong> are encryption algorithms that use the <strong>same
cryptographic keys</strong> for both encryption and decryption of data.
cryptographic key</strong> for both encryption and decryption of data.
This operation is also known as <strong>Symmetric Key Encryption</strong>.</p>
<p><code class="docutils literal"><span class="pre">wolfcrypt</span></code> provides access to the following <strong>Symmetric Key Ciphers</strong>:</p>
<div class="section" id="symmetric-key-encryption-classes">
<h2>Symmetric Key Encryption Classes<a class="headerlink" href="#symmetric-key-encryption-classes" title="Permalink to this headline"></a></h2>
<div class="section" id="interface">
@ -200,27 +199,27 @@ being raised.</p>
<dt id="wolfcrypt.ciphers._Cipher.encrypt">
<code class="descname">encrypt</code><span class="sig-paren">(</span><em>string</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/wolfcrypt/ciphers.html#_Cipher.encrypt"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#wolfcrypt.ciphers._Cipher.encrypt" title="Permalink to this definition"></a></dt>
<dd><p>Encrypts a non-empty string, using the key-dependent data in
the object, and with the appropriate feedback mode. The
string’s length must be an exact multiple of the algorithm’s
block size or, in CFB mode, of the segment size. Returns a
string containing the ciphertext.</p>
the object, and with the appropriate feedback mode.</p>
<p>The string’s length must be an exact multiple of the algorithm’s
block size or, in CFB mode, of the segment size.</p>
<p>Returns a string containing the ciphertext.</p>
</dd></dl>
<dl class="method">
<dt id="wolfcrypt.ciphers._Cipher.decrypt">
<code class="descname">decrypt</code><span class="sig-paren">(</span><em>string</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/wolfcrypt/ciphers.html#_Cipher.decrypt"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#wolfcrypt.ciphers._Cipher.decrypt" title="Permalink to this definition"></a></dt>
<dd><p>Decrypts <strong>string</strong>, using the key-dependent data in the
object and with the appropriate feedback mode. The string’s
length must be an exact multiple of the algorithm’s block
size or, in CFB mode, of the segment size. Returns a string
containing the plaintext.</p>
object and with the appropriate feedback mode.</p>
<p>The string’s length must be an exact multiple of the algorithm’s
block size or, in CFB mode, of the segment size.</p>
<p>Returns a string containing the plaintext.</p>
</dd></dl>
</dd></dl>
</div>
<div class="section" id="classes">
<h3>Classes<a class="headerlink" href="#classes" title="Permalink to this headline"></a></h3>
<div class="section" id="aes">
<h3>AES<a class="headerlink" href="#aes" title="Permalink to this headline"></a></h3>
<dl class="class">
<dt id="wolfcrypt.ciphers.Aes">
<em class="property">class </em><code class="descclassname">wolfcrypt.ciphers.</code><code class="descname">Aes</code><span class="sig-paren">(</span><em>key</em>, <em>mode</em>, <em>IV=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/wolfcrypt/ciphers.html#Aes"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#wolfcrypt.ciphers.Aes" title="Permalink to this definition"></a></dt>
@ -228,6 +227,20 @@ containing the plaintext.</p>
a symmetric-key cipher standardized by <strong>NIST</strong>.</p>
</dd></dl>
<p><strong>Example:</strong></p>
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">wolfcrypt.ciphers</span> <span class="kn">import</span> <span class="n">Aes</span><span class="p">,</span> <span class="n">MODE_CBC</span>
<span class="go">&gt;&gt;&gt;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">cipher</span> <span class="o">=</span> <span class="n">Aes</span><span class="p">(</span><span class="sa">b</span><span class="s1">&#39;0123456789abcdef&#39;</span><span class="p">,</span> <span class="n">MODE_CBC</span><span class="p">,</span> <span class="sa">b</span><span class="s1">&#39;1234567890abcdef&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">ciphertext</span> <span class="o">=</span> <span class="n">cipher</span><span class="o">.</span><span class="n">encrypt</span><span class="p">(</span><span class="s1">&#39;now is the time &#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">ciphertext</span>
<span class="go">b&#39;\x95\x94\x92W_B\x81S,\xcc\x9dFw\xa23\xcb&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">cipher</span><span class="o">.</span><span class="n">decrypt</span><span class="p">(</span><span class="n">ciphertext</span><span class="p">)</span>
<span class="go">b&#39;now is the time &#39;</span>
</pre></div>
</div>
</div>
<div class="section" id="triple-des">
<h3>Triple DES<a class="headerlink" href="#triple-des" title="Permalink to this headline"></a></h3>
<dl class="class">
<dt id="wolfcrypt.ciphers.Des3">
<em class="property">class </em><code class="descclassname">wolfcrypt.ciphers.</code><code class="descname">Des3</code><span class="sig-paren">(</span><em>key</em>, <em>mode</em>, <em>IV=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/wolfcrypt/ciphers.html#Des3"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#wolfcrypt.ciphers.Des3" title="Permalink to this definition"></a></dt>
@ -237,21 +250,19 @@ cipher, which applies the <strong>Data Encryption Standard</strong> (DES)
cipher algorithm three times to each data block.</p>
</dd></dl>
</div>
</div>
<div class="section" id="example">
<h2>Example<a class="headerlink" href="#example" title="Permalink to this headline"></a></h2>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">wolfcrypt.ciphers</span> <span class="k">import</span> <span class="n">Aes</span><span class="p">,</span> <span class="n">MODE_CBC</span>
<p><strong>Example:</strong></p>
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">wolfcrypt.ciphers</span> <span class="kn">import</span> <span class="n">Des3</span><span class="p">,</span> <span class="n">MODE_CBC</span>
<span class="go">&gt;&gt;&gt;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">cipher</span> <span class="o">=</span> <span class="n">Aes</span><span class="p">(</span><span class="sa">b</span><span class="s1">&#39;0123456789abcdef&#39;</span><span class="p">,</span> <span class="n">MODE_CBC</span><span class="p">,</span> <span class="sa">b</span><span class="s1">&#39;1234567890abcdef&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">cipher</span> <span class="o">=</span> <span class="n">Des3</span><span class="p">(</span><span class="sa">b</span><span class="s1">&#39;0123456789abcdeffedeba98&#39;</span><span class="p">,</span> <span class="n">MODE_CBC</span><span class="p">,</span> <span class="sa">b</span><span class="s1">&#39;12345678&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">ciphertext</span> <span class="o">=</span> <span class="n">cipher</span><span class="o">.</span><span class="n">encrypt</span><span class="p">(</span><span class="s1">&#39;now is the time &#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">ciphertext</span>
<span class="go">b&#39;\x95\x94\x92W_B\x81S,\xcc\x9dFw\xa23\xcb&#39;</span>
<span class="go">b&#39;l\x04\xd0$\xe8\x0c1\xd6\x1b\x07}V\xa6ty\xe8&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">cipher</span><span class="o">.</span><span class="n">decrypt</span><span class="p">(</span><span class="n">ciphertext</span><span class="p">)</span>
<span class="go">b&#39;now is the time &#39;</span>
</pre></div>
</div>
</div>
</div>
</div>
@ -298,7 +309,7 @@ cipher algorithm three times to each data block.</p>
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT:'./',
VERSION:'3.13.0-1',
VERSION:'3.14.0-1',
COLLAPSE_INDEX:false,
FILE_SUFFIX:'.html',
HAS_SOURCE: true,