# SealedBox reference vectors

Since libsodium’s tests do not provide reference data for the SealedBox construction, the implementation is verified with a `sealbox_test_vectors` utility program that produces and checks custom test vectors by making specific calls to libsodium API.

To build the `sealbox_test_vectors` you need a `C` language compiler, a prebuilt libsodium library more recent than version 1.0.3 and the corresponding include headers.

In a UNIX-like programming environment you should then execute:

    $ cc -o sealbox_test_vectors sealbox_test_vectors.c -lsodium -lc

If you prefer using a locally compiled installation of the bundled sources, refer to Building the bundled library and then run:

    $ cc -o sealbox_test_vectors sealbox_test_vectors.c \
      ${SODIUMINCL} ${SODIUMLIB} -lsodium -lc

## Vector generation

When called with one or more command line arguments, `sealbox_test_vectors` will generate the number of hex-encoded vectors requested as first argument, with the optional second and third arguments influencing the length of the randomly generated messages:

    $ ./sealbox_test_vectors 1
    XXXX...        XXXX...        <len>:XXXX...        <len>:XXXX...

The second argument, if present, sets both a minimum and a maximum length on generated messages, overriding the default 128 bytes values respectively with the supplied value and with twice the supplied value.

The third argument, if present, sets the maximum length of generated messages.

## Vector test

When called without command line arguments, `sealbox_test_vectors` will parse and hex-decode the lines given as standard input and check if decoding the encrypted message will return the original message. A “OK”/”FAIL” tag will be appended to the input line to signify success/failure of the test.

To check correct “round-trip” behavior, you can run `sealbox_test_vectors` as a test vector generator against itself:

    $ ./sealbox_test_vectors 1 | ./sealbox_test_vectors
    XXXX...     XXXX... <len>:XXXX...   <len>:XXXX...   OK

If you want to check the vectors distributed with PyNaCl’s sources, after setting the environment variable `PYNACL_BASE` to the directory where the unpacked source for PyNaCl has been extracted/cloned, you could run:

    $ ./sealbox_test_vectors < ${PYNACL_BASE}/tests/data/sealed_box_ref.txt
    77076d ... 8c86  OK

## Source code for the vector checker utility

The source code for `sealbox_test_vectors` is available inside the `docs/vectors/c-source` directory of PyNaCl distribution and can also be directly downloaded from `sealbox_test_vectors.c`.

