LCOV - code coverage report
Current view: top level - src/libavutil/tests - des.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 40 48 83.3 %
Date: 2017-01-22 02:20:28 Functions: 3 3 100.0 %

          Line data    Source code
       1             : /*
       2             :  * This file is part of FFmpeg.
       3             :  *
       4             :  * FFmpeg is free software; you can redistribute it and/or
       5             :  * modify it under the terms of the GNU Lesser General Public
       6             :  * License as published by the Free Software Foundation; either
       7             :  * version 2.1 of the License, or (at your option) any later version.
       8             :  *
       9             :  * FFmpeg is distributed in the hope that it will be useful,
      10             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      11             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      12             :  * Lesser General Public License for more details.
      13             :  *
      14             :  * You should have received a copy of the GNU Lesser General Public
      15             :  * License along with FFmpeg; if not, write to the Free Software
      16             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      17             :  */
      18             : 
      19             : #include "libavutil/des.c"
      20             : 
      21             : #include <stdint.h>
      22             : #include <stdio.h>
      23             : #include <stdlib.h>
      24             : #include <string.h>
      25             : 
      26             : #include "libavutil/time.h"
      27             : 
      28        4000 : static uint64_t rand64(void)
      29             : {
      30        4000 :     uint64_t r = rand();
      31        4000 :     r = (r << 32) | rand();
      32        4000 :     return r;
      33             : }
      34             : 
      35             : static const uint8_t test_key[] = { 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0 };
      36             : static const DECLARE_ALIGNED(8, uint8_t, plain)[] = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
      37             : static const DECLARE_ALIGNED(8, uint8_t, crypt)[] = { 0x4a, 0xb6, 0x5b, 0x3d, 0x4b, 0x06, 0x15, 0x18 };
      38             : static DECLARE_ALIGNED(8, uint8_t, tmp)[8];
      39             : static DECLARE_ALIGNED(8, uint8_t, large_buffer)[10002][8];
      40             : static const uint8_t cbc_key[] = {
      41             :     0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
      42             :     0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x01,
      43             :     0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x01, 0x23
      44             : };
      45             : 
      46           4 : static int run_test(int cbc, int decrypt)
      47             : {
      48             :     AVDES d;
      49           4 :     int delay = cbc && !decrypt ? 2 : 1;
      50             :     uint64_t res;
      51           4 :     AV_WB64(large_buffer[0], 0x4e6f772069732074ULL);
      52           4 :     AV_WB64(large_buffer[1], 0x1234567890abcdefULL);
      53           4 :     AV_WB64(tmp,             0x1234567890abcdefULL);
      54           4 :     av_des_init(&d, cbc_key, 192, decrypt);
      55           4 :     av_des_crypt(&d, large_buffer[delay], large_buffer[0], 10000, cbc ? tmp : NULL, decrypt);
      56           4 :     res = AV_RB64(large_buffer[9999 + delay]);
      57           4 :     if (cbc) {
      58           2 :         if (decrypt)
      59           1 :             return res == 0xc5cecf63ecec514cULL;
      60             :         else
      61           1 :             return res == 0xcb191f85d1ed8439ULL;
      62             :     } else {
      63           2 :         if (decrypt)
      64           1 :             return res == 0x8325397644091a0aULL;
      65             :         else
      66           1 :             return res == 0xdd17e8b8b437d232ULL;
      67             :     }
      68             : }
      69             : 
      70           1 : int main(void)
      71             : {
      72             :     AVDES d;
      73             :     int i;
      74             :     uint64_t key[3];
      75             :     uint64_t data;
      76             :     uint64_t ct;
      77             :     uint64_t roundkeys[16];
      78           1 :     srand(av_gettime());
      79           1 :     key[0] = AV_RB64(test_key);
      80           1 :     data   = AV_RB64(plain);
      81           1 :     gen_roundkeys(roundkeys, key[0]);
      82           1 :     if (des_encdec(data, roundkeys, 0) != AV_RB64(crypt)) {
      83           0 :         printf("Test 1 failed\n");
      84           0 :         return 1;
      85             :     }
      86           1 :     av_des_init(&d, test_key, 64, 0);
      87           1 :     av_des_crypt(&d, tmp, plain, 1, NULL, 0);
      88           1 :     if (memcmp(tmp, crypt, sizeof(crypt))) {
      89           0 :         printf("Public API decryption failed\n");
      90           0 :         return 1;
      91             :     }
      92           1 :     if (!run_test(0, 0) || !run_test(0, 1) || !run_test(1, 0) || !run_test(1, 1)) {
      93           0 :         printf("Partial Monte-Carlo test failed\n");
      94           0 :         return 1;
      95             :     }
      96        1001 :     for (i = 0; i < 1000; i++) {
      97        1000 :         key[0] = rand64();
      98        1000 :         key[1] = rand64();
      99        1000 :         key[2] = rand64();
     100        1000 :         data   = rand64();
     101        1000 :         av_des_init(&d, (uint8_t *) key, 192, 0);
     102        1000 :         av_des_crypt(&d, (uint8_t *) &ct, (uint8_t *) &data, 1, NULL, 0);
     103        1000 :         av_des_init(&d, (uint8_t *) key, 192, 1);
     104        1000 :         av_des_crypt(&d, (uint8_t *) &ct, (uint8_t *) &ct, 1, NULL, 1);
     105        1000 :         if (ct != data) {
     106           0 :             printf("Test 2 failed\n");
     107           0 :             return 1;
     108             :         }
     109             :     }
     110             : #ifdef GENTABLES
     111             :     printf("static const uint32_t S_boxes_P_shuffle[8][64] = {\n");
     112             :     for (i = 0; i < 8; i++) {
     113             :         int j;
     114             :         printf("    {");
     115             :         for (j = 0; j < 64; j++) {
     116             :             uint32_t v = S_boxes[i][j >> 1];
     117             :             v   = j & 1 ? v >> 4 : v & 0xf;
     118             :             v <<= 28 - 4 * i;
     119             :             v   = shuffle(v, P_shuffle, sizeof(P_shuffle));
     120             :             printf((j & 7) == 0 ? "\n    " : " ");
     121             :             printf("0x%08X,", v);
     122             :         }
     123             :         printf("\n    },\n");
     124             :     }
     125             :     printf("};\n");
     126             : #endif
     127           1 :     return 0;
     128             : }

Generated by: LCOV version 1.12