/* bcd32: 32 bit Pseudo-Random Number Generator Algorithm/Source Code */

/*
Copyright(c) 2015, Karl-Uwe Frank
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:

  1. Redistributions of source code must retain the above copyright
  notice, this list of conditions and the following disclaimer.

  2. Redistributions in binary form must reproduce the above copyright
  notice, this list of conditions and the following disclaimer in the
  documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES(INCLUDING, BUT NOT LIMITED
TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT(INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


 My special thanks goes to Bob Harris from Pennsylvania State University
 for his kind help in analysing the algorithm
 http://www.bx.psu.edu/~rsharris/


#** bcd32 algorithm designed and developed by Karl-Uwe Frank
*/

//# 28.09.2015  first design of bcd32
//
//# 08.11.2015  updated the seeding process that will always
//              start in a well known good initial state
//              and a 96bit seed can be passed to b,c,d
//                
//# 28.02.2017  Changed the seeding process to accept
//              a 128bit value in hex notation without leading 0x
//              to initialise a,b,c,d.
//              Fallback test for a and b never to be initialised with 0
//
//                
//**********************************************************************
//
// Compile Instructions
//
// rm -f ./bcd32_keystream; gcc -std=c99 -O3 -fomit-frame-pointer -mtune=native bcd32_keystream.c -o bcd32_keystream
//
// rm -f ./bcd32_keystream_PPC; gcc -std=c99 -O3 -fomit-frame-pointer -arch ppc bcd32_keystream.c -o bcd32_keystream_PPC
//
//-----------------------------------------
//
// ./bcd32_keystream 128bit_hex output_amount > bcd32_rng_out.bin
//
// ./bcd32_keystream 0c8c8279b04c4430d69a6454d069458e 256 > bcd32_rng_out.bin
//
// ./bcd32_keystream 0c8c8279b04c4430d69a6454d069458e 10240000 > bcd32_rng_out.bin
// 
//-----------------------------------------
//
// Test Vector (Little Endian)
//
// ./bcd32_keystream 0102030405 32 | xxd -g 1
// 
// 0000000: 08 86 64 40 34 23 00 1c 55 9e f7 ab 1b 98 04 72  ..d@4#..U......r
// 0000010: d2 3e 7c 5d 0a 38 98 06 6b aa 4d ff 22 f4 5d 94  .>|].8..k.M.".].
// 0000020: 04 6f 9f d0 47 6e 6b 57 97 01 8b e3 e0 74 ac 02  .o..GnkW.....t..
// 0000030: db 9d 68 0e 94 cb 91 05 0b 3e 6e f6 f4 02 1d 27  ..h......>n....'
// 0000040: a2 04 d8 89 f0 0b 8c 09 bd de 7e ba e0 6a 02 d0  ..........~..j..
// 0000050: 04 e0 be 5b 47 ce 40 1f e5 83 f8 6d b9 45 cd 72  ...[G.@....m.E.r
// 0000060: ca 5d 1a 67 9e 01 a5 5e e9 d9 de 1c 88 d5 bc 18  .].g...^........
// 0000070: 83 b9 d4 64 de c2 7a 17 3b f6 cd 00 13 20 37 d4  ...d..z.;.... 7.
// 
//
// ./bcd32_keystream 0c8c8279b04c4430d69a6454d069458e 32 | xxd -g 1
//
// 0000000: 06 00 90 6f a0 73 e4 73 fe b1 44 17 d3 b1 f4 f2  ...o.s.s..D.....
// 0000010: 3a c7 1a 69 48 b3 27 fa ac 7d 38 cd 67 5b 19 a4  :..iH.'..}8.g[..
// 0000020: e3 91 13 10 4b 8a dc 93 4f af 90 6b 49 45 f4 8b  ....K...O..kIE..
// 0000030: 5f 5c f7 60 bb e9 59 b3 ae 8d 47 c0 48 78 25 dd  _\.`..Y...G.Hx%.
// 0000040: 79 47 ec 36 24 c5 db 82 a4 8e a5 9b 43 5b f9 b5  yG.6$.......C[..
// 0000050: cb 62 7d 5e 18 e3 11 e5 c9 f2 83 67 60 28 27 97  .b}^.......g`('.
// 0000060: f5 4c fb 52 6c d0 84 e5 bc ca 32 c8 c8 42 c6 b2  .L.Rl.....2..B..
// 0000070: c7 d4 94 5e f3 a7 84 27 78 ce 7a d7 b8 1d 9c 8d  ...^...'x.z.....
//
//-----------------------------------------
// 
// Test Vector (Big Endian)
// 
// ./bcd32_keystream_PPC 0102030405 32 | xxd -g 1
// 
// 0000000: 40 64 86 08 1c 00 23 34 ab f7 9e 55 72 04 98 1b  @d....#4...Ur...
// 0000010: 5d 7c 3e d2 06 98 38 0a ff 4d aa 6b 94 5d f4 22  ]|>...8..M.k.]."
// 0000020: d0 9f 6f 04 57 6b 6e 47 e3 8b 01 97 02 ac 74 e0  ..o.WknG......t.
// 0000030: 0e 68 9d db 05 91 cb 94 f6 6e 3e 0b 27 1d 02 f4  .h.......n>.'...
// 0000040: 89 d8 04 a2 09 8c 0b f0 ba 7e de bd d0 02 6a e0  .........~....j.
// 0000050: 5b be e0 04 1f 40 ce 47 6d f8 83 e5 72 cd 45 b9  [....@.Gm...r.E.
// 0000060: 67 1a 5d ca 5e a5 01 9e 1c de d9 e9 18 bc d5 88  g.].^...........
// 0000070: 64 d4 b9 83 17 7a c2 de 00 cd f6 3b d4 37 20 13  d....z.....;.7 .
// 
// 
// ./bcd32_keystream_PPC 0c8c8279b04c4430d69a6454d069458e 32 | xxd -g 1
// 
// 0000000: 6f 90 00 06 73 e4 73 a0 17 44 b1 fe f2 f4 b1 d3  o...s.s..D......
// 0000010: 69 1a c7 3a fa 27 b3 48 cd 38 7d ac a4 19 5b 67  i..:.'.H.8}...[g
// 0000020: 10 13 91 e3 93 dc 8a 4b 6b 90 af 4f 8b f4 45 49  .......Kk..O..EI
// 0000030: 60 f7 5c 5f b3 59 e9 bb c0 47 8d ae dd 25 78 48  `.\_.Y...G...%xH
// 0000040: 36 ec 47 79 82 db c5 24 9b a5 8e a4 b5 f9 5b 43  6.Gy...$......[C
// 0000050: 5e 7d 62 cb e5 11 e3 18 67 83 f2 c9 97 27 28 60  ^}b.....g....'(`
// 0000060: 52 fb 4c f5 e5 84 d0 6c c8 32 ca bc b2 c6 42 c8  R.L....l.2....B.
// 0000070: 5e 94 d4 c7 27 84 a7 f3 d7 7a ce 78 8d 9c 1d b8  ^...'....z.x....
// 


