use v6;
use NativeCall;
use Crypt::TweetNacl::Constants;
use Crypt::TweetNacl::Basics;

unit module Crypt::TweetNacl::PublicKey;



head

Crypt::TweetNacl::PublicKey - public key crypto library


# create keys
my $alice = KeyPair.new;
my $bob = KeyPair.new;


# create Buf to encrypt
my $msg = 'Hello World'.encode('UTF-8');


# encrypt
my $cb = CryptoBox.new(pk => $alice.public , sk => $bob.secret);
my $data = $cb.encrypt($msg);


# decrypt
my $cbo = CryptoBoxOpen.new(pk => $bob.public , sk => $alice.secret);
my $rmsg = $cbo.decrypt($data);
say $rmsg.decode('UTF-8')


class KeyPair creates a public/secret keypair. And stores them in
attributes public and secret.


class ciphertext consists of two attributes: data and a nonce.


The constructor accepts:
- CArray with 16 leading zeros, removes them and stores them into the attribute data.
- And a 24Byte nonce.


The data without leading zeros can be accessed with the .data accessor.
The data with leading zeros can be accessed with the .zdata accessor.


The idea is to transport data(no leading zeros) and nonce to the
receiver combine them into a new ciphertext and decrypt into the
plaintext message. Somehow this is still missing...


class CryptoBox encrypts for a public key


The constructor accepts:
 - the public key of the receiver
 - the secret key of the sender


method encrypt accepts a Buf and returns class ciphertext


class CryptoBoxOpen decrypts for and verifies the sender
The constructor accepts:
 - the secret key of the receiver
 - the public key of the sender


method decrypt accepts a ciphertext and returns a Buf


In case problems arise this is reported by an exception.


panda --installed list
- Linenoise        [installed]
- TweetNacl        [installed]
- panda            [installed]


Various other(not documented) classes and methods might be exported
by the library. Please ignore them.


- https://nacl.cr.yp.to/box.html
- https://tweetnacl.cr.yp.to/tweetnacl-20131229.pdf


v0.0.1 initial version offered at #perl6





