pd.if.org Git - zpackage/blob - crypto/libeddsa/sign.c

   1 #define _POSIX_C_SOURCE 200809L
   2
   3 /* general zpm sign function */
   4
   5 /* read key, export key, import key, sign, export signature, import
   6  * signature, verify signature
   7  */
   8
   9 /* import and export is base64 encoded */
  10
  11 /* -v verify
  12  * -s sign
  13  * -g generate key
  14  * -e extract public key
  15  *
  16  * -o output file
  17  *
  18  * -p read key from file
  19  * -P read public key from argument to -P
  20  * -S read secret key from argument
  21  * -m message from argument
  22  * -h message is hex encoded
  23  */
  24
  25 #include <stdlib.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <unistd.h>
  29 #include <sys/types.h>
  30 #include <sys/stat.h>
  31 #include <fcntl.h>
  32 #include <sys/mman.h>
  33 #include <time.h>
  34
  35 /* linux specific for getrandom */
  36 #include <sys/random.h>
  37
  38 #include "eddsa.h"
  39 #include "sha512.h"
  40
  41 #define VERIFY 1
  42 #define SIGN 2
  43 #define GENKEY 3
  44 #define EXTRACT 4
  45
  46 //#define MARK do { fprintf(stderr, "%s %s:%d\n", __FILE__, __func__, __LINE__); } while (0)
  47
  48 static void hexdump(void *src, size_t len) {
  49         unsigned char *b = src;
  50         while (len--) {
  51                 printf("%02x", *b++);
  52         }
  53         printf("\n");
  54 }
  55
  56 static char hexchars[] = "0123456789abcdefABCDEF";
  57
  58 static void hex(char *dst, uint8_t *src, size_t len) {
  59         while (len--) {
  60                 dst[0] = hexchars[(src[0]>>4)&0xf];
  61                 dst[1] = hexchars[src[0]&0xf];
  62                 dst+=2;
  63                 src++;
  64         }
  65 }
  66
  67 static void hexbin(uint8_t *dst, unsigned char *src, size_t len) {
  68         size_t i;
  69         int x;
  70
  71         for (i=0; i<len; i+=2) {
  72                 sscanf((const char *)src+i, "%02x", &x);
  73                 dst[i/2] = x;
  74         }
  75 }
  76
  77 void *map(char *file, size_t *size) {
  78         int fd, rv;
  79         void *m;
  80         struct stat st;
  81
  82         fd = open(file, O_RDONLY);
  83         if (fd == -1) {
  84                 return NULL;
  85         }
  86
  87         rv = fstat(fd, &st);
  88         if (rv == -1) {
  89                 close(fd);
  90                 return NULL;
  91         }
  92
  93         m = mmap(0, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
  94         if (m == MAP_FAILED) {
  95                 return 0;
  96         }
  97
  98         close(fd);
  99         *size = st.st_size;
 100         return m;
 101 }
 102
 103 ssize_t readbytes(char *dest, char *file, size_t n) {
 104         char *m;
 105         size_t fs;
 106
 107         m = map(file, &fs);
 108         if (!m) {
 109                 return -1;
 110         }
 111         if (n > fs) {
 112                 n = fs;
 113         }
 114
 115         size_t pk = strspn(m, hexchars);
 116         pk /= 2;
 117         if (n > pk) {
 118                 n = pk;
 119         }
 120
 121         hexbin(dest, m, n*2);
 122         munmap(m, fs);
 123         return n;
 124 }
 125
 126
 127 /* private key format is:
 128  * "ZPMS" 4 byte magic "ZPMS"
 129  * byte 0x01 = version 1
 130  * byte 0x01 = private key
 131  * byte 0x01 = chacha encrypted, 0x00 = plain/raw key bytes
 132  * byte 0x00 reserved, probably "key usage"
 133  * 32 bytes private key
 134  * 24 bytes reserved
 135  * sub keys, public keys?  No point to the public key, since it's
 136  * always derivable.  could have 16 bytes of IV for chacha to encrypt.
 137  *
 138  * entire thing is then hexencoded, but
 139  */
 140
 141 /* public key format is:
 142  * "ZPMS" 4 byte magic "ZPMS"
 143  * 0x01   1 byte version
 144  * 0x02   1 byte "public key packet"
 145  * 0x00   1 byte reserved
 146  * 0x00   1 byte reserved
 147  * 0x..  32 bytes public key
 148  * 0x..  24 bytes reserved
 149  * 0x..     revocation signatures
 150  * 0x..     user id packets
 151  * 0x..     certification signatures
 152  * 0x..     sub key packets
 153  */
 154
 155 /* timestamps are 8 byte little endian integers of seconds since
 156  * the epoch.  or unix time, or some such.  Times are a mess.
 157  * Unix time is leap second unaware, and ambiguous during leap seconds.
 158  * UTC requires a database of leap seconds for past time, and the
 159  * specified second in the future possibly changes.
 160  * TAI is good, but currently 37 seconds behind UTC, which is just weird
 161  */
 162
 163 /* signature items from openpgp */
 164 /* revokable flag
 165  * 0-255 trust level
 166  *
 167  */
 168
 169 /* signature format:
 170  * "ZPMS" 4 byte magic "ZPMS"
 171  * 0x01   1 byte version
 172  * 0x03   1 byte "signature packet"
 173  * 0x00   1 byte reserved
 174  * 0x00   1 byte reserved
 175  * 0x..   8 bytes timestamp of signature time
 176  * 0x..   8 bytes timestamp of signature expiration, 0 if none
 177  * 0x..  64 bytes of actual signature
 178  * 0x..  32 bytes of public key making the signature
 179  * 0x..   8 bytes reserved
 180  * Total is 128 bytes.
 181  */
 182
 183 /* expires time could probably be 4 bytes as an offset from created.
 184  * That would free up 4 bytes.  Sign time could probably be four
 185  * bytes with an epoch of say 2019-01-01, since negative times don't
 186  * really make any sense, that give more than 100 years, and frees
 187  * up another 4 bytes
 188  *
 189  * version is zero until this proof of concept is better validated
 190  */
 191 struct signature {
 192         char magic[4]; /* magic ZPMS */
 193         char info[4]; /* version = 0, type=3, 1 byte trust, 1 byte reserved */
 194         uint64_t signtime; /* unix time */
 195         uint64_t expires; /* unix time, 0 = none */
 196         char sig[64];
 197         char pub[32];
 198         char reserved[8];
 199 };
 200
 201 struct key {
 202         char magic[4]; /* "ZPMS" */
 203         char info[4]; /* version, type = 0x02, reserved, reserved */
 204         char key[32];
 205         uint64_t created;
 206         uint64_t expires;
 207         char reserved[8];
 208         char sig[64]; /* zeroes for a private key, or fill in, doesn't matter*/
 209         /* could fill in the first 32 bytes of sig with the public key
 210          * if this is a private key, then you don't need another structure */
 211 };
 212
 213 int create_key(struct key *sk) {
 214         char info[] = { 0, 1, 0, 0 };
 215         memcpy(sk->magic, "ZPMS", 4);
 216         memcpy(sk->info, info, 4);
 217         getrandom(sk->key, sizeof sk->key, 0);
 218         ed25519_genpub(sk->sig, sk->key);
 219         sk->created = time(NULL);
 220         memset(sk->reserved, 0, 8);
 221         memset(sk->sig+32, 0, 32);
 222         return 1;
 223 }
 224
 225 int derive_pubkey(struct key *pk, struct key *sk) {
 226         char info[] = { 0, 2, 0, 0 };
 227
 228         memcpy(sk->magic, "ZPMS", 4);
 229         memcpy(sk->info, info, 4);
 230         ed25519_genpub(pk->key, sk->key);
 231         pk->created = sk->created;
 232         pk->expires = sk->expires;
 233         memset(sk->reserved, 0, 8);
 234
 235         ed25519_sign(pk->sig, sk->key, pk->sig, sk->info, 52);
 236         return 1;
 237
 238 }
 239
 240 /* if reserved used 16 bytes for signtime and expires, and we added
 241  * 64 bytes as a signature, a public key could include it's own self
 242  * signature, and a key would be 128 bytes, as would a signature.  This
 243  * would make all structures 128 bytes.
 244  */
 245
 246 int read_secret_key(uint8_t *sec, uint8_t *pub, char *file) {
 247         uint8_t sk[64];
 248
 249         readbytes(sk, file, sizeof sk);
 250         if (sk[4] != 1 || sk[5] != 1) {
 251                 printf("magic: ");
 252                 hexdump(sk, 16);
 253                 return 0;
 254         }
 255         memcpy(sec, sk+8, 32);
 256         //printf("sec: ");
 257         //hexdump(sec, 32);
 258
 259         if (pub) {
 260                 ed25519_genpub(pub, sec);
 261         //      printf("pub: ");
 262         //      hexdump(pub, 32);
 263         }
 264
 265         return 1;
 266 }
 267
 268 /* private key format is:
 269  * "ZPMS" 4 byte magic "ZPMS"
 270  * byte 0x01 = version 1
 271  * byte 0x01 = private key
 272  * byte 0x01 = chacha encrypted, 0x00 = plain/raw key bytes
 273  * byte 0x00 reserved, probably "key usage"
 274  * 32 bytes private key
 275  * 24 bytes reserved
 276  * sub keys, public keys?  No point to the public key, since it's
 277  * always derivable.  could have 16 bytes of IV for chacha to encrypt.
 278  *
 279  * entire thing is then hexencoded, but
 280  */
 281
 282 int write_secret_key(uint8_t *sec, int flags, int fd) {
 283         uint8_t skh[128] = "5A504D5301010000"; /* ZPMS 1 1 0 0 */
 284
 285         if (flags & 0x01) {
 286                 skh[13] = '1';
 287         }
 288         //hexdump(sec, 32);
 289         hex(skh + 16, sec, 32);
 290         memset(skh + 80, '0', 48);
 291         write(fd, skh, sizeof skh);
 292         memset(skh, 0, sizeof skh);
 293
 294         return 1;
 295 }
 296
 297 int main(int ac, char *av[]) {
 298         int option;
 299         int mode = 0;
 300         char *outfile = 0;
 301         uint8_t pub[ED25519_KEY_LEN];
 302         /* TODO should use mlock()ed memory for the secret key */
 303         uint8_t sec[ED25519_KEY_LEN];
 304         uint8_t sig[ED25519_SIG_LEN];
 305         void *message = 0;
 306         char *messagefile = 0;
 307         char *messagestring = 0;
 308         char messagehash[SHA512_HASH_LENGTH];
 309         char *keystring = 0, *keyfile = 0;
 310         unsigned char *sigstring = 0, *sigfile = 0;
 311         char *passphrase = 0;
 312         size_t mlen;
 313         int rawsig = 0, hexencoded = 0;
 314         int debug = 0;
 315
 316         while ((option = getopt(ac, av, "o:vS:f:sgek:K:rm:hd")) != -1) {
 317                 switch (option) {
 318                         case 'o': outfile = optarg; break;
 319                         case 'v': mode = VERIFY; break;
 320                         case 'S': sigstring = optarg; break;
 321                         case 'f': sigfile = optarg; break;
 322                         case 's': mode = SIGN; break;
 323                         case 'g': mode = GENKEY; break;
 324                         case 'e': mode = EXTRACT; break;
 325                         case 'k': keystring = optarg; break;
 326                         case 'K': keyfile = optarg; break;
 327                         case 'p': passphrase = optarg; break;
 328                         case 'm': messagestring = optarg; break;
 329                         case 'h': hexencoded = 1; break;
 330                         case 'r': rawsig = 1; break;
 331                         case 'd': debug++; break;
 332                         default:
 333                                   exit(EXIT_FAILURE);
 334                                   break;
 335                 }
 336         }
 337
 338         if (sigfile) {
 339                 ssize_t r;
 340                 memset(sig, 0, sizeof sig);
 341                 r = readbytes(sig, sigfile, sizeof sig);
 342                 if (r == -1) {
 343                         return 8;
 344                 }
 345                 if ((size_t)r < sizeof sig) {
 346                         return 7;
 347                 }
 348         } else if (sigstring) {
 349                 memset(sig, 0, sizeof sig);
 350                 hexbin(sig, sigstring, sizeof sig);
 351         }
 352
 353         if (keystring) {
 354                 memset(sec, 0, sizeof sec);
 355                 hexbin(sec, keystring, strlen(keystring));
 356                 ed25519_genpub(pub, sec);
 357                 if (debug) {
 358                         printf("sec:\n"); hexdump(sec, sizeof sec);
 359                 }
 360         } else if (keyfile) {
 361                 read_secret_key(sec, pub, keyfile);
 362                 //hexdump(sec, sizeof sec);
 363                 //hexdump(pub, sizeof pub);
 364         }
 365
 366         if (mode == EXTRACT) {
 367                 /* want to print the pubkey only */
 368                 hexdump(pub, sizeof pub);
 369                 exit(0);
 370         }
 371
 372         /* need to be able to encrypt the private keys */
 373         /* use chacha */
 374         if (mode == GENKEY) {
 375                 /* a private key is just 32 random bytes */
 376                 getrandom(sec, sizeof sec, 0);
 377                 ed25519_genpub(pub, sec);
 378                 ed25519_sign(sig, sec, pub, sec, sizeof sec);
 379                 //int rv = ed25519_verify(sig, pub, sec, sizeof sec);
 380                 if (outfile) {
 381                         int fd;
 382                         fd = open(outfile, O_WRONLY|O_CREAT, 0600);
 383                         if (fd == -1) {
 384                                 perror("can't open outfile");
 385                                 exit(EXIT_FAILURE);
 386                         }
 387                         write_secret_key(sec, 0, fd);
 388                         close(fd);
 389                 } else {
 390                         write_secret_key(sec, 0, 1);
 391                 }
 392         }
 393
 394         /* set up the message data */
 395         if (mode == SIGN || mode == VERIFY) {
 396                 messagefile = av[optind];
 397                 if (messagefile) {
 398                         message = map(messagefile, &mlen);
 399                         if (!message) {
 400                                 return 9;
 401                         }
 402                 } else if (messagestring) {
 403                         message = messagestring;
 404                         if (hexencoded) {
 405                                 mlen = strlen(messagestring)/2;
 406                                 message = malloc(mlen);
 407                                 if (!message) {
 408                                         return 10;
 409                                 }
 410                                 hexbin(message, messagestring, mlen*2);
 411                         } else {
 412                                 mlen = strlen(messagestring);
 413                         }
 414                 } else {
 415                         return 2;
 416                 }
 417                 if (!message) {
 418                         return 3;
 419                 }
 420         }
 421
 422         if (mode == SIGN) {
 423                 struct signature s;
 424                 s.magic[0] = 'Z';
 425                 s.magic[1] = 'P';
 426                 s.magic[2] = 'M';
 427                 s.magic[3] = 'S';
 428                 s.info[0] = 1;
 429                 s.info[1] = 1;
 430                 s.info[2] = 0;
 431                 s.info[3] = 0;
 432                 s.signtime = time(NULL);
 433                 s.expires = 0;
 434                 memset(s.reserved, 0, 8);
 435                 if (!rawsig) {
 436                         struct sha512 hash;
 437                         sha512_init(&hash);
 438                         sha512_add(&hash, message, mlen);
 439                         sha512_add(&hash, (uint8_t *)&s.signtime, sizeof s.signtime);
 440                         sha512_add(&hash, (uint8_t *)&s.expires, sizeof s.expires);
 441                         sha512_add(&hash, s.info, sizeof s.info);
 442                         sha512_final(&hash, messagehash);
 443                         message = messagehash;
 444                 }
 445
 446                 if (message == 0) {
 447                         return 5;
 448                 }
 449
 450                 ed25519_sign(sig, sec, pub, message, mlen);
 451                 memcpy(s.sig, sig, sizeof sig);
 452                 memcpy(s.pub, pub, sizeof pub);
 453                 if (rawsig) {
 454                         hexdump(sig, sizeof sig);
 455                 } else {
 456                         hexdump(&s, sizeof s);
 457                 }
 458         }
 459
 460         if (mode == VERIFY) {
 461                 fprintf(stderr, "sig: ");
 462                 hexdump(sig, sizeof sig);
 463                 int rv = ed25519_verify(sig, pub, message, mlen);
 464                 if (rv) {
 465                         fprintf(stderr, "verified\n");
 466                         return 0;
 467                 } else {
 468                         fprintf(stderr, "not verified\n");
 469                         return 6;
 470                 }
 471         }
 472
 473         if (message && messagefile) {
 474                 munmap(message, mlen);
 475         }
 476
 477         return 0;
 478 }