#include <stdlib.h>
#include <stdio.h> 
#include <string.h>
#include <time.h>
// needed to generate uint32 on a 64bit OS
#include <stdint.h>

///////////////////////////////////////////

static uint32_t a, b, c, d, t;

void seed_bcd32(uint32_t seed[]);

// The Seeding Function
void seed_bcd32(uint32_t seed[]) {  
  a = seed[0];
  b = seed[1];   
  c = seed[2];  
  d = seed[3]; 
  
  if (a==0) a = 0x9E3779B9; // golden ratio
  if (b==0) b = 1;
  
  t = a + b + c + d;
}


int main (int argc, char *argv[]) { 
  if (strlen(argv[1]) < 2) {
    fprintf(stderr, "Min. key length is 8bit\n");
    return 1;
  }

  if (strlen(argv[1]) > 32) {
    fprintf(stderr, "Max. key length is 128bit\n");
    return 1;
  }

  uint64_t output_size;

  uint32_t seed[4];
  
  uint8_t key[32];
  uint8_t keyLen;
  uint8_t hexKey[32];
  uint8_t hex[3]; 

  // Make sure the Arrays get initialised properly
  // and wipe out Anything which might be there
  memset(seed,   0, sizeof(seed));
  memset(key,    0, sizeof(key));
  memset(hexKey, 0, sizeof(hexKey));
  memset(hex,    0, 3);

  // Store the Key in an 8bit Array
  strncpy(hexKey, argv[1], strlen(argv[1]));
  keyLen = strlen(hexKey);
  hexKey[keyLen] = 0;

  keyLen = keyLen/2;
  for (uint16_t i=0; i<keyLen; i++) {
    strncpy(hex, hexKey +(i*2), 2);
    key[i] = strtol(hex, NULL, 16);
  }

  keyLen = 0;
  memset(hex, 0, 3);
  memset(hexKey, 0, sizeof(hexKey));

  // Pass over the 8bit Array as 32bit Integer
  for (uint8_t i=0; i<4; i++) {
    for (uint8_t j=0; j<4; j++) {
      seed[i] = seed[i] | (uint32_t)key[i*4+j] << ((3-(j%4))*8);  // always BIG ENDIAN !!
    }
  }

  /* Debug */
  // fprintf(stderr, "after Initial Seeding ==> %08x, %08x, %08x, %08x\n", seed[0],seed[1],seed[2],seed[3]);
  // fprintf(stderr, "after Initial Seeding ==> %10u, %10u, %10u, %10u\n", seed[0],seed[1],seed[2],seed[3]);
  
  output_size = (uint64_t)strtoul(argv[2], NULL, 0);

  // Seed the PRNG
  seed_bcd32(seed);

  memset(seed, 0, sizeof(seed));

  // Write Output into Binary File (unbuffered Write)
  uint32_t outB;

  fflush(stdout);

  for (uint64_t i=0; i<output_size; i++) {
 
    a = a + (d >> 5);
    b = a + (b ^ c);
    c = a + (b << 13);
    d = a + (d ^ t);
    t = a + t;

    outB = (b ^ c ^ d);

    // Redirect Output to stdout
    fwrite(&outB, sizeof(uint32_t), 1, stdout);    
  }

  fflush(stdout);

  return 0;
}