DOC INIT {
        use Pod::To::Text;
        pod2text($


# https://nacl.cr.yp.to/box.html
# int crypto_box_keypair(u8 *y,u8 *x);

sub crypto_box_keypair_int(CArray[uint8], CArray[uint8]) is symbol('crypto_box_keypair') is native(TWEETNACL) returns int { * }

class KeyPair is export
{
    has $.secret;
    has $.public;
    submethod BUILD()
    {
        $!secret := CArray[uint8].new;
        $!public := CArray[uint8].new;
        $!secret[CRYPTO_BOX_SECRETKEYBYTES - 1] = 0; # extend the array to 32 items
        $!public[CRYPTO_BOX_PUBLICKEYBYTES - 1] = 0; # extend the array to 32 items
        my $ret = crypto_box_keypair_int($!public,$!secret);
        if ($ret != 0) {
            die "crypto_box_keypair_int, bad return code: $ret";
        }
    }
}
#https://nacl.cr.yp.to/box.html

# void randombytes(unsigned char *x,unsigned long long xlen)



#      unsigned char k[crypto_box_BEFORENMBYTES];
#      const unsigned char pk[crypto_box_PUBLICKEYBYTES];
#      const unsigned char sk[crypto_box_SECRETKEYBYTES];

#      crypto_box_beforenm(k,pk,sk);#int crypto_box_beforenm(u8 *k,const u8 *y,const u8 *x);

sub crypto_box_beforenm_int (CArray[uint8], CArray[uint8], CArray[uint8]) is symbol('crypto_box_beforenm') is native(TWEETNACL) is export returns int32 { * };

# const unsigned char k[crypto_box_BEFORENMBYTES];
# const unsigned char n[crypto_box_NONCEBYTES];
# const unsigned char c[...]; unsigned long long clen;
# unsigned char m[...];

# crypto_box_open_afternm(m,c,clen,n,k);

sub crypto_box_afternm_int (CArray[uint8], CArray[uint8], ulonglong, CArray[uint8], CArray[uint8]) is symbol('crypto_box_afternm') is native(TWEETNACL) is export returns int32 { * };


class CryptoBox is export
{
    has $!key;
    submethod BUILD(CArray :$pk!, CArray :$sk!)
    {
        $!key := CArray[uint8].new;
        $!key[CRYPTO_BOX_BEFORENMBYTES - 1] = 0; # extend the array to 32 items
        my $ret = crypto_box_beforenm_int($!key, $pk, $sk);
        if ($ret != 0) {
            die "crypto_box_beforenm_int, bad return code: $ret";
        }
    }

    multi method encrypt(Blob $buf!, CArray $nonce!)
    {
        my ulonglong $mlen = CRYPTO_BOX_ZEROBYTES + $buf.elems;
        my $data = CArray[uint8].new;
        $data[$mlen - 1] = 0;   #alloc
        my $msg  = prepend_zeros($buf, CRYPTO_BOX_ZEROBYTES);
        my $ret = crypto_box_afternm_int($data, $msg, $mlen, $nonce, $!key);
        if ($ret != 0) {
            die "crypto_box, bad return code: $ret";
        }
        return $data;
    }

    multi method encrypt(Blob $buf!)
    {
        my $nonce = nonce();
        my $data  = self.encrypt($buf, $nonce);
        my $ciph  = Ciphertext.new(zdata => $data, nonce => $nonce);
        return $ciph;
    }
}



# The crypto_box_open_afternm function is callable as follows:

#    #include "crypto_box.h"

#    const unsigned char k[crypto_box_BEFORENMBYTES];
#    const unsigned char n[crypto_box_NONCEBYTES];
#    const unsigned char c[...]; unsigned long long clen;
#    unsigned char m[...];

#    crypto_box_open_afternm(m,c,clen,n,k)

sub crypto_box_open_afternm_int(CArray[uint8], CArray[uint8], ulonglong, CArray[uint8], CArray[uint8]) is symbol('crypto_box_open_afternm') is native(TWEETNACL) is export returns int32 { * }

class CryptoBoxOpen is export
{
    has $!key;
    submethod BUILD(CArray :$pk!, CArray :$sk!)
    {
        $!key := CArray[uint8].new;
        $!key[CRYPTO_BOX_BEFORENMBYTES - 1] = 0; # extend the array to 32 items
        my $ret = crypto_box_beforenm_int($!key, $pk, $sk);
        if ($ret != 0) {
            die "crypto_box_beforenm_int, bad return code: $ret";
        }
    }
    multi method decrypt(CArray $c!, CArray $nonce!)
    {
        my $msg  = CArray[uint8].new;
        my $clen = $c.elems;
        $msg[$clen - 1] = 0;    #alloc
        my $i;
        loop ($i=0; $i < CRYPTO_BOX_BOXZEROBYTES ; $i++)
        {
            if ($c[$i] != 0) {
                die "crypto_box_open, bad ciphertext";
            }
        }
        my $ret = crypto_box_open_afternm_int($msg, $c, $clen, $nonce, $!key);
        if ($ret != 0) {
            die "crypto_box_open_afternm_int, bad return code: $ret";

        }
        return remove_leading_elems(Buf, $msg, CRYPTO_BOX_ZEROBYTES);
    }

    multi method decrypt(Ciphertext $ciph!)
    {
        return self.decrypt($ciph.zdata, $ciph.nonce);
    }
}


# ----------------------------------------------------------------------
# internal subroutines for test, do not use
# ----------------------------------------------------------------------


# const unsigned char pk[crypto_box_PUBLICKEYBYTES];
#     const unsigned char sk[crypto_box_SECRETKEYBYTES];
#     const unsigned char n[crypto_box_NONCEBYTES];
#     const unsigned char m[...]; unsigned long long mlen;
#     unsigned char c[...];
#
#     crypto_box(c,m,mlen,n,pk,sk);

sub crypto_box_int (CArray[uint8], CArray[uint8], ulonglong, CArray[uint8], CArray[uint8], CArray[uint8]) is symbol('crypto_box') is native(TWEETNACL) is export returns int32 { * };

sub crypto_box (Blob $buf!, CArray $nonce!, CArray $pk!, CArray $sk!) is export
{
    my ulonglong $mlen = CRYPTO_BOX_ZEROBYTES + $buf.elems;
    my $data = CArray[uint8].new;
    $data[$mlen - 1] = 0;       #alloc
    my $msg  = prepend_zeros($buf, CRYPTO_BOX_ZEROBYTES);
    my $ret = crypto_box_int($data, $msg, $mlen, $nonce, $pk, $sk);
    if ($ret != 0) {
        die "crypto_box, bad return code: $ret";
    }
    return $data;
}

#     const unsigned char pk[crypto_box_PUBLICKEYBYTES];
#     const unsigned char sk[crypto_box_SECRETKEYBYTES];
#     const unsigned char n[crypto_box_NONCEBYTES];
#     const unsigned char c[...]; unsigned long long clen;
#     unsigned char m[...];
#     crypto_box_open(m,c,clen,n,pk,sk);

sub crypto_box_open_int(CArray[uint8], CArray[uint8], ulonglong, CArray[uint8], CArray[uint8], CArray[uint8]) is symbol('crypto_box_open') is native(TWEETNACL) is export returns int32 { * }


sub crypto_box_open(CArray $c!, CArray $nonce!, CArray $pk!, CArray $sk!) is export
{
    my $msg  = CArray[uint8].new;
    my $clen = $c.elems;
    $msg[$clen - 1] = 0;        #alloc
    my $i;
    loop ($i=0; $i < CRYPTO_BOX_BOXZEROBYTES ; $i++)
    {
        if ($c[$i] != 0) {
            die "crypto_box_open, bad ciphertext";
        }
    }
    my $ret = crypto_box_open_int($msg, $c, $clen, $nonce, $pk, $sk);
    if ($ret != 0) {
        die "crypto_box_open, bad return code: $ret";

    }
    return remove_leading_elems(Buf, $msg, CRYPTO_BOX_ZEROBYTES);
}


root

SecretKey

README

React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


PublicKey

NAME

SYNOPSIS

DESCRIPTION

key generation

ciphertext handling

encryption

decryption

OPTIONS

RETURN VALUE

ERRORS

DIAGNOSTICS

EXAMPLES

ENVIRONMENT

FILES

CAVEATS

BUGS

RESTRICTIONS

NOTES

SEE ALSO

AUTHOR

HISTORY