sealbox_test_vectors.c

    /*
     * Copyright 2017 Donald Stufft and individual contributors
     *
     * Licensed under the Apache License, Version 2.0 (the "License");
     * you may not use this file except in compliance with the License.
     * You may obtain a copy of the License at
     *
     * http://www.apache.org/licenses/LICENSE-2.0
     *
     * Unless required by applicable law or agreed to in writing, software
     * distributed under the License is distributed on an "AS IS" BASIS,
     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     * See the License for the specific language governing permissions and
     * limitations under the License.
     *
     * Test vector generator/checker for libsodium's box_seal APIs
     * to build in a unix-like environment, use a command line like
     * $ cc sealbox_test_vectors.c -I${IPATH} -L${LPATH} -lsodium -o sealbox_test_vectors
     * with IPATH and LPATH defined to respectively point to libsodium's include path
     * and to the directory containing the link library libsodium.a or libsodium.o
     *
     */
    #include <stdio.h>
    #include <string.h>
    #include <sodium.h>

    int checkone (char *hxsecret, char *hxpub, size_t ptlen, char *hxplaintext,
    	      size_t crlen, char *hxencrypted) {

        int pklen = crypto_box_PUBLICKEYBYTES;
        int sklen = crypto_box_SECRETKEYBYTES;

        char *skr = sodium_malloc (sklen);
        char *pub = sodium_malloc (pklen);
        char *txt = sodium_malloc (ptlen);
        char *crpt = sodium_malloc (crlen);
        char *outp = sodium_malloc (ptlen);

        int rs = sodium_hex2bin (skr, sklen, hxsecret, 2 * sklen,
                                 NULL, NULL, NULL);
        rs |= sodium_hex2bin (pub, pklen, hxpub, 2 * pklen, NULL, NULL, NULL);
        rs |= sodium_hex2bin (txt, ptlen, hxplaintext, strlen (hxplaintext),
                              NULL, NULL, NULL);
        rs |= sodium_hex2bin (crpt, crlen, hxencrypted, strlen (hxencrypted),
                              NULL, NULL, NULL);

        if (rs == 0)
            rs = crypto_box_seal_open (outp, crpt, crlen, pub, skr);
        if (rs == 0)
            rs = sodium_memcmp (outp, txt, ptlen);

        sodium_free (crpt);
        sodium_free (txt);
        sodium_free (skr);
        sodium_free (pub);

        return rs;
    }

    void gentestline (int minmsglen, int maxmsglen) {

        int pklen = crypto_box_PUBLICKEYBYTES;
        int sklen = crypto_box_SECRETKEYBYTES;
        size_t txtlen = minmsglen + randombytes_uniform (maxmsglen - minmsglen + 1);
        size_t encrlen = txtlen + crypto_box_SEALBYTES;

        char *skr = sodium_malloc (sklen);
        char *pub = sodium_malloc (pklen);
        char *txt = sodium_malloc (txtlen);
        char *crpt = sodium_malloc (encrlen);

        crypto_box_keypair (pub, skr);
        randombytes_buf (txt, txtlen);

        crypto_box_seal (crpt, txt, txtlen, pub);

        char *hskr = sodium_malloc (sklen * 2 + 1);
        char *hpub = sodium_malloc (pklen * 2 + 1);
        char *htxt = sodium_malloc (txtlen * 2 + 1);
        char *hkrp = sodium_malloc (encrlen * 2 + 1);

        sodium_bin2hex (hskr, sklen * 2 + 1, skr, sklen);
        sodium_bin2hex (hpub, pklen * 2 + 1, pub, pklen);
        sodium_bin2hex (htxt, txtlen * 2 + 1, txt, txtlen);
        sodium_bin2hex (hkrp, encrlen * 2 + 1, crpt, encrlen);

        printf ("%s\t%s\t%zu:%s\t%zu:%s\n", hskr, hpub, txtlen, htxt, encrlen, hkrp);
    }

    int main (int argc, char **argv) {
    /*
     * If called without any argument, the resulting executable will
     * read and hex decode the secret and public part of the receiver key,
     * the original plaintext and the ciphertext, and then
     * check if the message resulting from decrypting ciphertext with
     * the secret key is equal to the given plaintext
     *
     * If called with a sequence of integer arguments, sealbox_test_vectors
     * will generate the requested number of reference lines, encrypting
     * random messages.
     *
     */
        if (sodium_init () == -1) {
            exit (1);
        }

        if (argc == 1) {
            size_t lsz = 0;
            char *line = NULL;
            ssize_t lln = 0;
            int res;
            char hxsecret[2 * crypto_box_SECRETKEYBYTES + 1];
            char hxpub[2 * crypto_box_PUBLICKEYBYTES + 1];
            char hxplaintext[2048 + 1];
            char hxencrypted[2048 + 2 * crypto_box_SEALBYTES + 1];
            char cmpplaintext[5 + 2048 + 1];
            char cmpencrypted[5 + 2048 + 2 * crypto_box_SEALBYTES + 1];
            size_t ptlen = 0;
            size_t crlen = 0;

            while (lln = getline (&line, &lsz, stdin) > 0) {
                if (lln > 0) {
                    if (strncmp (line, "#", 1) == 0 ||
                            strncmp (line, "\n", 1) == 0 ||
                            strncmp (line, "\r", 1) == 0)
                        continue;

                    sscanf (line, "%s%s%s%s",
                            hxsecret, hxpub, cmpplaintext, cmpencrypted);
                    sscanf (cmpplaintext, "%zu:%s",
                            &ptlen, hxplaintext);
                    sscanf (cmpencrypted, "%zu:%s",
                            &crlen, hxencrypted);
                    if (ptlen == 0)
                            memset(hxplaintext, 0, sizeof(hxplaintext));
                    if (crlen == 0)
                            memset(hxencrypted, 0, sizeof(hxencrypted));
                    res = checkone (hxsecret, hxpub, ptlen, hxplaintext, crlen, hxencrypted);
                    char *rsstr = (res == 0) ? "OK" : "FAIL";
                    printf ("%s\t%s\t%zu:%s\t%zu:%s\t%s\n",
                            hxsecret, hxpub, ptlen, hxplaintext, crlen, hxencrypted, rsstr);
                }
                free (line);
                line = NULL;
            }
        } else {
            int nlines = atoi (argv[1]);
            int minmsgl = 128;
            int maxmsgl = 128;
            if (argc == 3) {
                minmsgl = atoi (argv[2]);
                maxmsgl = atoi (argv[2]) * 2;
            } else if (argc == 4) {
                minmsgl = atoi (argv[2]);
                maxmsgl = atoi (argv[3]);
            }
            for (int i = 0; i < nlines; i++) {
                gentestline (minmsgl, maxmsgl);
            }
        }
    }