95d30a77d1f8d0b3a8d00e8d38ed73b5aa5aebb5
[gnupg.git] / cipher / random.c
1 /* random.c  -  random number generator
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21
22 /****************
23  * This random number generator is modelled after the one described
24  * in Peter Gutmann's Paper: "Software Generation of Practically
25  * Strong Random Numbers".
26  */
27
28
29 #include <config.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <assert.h>
33 #include <errno.h>
34 #include <string.h>
35 #include <time.h>
36 #include <sys/time.h>
37 #include <sys/types.h>
38 #include <sys/stat.h>
39 #include <unistd.h>
40 #include <fcntl.h>
41 #ifdef HAVE_GETHRTIME
42   #include <sys/times.h>
43 #endif
44 #ifdef HAVE_GETTIMEOFDAY
45   #include <sys/times.h>
46 #endif
47 #ifdef HAVE_TIMES
48   #include <sys/times.h>
49 #endif
50 #ifdef HAVE_GETRUSAGE
51   #include <sys/resource.h>
52 #endif
53 #ifdef __MINGW32__
54   #include <process.h>
55 #endif
56 #include "util.h"
57 #include "rmd.h"
58 #include "ttyio.h"
59 #include "i18n.h"
60 #include "random.h"
61 #include "rand-internal.h"
62 #include "algorithms.h"
63
64 #ifndef RAND_MAX   /* for SunOS */
65   #define RAND_MAX 32767
66 #endif
67
68
69 #if SIZEOF_UNSIGNED_LONG == 8
70   #define ADD_VALUE 0xa5a5a5a5a5a5a5a5
71 #elif SIZEOF_UNSIGNED_LONG == 4
72   #define ADD_VALUE 0xa5a5a5a5
73 #else
74   #error weird size for an unsigned long
75 #endif
76
77 #define BLOCKLEN  64   /* hash this amount of bytes */
78 #define DIGESTLEN 20   /* into a digest of this length (rmd160) */
79 /* poolblocks is the number of digests which make up the pool
80  * and poolsize must be a multiple of the digest length
81  * to make the AND operations faster, the size should also be
82  * a multiple of ulong
83  */
84 #define POOLBLOCKS 30
85 #define POOLSIZE (POOLBLOCKS*DIGESTLEN)
86 #if (POOLSIZE % SIZEOF_UNSIGNED_LONG)
87   #error Please make sure that poolsize is a multiple of ulong
88 #endif
89 #define POOLWORDS (POOLSIZE / SIZEOF_UNSIGNED_LONG)
90
91
92 static int is_initialized;
93 #define MASK_LEVEL(a) do {if( a > 2 ) a = 2; else if( a < 0 ) a = 0; } while(0)
94 static char *rndpool;   /* allocated size is POOLSIZE+BLOCKLEN */
95 static char *keypool;   /* allocated size is POOLSIZE+BLOCKLEN */
96 static size_t pool_readpos;
97 static size_t pool_writepos;
98 static int pool_filled;
99 static int pool_balance;
100 static int just_mixed;
101 static int did_initial_extra_seeding;
102 static char *seed_file_name;
103 static int allow_seed_file_update;
104
105 static int secure_alloc;
106 static int quick_test;
107 static int faked_rng;
108
109
110 static void read_pool( byte *buffer, size_t length, int level );
111 static void add_randomness( const void *buffer, size_t length, int source );
112 static void random_poll(void);
113 static void read_random_source( int requester, size_t length, int level);
114 static int gather_faked( void (*add)(const void*, size_t, int), int requester,
115                                                     size_t length, int level );
116
117 static struct {
118     ulong mixrnd;
119     ulong mixkey;
120     ulong slowpolls;
121     ulong fastpolls;
122     ulong getbytes1;
123     ulong ngetbytes1;
124     ulong getbytes2;
125     ulong ngetbytes2;
126     ulong addbytes;
127     ulong naddbytes;
128 } rndstats;
129
130
131 static int (*
132 getfnc_gather_random (void))(void (*)(const void*, size_t, int), int,
133                         size_t, int)
134 {
135 #ifdef USE_ALL_RANDOM_MODULES
136   static int (*fnc)(void (*)(const void*, size_t, int), int, size_t, int);
137   
138   if (fnc)
139     return fnc;
140 # ifdef USE_RNDLINUX
141   if ( !access (NAME_OF_DEV_RANDOM, R_OK)
142        && !access (NAME_OF_DEV_RANDOM, R_OK))
143     {
144       fnc = rndlinux_gather_random;
145       return fnc;
146     }
147 # endif
148 # ifdef USE_RNDEGD
149   if ( rndegd_connect_socket (1) != -1 )
150     {
151       fnc = rndegd_gather_random;
152       return fnc;
153     }
154 # endif
155 # ifdef USE_RNDUNIX
156   fnc = rndunix_gather_random;
157   return fnc;
158 # endif
159
160   log_fatal (_("no entropy gathering module detected\n"));
161
162 #else
163 # ifdef USE_RNDLINUX
164   return rndlinux_gather_random;
165 # endif
166 # ifdef USE_RNDUNIX
167   return rndunix_gather_random;
168 # endif
169 # ifdef USE_RNDEGD
170   return rndegd_gather_random;
171 # endif
172 # ifdef USE_RNDW32
173   return rndw32_gather_random;
174 # endif
175 # ifdef USE_RNDRISCOS
176   return rndriscos_gather_random;
177 # endif
178 #endif
179   return NULL;
180 }
181
182 static void (*
183 getfnc_fast_random_poll (void))( void (*)(const void*, size_t, int), int)
184 {
185 #ifdef USE_RNDW32
186   return rndw32_gather_random_fast;
187 #endif
188   return NULL;
189 }
190
191
192
193 static void
194 initialize(void)
195 {
196     /* The data buffer is allocated somewhat larger, so that
197      * we can use this extra space (which is allocated in secure memory)
198      * as a temporary hash buffer */
199     rndpool = secure_alloc ? m_alloc_secure_clear(POOLSIZE+BLOCKLEN)
200                            : m_alloc_clear(POOLSIZE+BLOCKLEN);
201     keypool = secure_alloc ? m_alloc_secure_clear(POOLSIZE+BLOCKLEN)
202                            : m_alloc_clear(POOLSIZE+BLOCKLEN);
203     is_initialized = 1;
204 }
205
206 static void
207 burn_stack (int bytes)
208 {
209     char buf[128];
210     
211     wipememory(buf,sizeof buf);
212     bytes -= sizeof buf;
213     if (bytes > 0)
214         burn_stack (bytes);
215 }
216
217 void
218 random_dump_stats()
219 {
220     fprintf(stderr,
221             "random usage: poolsize=%d mixed=%lu polls=%lu/%lu added=%lu/%lu\n"
222             "              outmix=%lu getlvl1=%lu/%lu getlvl2=%lu/%lu\n",
223         POOLSIZE, rndstats.mixrnd, rndstats.slowpolls, rndstats.fastpolls,
224                   rndstats.naddbytes, rndstats.addbytes,
225         rndstats.mixkey, rndstats.ngetbytes1, rndstats.getbytes1,
226                     rndstats.ngetbytes2, rndstats.getbytes2 );
227 }
228
229 void
230 secure_random_alloc()
231 {
232     secure_alloc = 1;
233 }
234
235
236 int
237 quick_random_gen( int onoff )
238 {
239     int last;
240
241     read_random_source(0,0,0); /* init */
242     last = quick_test;
243     if( onoff != -1 )
244         quick_test = onoff;
245     return faked_rng? 1 : last;
246 }
247
248
249 /****************
250  * Fill the buffer with LENGTH bytes of cryptographically strong
251  * random bytes. level 0 is not very strong, 1 is strong enough
252  * for most usage, 2 is good for key generation stuff but may be very slow.
253  */
254 void
255 randomize_buffer( byte *buffer, size_t length, int level )
256 {
257     char *p = get_random_bits( length*8, level, 1 );
258     memcpy( buffer, p, length );
259     m_free(p);
260 }
261
262
263 int
264 random_is_faked()
265 {
266     if( !is_initialized )
267         initialize();
268     return faked_rng || quick_test;
269 }
270
271 /****************
272  * Return a pointer to a randomized buffer of level 0 and LENGTH bits
273  * caller must free the buffer.
274  * Note: The returned value is rounded up to bytes.
275  */
276 byte *
277 get_random_bits( size_t nbits, int level, int secure )
278 {
279     byte *buf, *p;
280     size_t nbytes = (nbits+7)/8;
281
282     if( quick_test && level > 1 )
283         level = 1;
284     MASK_LEVEL(level);
285     if( level == 1 ) {
286         rndstats.getbytes1 += nbytes;
287         rndstats.ngetbytes1++;
288     }
289     else if( level >= 2 ) {
290         rndstats.getbytes2 += nbytes;
291         rndstats.ngetbytes2++;
292     }
293
294     buf = secure && secure_alloc ? m_alloc_secure( nbytes ) : m_alloc( nbytes );
295     for( p = buf; nbytes > 0; ) {
296         size_t n = nbytes > POOLSIZE? POOLSIZE : nbytes;
297         read_pool( p, n, level );
298         nbytes -= n;
299         p += n;
300     }
301     return buf;
302 }
303
304
305 /****************
306  * Mix the pool
307  */
308 static void
309 mix_pool(byte *pool)
310 {
311     char *hashbuf = pool + POOLSIZE;
312     char *p, *pend;
313     int i, n;
314     RMD160_CONTEXT md;
315
316     rmd160_init( &md );
317 #if DIGESTLEN != 20
318     #error must have a digest length of 20 for ripe-md-160
319 #endif
320     /* loop over the pool */
321     pend = pool + POOLSIZE;
322     memcpy(hashbuf, pend - DIGESTLEN, DIGESTLEN );
323     memcpy(hashbuf+DIGESTLEN, pool, BLOCKLEN-DIGESTLEN);
324     rmd160_mixblock( &md, hashbuf);
325     memcpy(pool, hashbuf, 20 );
326
327     p = pool;
328     for( n=1; n < POOLBLOCKS; n++ ) {
329         memcpy(hashbuf, p, DIGESTLEN );
330
331         p += DIGESTLEN;
332         if( p+DIGESTLEN+BLOCKLEN < pend )
333             memcpy(hashbuf+DIGESTLEN, p+DIGESTLEN, BLOCKLEN-DIGESTLEN);
334         else {
335             char *pp = p+DIGESTLEN;
336             for(i=DIGESTLEN; i < BLOCKLEN; i++ ) {
337                 if( pp >= pend )
338                     pp = pool;
339                 hashbuf[i] = *pp++;
340             }
341         }
342
343         rmd160_mixblock( &md, hashbuf);
344         memcpy(p, hashbuf, 20 );
345     }
346     burn_stack (384); /* for the rmd160_mixblock() */
347 }
348
349
350 void
351 set_random_seed_file( const char *name )
352 {
353     if( seed_file_name )
354         BUG();
355     seed_file_name = m_strdup( name );
356 }
357
358 /****************
359  * Read in a seed form the random_seed file
360  * and return true if this was successful
361  */
362 static int
363 read_seed_file(void)
364 {
365     int fd;
366     struct stat sb;
367     unsigned char buffer[POOLSIZE];
368     int n;
369
370     if( !seed_file_name )
371         return 0;
372
373 #if defined(HAVE_DOSISH_SYSTEM) || defined(__CYGWIN__)
374     fd = open( seed_file_name, O_RDONLY | O_BINARY );
375 #else
376     fd = open( seed_file_name, O_RDONLY );
377 #endif
378     if( fd == -1 && errno == ENOENT) {
379         allow_seed_file_update = 1;
380         return 0;
381     }
382
383     if( fd == -1 ) {
384         log_info(_("can't open `%s': %s\n"), seed_file_name, strerror(errno) );
385         return 0;
386     }
387     if( fstat( fd, &sb ) ) {
388         log_info(_("can't stat `%s': %s\n"), seed_file_name, strerror(errno) );
389         close(fd);
390         return 0;
391     }
392     if( !S_ISREG(sb.st_mode) ) {
393         log_info(_("`%s' is not a regular file - ignored\n"), seed_file_name );
394         close(fd);
395         return 0;
396     }
397     if( !sb.st_size ) {
398         log_info(_("note: random_seed file is empty\n") );
399         close(fd);
400         allow_seed_file_update = 1;
401         return 0;
402     }
403     if( sb.st_size != POOLSIZE ) {
404         log_info(_("WARNING: invalid size of random_seed file - not used\n") );
405         close(fd);
406         return 0;
407     }
408     do {
409         n = read( fd, buffer, POOLSIZE );
410     } while( n == -1 && errno == EINTR );
411     if( n != POOLSIZE ) {
412         log_fatal(_("can't read `%s': %s\n"), seed_file_name,strerror(errno) );
413         close(fd);
414         return 0;
415     }
416
417     close(fd);
418
419     add_randomness( buffer, POOLSIZE, 0 );
420     /* add some minor entropy to the pool now (this will also force a mixing) */
421     {   pid_t x = getpid();
422         add_randomness( &x, sizeof(x), 0 );
423     }
424     {   time_t x = time(NULL);
425         add_randomness( &x, sizeof(x), 0 );
426     }
427     {   clock_t x = clock();
428         add_randomness( &x, sizeof(x), 0 );
429     }
430     /* And read a few bytes from our entropy source.  By using
431      * a level of 0 this will not block and might not return anything
432      * with some entropy drivers, however the rndlinux driver will use
433      * /dev/urandom and return some stuff - Do not read to much as we
434      * want to be friendly to the scare system entropy resource. */
435     read_random_source( 0, 16, 0 );
436
437     allow_seed_file_update = 1;
438     return 1;
439 }
440
441 void
442 update_random_seed_file()
443 {
444     ulong *sp, *dp;
445     int fd, i;
446
447     if( !seed_file_name || !is_initialized || !pool_filled )
448         return;
449     if( !allow_seed_file_update ) {
450         log_info(_("note: random_seed file not updated\n"));
451         return;
452     }
453
454
455     /* copy the entropy pool to a scratch pool and mix both of them */
456     for(i=0,dp=(ulong*)keypool, sp=(ulong*)rndpool;
457                                     i < POOLWORDS; i++, dp++, sp++ ) {
458         *dp = *sp + ADD_VALUE;
459     }
460     mix_pool(rndpool); rndstats.mixrnd++;
461     mix_pool(keypool); rndstats.mixkey++;
462
463 #if defined(HAVE_DOSISH_SYSTEM) || defined(__CYGWIN__)
464     fd = open( seed_file_name, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY,
465                                                         S_IRUSR|S_IWUSR );
466 #else
467     fd = open( seed_file_name, O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR );
468 #endif
469     if( fd == -1 ) {
470         log_info(_("can't create `%s': %s\n"), seed_file_name, strerror(errno) );
471         return;
472     }
473     do {
474         i = write( fd, keypool, POOLSIZE );
475     } while( i == -1 && errno == EINTR );
476     if( i != POOLSIZE ) {
477         log_info(_("can't write `%s': %s\n"), seed_file_name, strerror(errno) );
478     }
479     if( close(fd) )
480         log_info(_("can't close `%s': %s\n"), seed_file_name, strerror(errno) );
481 }
482
483
484 static void
485 read_pool( byte *buffer, size_t length, int level )
486 {
487     int i;
488     ulong *sp, *dp;
489
490     if( length > POOLSIZE ) {
491         log_bug("too many random bits requested\n");
492     }
493
494     if( !pool_filled ) {
495         if( read_seed_file() )
496             pool_filled = 1;
497     }
498
499     /* For level 2 quality (key generation) we alwas make
500      * sure that the pool has been seeded enough initially */
501     if( level == 2 && !did_initial_extra_seeding ) {
502         size_t needed;
503
504         pool_balance = 0;
505         needed = length - pool_balance;
506         if( needed < POOLSIZE/2 )
507             needed = POOLSIZE/2;
508         else if( needed > POOLSIZE )
509             BUG();
510         read_random_source( 3, needed, 2 );
511         pool_balance += needed;
512         did_initial_extra_seeding=1;
513     }
514
515     /* for level 2 make sure that there is enough random in the pool */
516     if( level == 2 && pool_balance < length ) {
517         size_t needed;
518
519         if( pool_balance < 0 )
520             pool_balance = 0;
521         needed = length - pool_balance;
522         if( needed > POOLSIZE )
523             BUG();
524         read_random_source( 3, needed, 2 );
525         pool_balance += needed;
526     }
527
528     /* make sure the pool is filled */
529     while( !pool_filled )
530         random_poll();
531
532     /* do always a fast random poll */
533     fast_random_poll();
534
535     if( !level ) { /* no need for cryptographic strong random */
536         /* create a new pool */
537         for(i=0,dp=(ulong*)keypool, sp=(ulong*)rndpool;
538                                     i < POOLWORDS; i++, dp++, sp++ )
539             *dp = *sp + ADD_VALUE;
540         /* must mix both pools */
541         mix_pool(rndpool); rndstats.mixrnd++;
542         mix_pool(keypool); rndstats.mixkey++;
543         memcpy( buffer, keypool, length );
544     }
545     else {
546         /* mix the pool (if add_randomness() didn't it) */
547         if( !just_mixed ) {
548             mix_pool(rndpool);
549             rndstats.mixrnd++;
550         }
551         /* create a new pool */
552         for(i=0,dp=(ulong*)keypool, sp=(ulong*)rndpool;
553                                     i < POOLWORDS; i++, dp++, sp++ )
554             *dp = *sp + ADD_VALUE;
555         /* and mix both pools */
556         mix_pool(rndpool); rndstats.mixrnd++;
557         mix_pool(keypool); rndstats.mixkey++;
558         /* read the required data
559          * we use a readpoiter to read from a different postion each
560          * time */
561         while( length-- ) {
562             *buffer++ = keypool[pool_readpos++];
563             if( pool_readpos >= POOLSIZE )
564                 pool_readpos = 0;
565             pool_balance--;
566         }
567         if( pool_balance < 0 )
568             pool_balance = 0;
569         /* and clear the keypool */
570         wipememory(keypool, POOLSIZE);
571     }
572 }
573
574
575 /****************
576  * Add LENGTH bytes of randomness from buffer to the pool.
577  * source may be used to specify the randomness source.
578  * Source is:
579  *      0 - used ony for initialization
580  *      1 - fast random poll function
581  *      2 - normal poll function
582  *      3 - used when level 2 random quality has been requested
583  *          to do an extra pool seed.
584  */
585 static void
586 add_randomness( const void *buffer, size_t length, int source )
587 {
588     const byte *p = buffer;
589
590     if( !is_initialized )
591         initialize();
592     rndstats.addbytes += length;
593     rndstats.naddbytes++;
594     while( length-- ) {
595         rndpool[pool_writepos++] ^= *p++;
596         if( pool_writepos >= POOLSIZE ) {
597             if( source > 1 )
598                 pool_filled = 1;
599             pool_writepos = 0;
600             mix_pool(rndpool); rndstats.mixrnd++;
601             just_mixed = !length;
602         }
603     }
604 }
605
606
607
608 static void
609 random_poll()
610 {
611     rndstats.slowpolls++;
612     read_random_source( 2, POOLSIZE/5, 1 );
613 }
614
615
616 void
617 fast_random_poll()
618 {
619     static void (*fnc)( void (*)(const void*, size_t, int), int) = NULL;
620     static int initialized = 0;
621
622     rndstats.fastpolls++;
623     if( !initialized ) {
624         if( !is_initialized )
625             initialize();
626         initialized = 1;
627         fnc = getfnc_fast_random_poll();
628     }
629     if( fnc ) {
630         (*fnc)( add_randomness, 1 );
631         return;
632     }
633
634     /* fall back to the generic function */
635   #if defined(HAVE_GETHRTIME) && !defined(HAVE_BROKEN_GETHRTIME)
636     {   hrtime_t tv;
637         /* On some Solaris and HPUX system gethrtime raises an SIGILL, but we 
638          * checked this with configure */
639         tv = gethrtime();
640         add_randomness( &tv, sizeof(tv), 1 );
641     }
642   #elif defined (HAVE_GETTIMEOFDAY)
643     {   struct timeval tv;
644         if( gettimeofday( &tv, NULL ) )
645             BUG();
646         add_randomness( &tv.tv_sec, sizeof(tv.tv_sec), 1 );
647         add_randomness( &tv.tv_usec, sizeof(tv.tv_usec), 1 );
648     }
649   #elif defined (HAVE_CLOCK_GETTIME)
650     {   struct timespec tv;
651         if( clock_gettime( CLOCK_REALTIME, &tv ) == -1 )
652             BUG();
653         add_randomness( &tv.tv_sec, sizeof(tv.tv_sec), 1 );
654         add_randomness( &tv.tv_nsec, sizeof(tv.tv_nsec), 1 );
655     }
656   #elif defined (HAVE_TIMES)
657     {   struct tms buf;
658         if( times( &buf ) == -1 )
659             BUG();
660         add_randomness( &buf, sizeof buf, 1 );
661     }
662   #endif
663   #ifdef HAVE_GETRUSAGE
664     #ifndef RUSAGE_SELF
665       #ifdef __GCC__
666         #warning There is no RUSAGE_SELF on this system
667       #endif
668     #else
669     {   struct rusage buf;
670         /* QNX/Neutrino does return ENOSYS - so we just ignore it and
671          * add whatever is in buf.  In a chroot environment it might not
672          * work at all (i.e. because /proc/ is not accessible), so we better 
673          * ignore all error codes and hope for the best
674          */
675         getrusage( RUSAGE_SELF, &buf );
676         
677         add_randomness( &buf, sizeof buf, 1 );
678         wipememory( &buf, sizeof buf );
679     }
680     #endif
681   #endif
682     /* time and clock are available on all systems - so
683      * we better do it just in case one of the above functions
684      * didn't work */
685     {   time_t x = time(NULL);
686         add_randomness( &x, sizeof(x), 1 );
687     }
688     {   clock_t x = clock();
689         add_randomness( &x, sizeof(x), 1 );
690     }
691 }
692
693
694
695 static void
696 read_random_source( int requester, size_t length, int level )
697 {
698     static int (*fnc)(void (*)(const void*, size_t, int), int,
699                                                     size_t, int) = NULL;
700     if( !fnc ) {
701         if( !is_initialized )
702             initialize();
703         fnc = getfnc_gather_random();
704         if( !fnc ) {
705             faked_rng = 1;
706             fnc = gather_faked;
707         }
708         if( !requester && !length && !level )
709             return; /* init only */
710     }
711     if( (*fnc)( add_randomness, requester, length, level ) < 0 )
712         log_fatal("No way to gather entropy for the RNG\n");
713 }
714
715
716 static int
717 gather_faked( void (*add)(const void*, size_t, int), int requester,
718               size_t length, int level )
719 {
720     static int initialized=0;
721     size_t n;
722     char *buffer, *p;
723
724     if( !initialized ) {
725         log_info(_("WARNING: using insecure random number generator!!\n"));
726         tty_printf(_("The random number generator is only a kludge to let\n"
727                    "it run - it is in no way a strong RNG!\n\n"
728                    "DON'T USE ANY DATA GENERATED BY THIS PROGRAM!!\n\n"));
729         initialized=1;
730       #ifdef HAVE_RAND
731         srand(make_timestamp()*getpid());
732       #else
733         srandom(make_timestamp()*getpid());
734       #endif
735     }
736
737     p = buffer = m_alloc( length );
738     n = length;
739   #ifdef HAVE_RAND
740     while( n-- )
741         *p++ = ((unsigned)(1 + (int) (256.0*rand()/(RAND_MAX+1.0)))-1);
742   #else
743     while( n-- )
744         *p++ = ((unsigned)(1 + (int) (256.0*random()/(RAND_MAX+1.0)))-1);
745   #endif
746     add_randomness( buffer, length, requester );
747     m_free(buffer);
748     return 0; /* okay */
749 }
750
751