void output(OFREF outf, const inx) { char tstr[16]; u4byte av; put_string(outf, "\n// "); put_dec(tstr, kl[inx]); put_string(outf, tstr); put_string(outf, " Bit:"); put_string(outf, " Key Setup: "); put_dec(tstr, ekt[inx]); put_string(outf, tstr); put_char(outf, '/'); put_dec(tstr, dkt[inx]); put_string(outf, tstr); put_string(outf, " cycles"); put_string(outf, "\n// Encrypt: "); put_dec(tstr, et[inx]); put_string(outf, tstr); put_string(outf, " cycles = "); av = (1280 * PRO_CLOCK) / et[inx]; put_dec(tstr, av / 10); put_string(outf, tstr); put_char(outf, '.'); put_char(outf, (char)('0' + (av % 10))); put_string(outf, " mbits/sec"); put_string(outf, "\n// Decrypt: "); put_dec(tstr, dt[inx]); put_string(outf, tstr); put_string(outf, " cycles = "); av = (1280 * PRO_CLOCK) / dt[inx]; put_dec(tstr, av / 10); put_string(outf, tstr); put_char(outf, '.'); put_char(outf, (char)('0' + (av % 10))); put_string(outf, " mbits/sec"); #if(0) av = (et[inx] + dt[inx] + 1) >> 1; put_string(outf, "\n// Mean: "); put_dec(tstr, av); put_string(outf, tstr); put_string(outf, " cycles = "); av = (1280 * PRO_CLOCK) / av; put_dec(tstr, av / 10); put_string(outf, tstr); put_char(outf, '.'); put_char(outf, (char)('0' + (av % 10))); put_string(outf, " mbits/sec"); #endif }
void header(OFREF outf) { char tstr[16]; put_string(outf, "\n// Processor: "); put_string(outf, PROCESSOR); put_string(outf, " ("); put_dec(tstr, PRO_CLOCK); put_string(outf, tstr); put_string(outf, " MHz)\n"); }
int main(void) { char c; int term[2], result; unsigned int current_term; lcd_init(); keymatrix_init(); while (1) { put_char('>'); term[0] = 0; term[1] = 0; current_term = 0; while (1) { c = get_char(); put_char(c); if ('0' <= c && c <= '9') { term[current_term] = (term[current_term] * 10) + (c - '0'); } else if (c == '*') { current_term++; } else if (c == '\n') { result = term[0] * term[1]; put_dec(result); get_char(); /* 演算結果表示後、何らかのキー入力を待つ */ break; } } put_char('\n'); } return 0; }
void ref_test(const char *in_file, const unsigned int it_cnt, enum test_type t_type, AESREF alg) { u4byte i, kl, test_no, cnt, e_cnt; u1byte key[32], pt[16], iv[16], ect[16], act[32]; char str[128], tstr[16]; int ty; IFILE inf; con_string("\nTest file: "); con_string(in_file); con_string("\nStatus: \n"); if(!(inf = open_ifile(inf, in_file))) // reference file for test vectors { // if file is not present con_string("error in running test\n"); return; } cnt = 0; e_cnt = test_no = 0; for(;;) // while there are tests { ty = find_line(inf, str); // input a line if(ty < 0) // until end of file break; switch(ty) // process line type { case 0: kl = get_dec(str + 8); continue; // key length case 1: test_no = get_dec(str + 2); continue; // test number case 2: block_in(iv, str + 3); continue; // init vector case 3: block_in(key, str + 4); continue; // key case 4: block_in(pt, str + 3); // plaintext if(t_type != ecb_md && t_type != cbc_md) continue; break; case 5: block_in(ect, str + 3); // ciphertext if(t_type == ecb_md || t_type == cbc_md) continue; break; } if(serpent_hack) block_reverse(key, kl / 8); alg.set_key(key, kl, both); // set the key if(it_cnt > 100) OUT_DOTS(test_no); if(t_type == ecb_md || t_type == cbc_md) { block_copy(act, ect, 16); // encrypted text to low block if(t_type == cbc_md) // CBC Monte Carlo decryption { block_copy(act + 16, iv, 16); // IV to high block for(i = 0; i < it_cnt; i += 2) // do decryptions two at a time { if(serpent_hack) block_reverse(act, 16); alg.decrypt(act, ect); // decrypt low block if(serpent_hack) { block_reverse(act, 16); block_reverse(ect, 16); } block_xor(act + 16, ect, 16);// xor into high block if(serpent_hack) block_reverse(act + 16, 16); alg.decrypt(act + 16, ect); // decrypt high block if(serpent_hack) { block_reverse(ect, 16); block_reverse(act + 16, 16); } block_xor(act, ect, 16); // xor into low block } } else // ECB Monte Carlo decryption { if(serpent_hack) block_reverse(act, 16); for(i = 0; i < it_cnt; ++i) alg.decrypt(act, act); if(serpent_hack) block_reverse(act, 16); } if(!block_cmp(pt, act, 16)) { con_string("\n\ndecryption error on test "); put_dec(tstr, test_no); con_string(tstr); e_cnt++; } if(t_type == ecb_md) // test encryption if ECB mode { if(serpent_hack) block_reverse(act, 16); for(i = 0; i < it_cnt; ++i) alg.encrypt(act, act); if(serpent_hack) block_reverse(act, 16); if(!block_cmp(ect, act, 16)) { con_string("\n\nencryption error on test "); put_dec(tstr, test_no); con_string(tstr); e_cnt++; } } } else // if(t_type == ecb_me || t_type == cbc_me || ecb_vk || ecb_vt) { if(t_type == cbc_me) // CBC Monte Carlo encryption { block_copy(act, iv, 16); block_copy(act + 16, pt, 16); // copy IV and plaintext for(i = 0; i < it_cnt; i += 2) { block_xor(act + 16, act, 16); // xor low block into high block if(serpent_hack) block_reverse(act + 16, 16); alg.encrypt(act + 16, act + 16); // encrypt high block if(serpent_hack) block_reverse(act + 16, 16); block_xor(act, act + 16, 16); // xor high block into low block if(serpent_hack) block_reverse(act, 16); alg.encrypt(act, act); // encrypt low block if(serpent_hack) block_reverse(act, 16); } } else // ECB Monte Carlo encryption { block_copy(act, pt, 16); if(serpent_hack) block_reverse(act, 16); for(i = 0; i < it_cnt; ++i) alg.encrypt(act, act); if(serpent_hack) block_reverse(act, 16); } if(!block_cmp(ect, act, 16)) { con_string("\n\nencryption error on test "); put_dec(tstr, test_no); con_string(tstr); e_cnt++; } if(t_type != cbc_me) // if ECB mode test decrytpion { if(serpent_hack) block_reverse(act, 16); for(i = 0; i < it_cnt; ++i) alg.decrypt(act, act); if(serpent_hack) block_reverse(act, 16); if(!block_cmp(pt, act, 16)) { con_string("\n\ndecryption error on test "); put_dec(tstr, test_no); con_string(tstr); e_cnt++; } } } } close_ifile(inf); if(e_cnt > 0) // report any errors { put_dec(tstr, e_cnt); con_string("\n"); con_string(tstr); con_string(" errors during test\n"); } else // else report all is well con_string("\nall tests correct\n"); }
int hb_vsnprintf( char * buffer, size_t bufsize, const char * format, va_list ap ) { va_list args; size_t size; char c; #ifndef __NO_ARGPOS__ const char * fmt_start = format; v_param argbuf[ _ARGBUF_SIZE ]; v_paramlst params; params.size = _ARGBUF_SIZE; params.maxarg = 0; params.arglst = argbuf; #endif #ifndef __NO_ARGPOS__ do { params.repeat = HB_FALSE; if( params.maxarg > 0 ) { va_copy( args, ap ); va_arg_fill( ¶ms, args ); va_end( args ); } format = fmt_start; #endif va_copy( args, ap ); size = 0; do { c = *format++; if( c == '%' ) { const char * pattern = format; c = *format++; if( c != 0 && c != '%' ) { /* decode pattern */ v_param argval; int param = 0, flags = 0, width = -1, precision = -1, length, value, stop = 0; /* parameter position */ if( c >= '0' && c <= '9' ) { c = get_decimal( c, &format, &value ); if( c == '$' ) param = value; else format = pattern; c = *format++; } /* flags */ while( ! stop ) { switch( c ) { case '#': flags |= _F_ALTERNATE; c = *format++; break; case '0': flags |= _F_ZEROPADED; c = *format++; break; case '-': flags |= _F_LEFTADJUSTED; c = *format++; break; case ' ': flags |= _F_SPACE; c = *format++; break; case '+': flags |= _F_SIGN; c = *format++; break; #ifdef _SUSV2_COMPAT_ case '\'': /* group with locale thousands' grouping characters */ c = *format++; break; #endif default: stop = 1; break; } } /* field width */ if( c == '*' ) { c = *format++; if( c >= '0' && c <= '9' ) { c = get_decimal( c, &format, &value ); if( c == '$' ) { width = va_arg_n( args, _x_int, value ); c = *format++; } /* else error, wrong format */ } else width = va_arg_n( args, _x_int, 0 ); } else if( c >= '0' && c <= '9' ) c = get_decimal( c, &format, &width ); /* precision */ if( c == '.' ) { precision = 0; c = *format++; if( c == '*' ) { c = *format++; if( c >= '0' && c <= '9' ) { c = get_decimal( c, &format, &value ); if( c == '$' ) { precision = va_arg_n( args, _x_int, value ); c = *format++; } /* else error, wrong format */ } else precision = va_arg_n( args, _x_int, 0 ); } else if( c >= '0' && c <= '9' ) c = get_decimal( c, &format, &precision ); } /* length modifier */ switch( c ) { case 'h': c = *format++; if( c == 'h' ) { length = _L_CHAR_; c = *format++; } else length = _L_SHORT_; break; case 'l': c = *format++; if( c == 'l' ) { length = _L_LONGLONG_; c = *format++; } else length = _L_LONG_; break; case 'L': length = _L_LONGDOUBLE_; c = *format++; break; case 'j': length = _L_INTMAX_; c = *format++; break; case 'z': length = _L_SIZE_; c = *format++; break; case 't': length = _L_PTRDIFF_; c = *format++; break; case 'I': /* MS-Windows extension */ if( format[ 0 ] == '6' && format[ 1 ] == '4' ) { length = _L_LONGLONG_; format += 2; c = *format++; break; } else if( format[ 0 ] == '1' && format[ 1 ] == '6' ) { length = _L_SHORT_; format += 2; c = *format++; break; } else if( format[ 0 ] == '3' && format[ 1 ] == '2' ) { format += 2; c = *format++; } /* no break; */ default: length = _L_UNDEF_; break; } /* conversion specifier */ switch( c ) { #ifndef __NO_DOUBLE__ case 'a': case 'A': case 'e': case 'E': case 'g': case 'G': /* redirect above conversion to 'f' or 'F' type to keep * valid parameters order */ c = ( c == 'a' || c == 'e' || c == 'g' ) ? 'f' : 'F'; /* no break; */ case 'f': /* double decimal notation */ case 'F': /* double decimal notation */ if( length == _L_LONGDOUBLE_ ) { argval.value.as_x_long_dbl = va_arg_n( args, _x_long_dbl, param ); HB_NUMTYPEL( value, argval.value.as_x_long_dbl ); } else { double d = va_arg_n( args, _x_double, param ); HB_NUMTYPE( value, d ); argval.value.as_x_long_dbl = ( value & ( _HB_NUM_NAN | _HB_NUM_PINF | _HB_NUM_NINF ) ) == 0 ? d : 0; } if( value & _HB_NUM_NAN ) size = put_str( buffer, bufsize, size, c == 'f' ? ( flags & _F_SIGN ? "+nan": "nan" ) : ( flags & _F_SIGN ? "+NAN": "NAN" ) , flags, width, -1 ); else if( value & _HB_NUM_PINF ) size = put_str( buffer, bufsize, size, c == 'f' ? ( flags & _F_SIGN ? "+inf": "inf" ) : ( flags & _F_SIGN ? "+INF": "INF" ), flags, width, -1 ); else if( value & _HB_NUM_NINF ) size = put_str( buffer, bufsize, size, c == 'f' ? "-inf" : "-INF", flags, width, -1 ); else size = put_dbl( buffer, bufsize, size, argval.value.as_x_long_dbl, flags, width, precision ); continue; #endif case 'd': case 'i': /* signed int decimal conversion */ if( length == _L_CHAR_ ) argval.value.as_x_intmax_t = ( unsigned char ) va_arg_n( args, _x_int, param ); else if( length == _L_SHORT_ ) argval.value.as_x_intmax_t = ( unsigned short ) va_arg_n( args, _x_int, param ); else if( length == _L_LONG_ ) argval.value.as_x_intmax_t = va_arg_n( args, _x_long, param ); else if( length == _L_LONGLONG_ ) argval.value.as_x_intmax_t = va_arg_n( args, _x_longlong, param ); else if( length == _L_INTMAX_ ) argval.value.as_x_intmax_t = va_arg_n( args, _x_intmax_t, param ); else if( length == _L_SIZE_ ) argval.value.as_x_intmax_t = va_arg_n( args, _x_size_t, param ); else if( length == _L_PTRDIFF_ ) argval.value.as_x_intmax_t = va_arg_n( args, _x_ptrdiff_t, param ); else argval.value.as_x_intmax_t = va_arg_n( args, _x_int, param ); value = argval.value.as_x_intmax_t < 0; argval.value.as_x_uintmax_t = value ? -argval.value.as_x_intmax_t : argval.value.as_x_intmax_t; size = put_dec( buffer, bufsize, size, argval.value.as_x_uintmax_t, flags, width, precision, value ); continue; case 'o': /* unsigned int octal conversion */ case 'u': /* unsigned int decimal conversion */ case 'x': /* unsigned int hexadecimal conversion */ case 'X': /* unsigned int hexadecimal conversion */ if( length == _L_CHAR_ ) argval.value.as_x_uintmax_t = ( unsigned char ) va_arg_n( args, _x_int, param ); else if( length == _L_SHORT_ ) argval.value.as_x_uintmax_t = ( unsigned short ) va_arg_n( args, _x_int, param ); else if( length == _L_LONG_ ) argval.value.as_x_uintmax_t = va_arg_n( args, _x_ulong, param ); else if( length == _L_LONGLONG_ ) argval.value.as_x_uintmax_t = va_arg_n( args, _x_ulonglong, param ); else if( length == _L_INTMAX_ ) argval.value.as_x_uintmax_t = va_arg_n( args, _x_uintmax_t, param ); else if( length == _L_SIZE_ ) argval.value.as_x_uintmax_t = va_arg_n( args, _x_size_t, param ); else if( length == _L_PTRDIFF_ ) argval.value.as_x_uintmax_t = va_arg_n( args, _x_ptrdiff_t, param ); else argval.value.as_x_uintmax_t = va_arg_n( args, _x_uint, param ); if( c == 'o' ) size = put_octal( buffer, bufsize, size, argval.value.as_x_uintmax_t, flags, width, precision ); else if( c == 'u' ) size = put_dec( buffer, bufsize, size, argval.value.as_x_uintmax_t, flags & ~( _F_SPACE | _F_SIGN ), width, precision, 0 ); else size = put_hex( buffer, bufsize, size, argval.value.as_x_uintmax_t, flags, width, precision, c == 'X' ); continue; case 'p': /* void * pointer */ argval.value.as_x_ptr = va_arg_n( args, _x_ptr, param ); if( argval.value.as_x_ptr ) size = put_hex( buffer, bufsize, size, ( HB_PTRUINT ) argval.value.as_x_ptr, flags | _F_ALTERNATE, width, precision, 0 ); else size = put_str( buffer, bufsize, size, "(nil)", flags, width, -1 ); continue; case 'c': /* signed int casted to unsigned char */ if( ( flags & _F_LEFTADJUSTED ) == 0 ) { while( --width > 0 ) { if( size < bufsize ) buffer[ size ] = ' '; ++size; } } c = ( unsigned char ) va_arg_n( args, _x_int, param ); if( size < bufsize ) buffer[ size ] = c; ++size; while( --width > 0 ) { if( size < bufsize ) buffer[ size ] = ' '; ++size; } continue; case 's': /* const char * */ if( length == _L_LONG_ ) { argval.value.as_x_wstr = va_arg_n( args, _x_wstr, param ); size = put_wstr( buffer, bufsize, size, argval.value.as_x_wstr, flags, width, precision ); } else { argval.value.as_x_str = va_arg_n( args, _x_str, param ); size = put_str( buffer, bufsize, size, argval.value.as_x_str, flags, width, precision ); } continue; case 'n': /* store current result size in int * arg */ /* This is very danger feature in *printf() functions * family very often used by hackers to create buffer * overflows. It can also cause unintentional memory * corruption by programmers typo in pattern so if it's * not strictly necessary it's good to disable it. */ *( va_arg_n( args, _x_intptr, param ) ) = ( int ) size; continue; case '%': /* store % consuming arguments % */ break; default: /* error, wrong format, store pattern */ format = pattern; c = '%'; break; } } } /* ISO C99 defines that when size is 0 and buffer is NULL we should * return number of characters that would have been written in case * the output string has been large enough without trailing 0. * Many implementations always returns number of characters necessary * to hold the string even if the above condition is not true so the * returned value can be used to check if buffer was large enough * and if not to allocate bigger buffer. Let's do the same. */ if( size < bufsize ) buffer[ size ] = c; ++size; } while( c != 0 ); va_end( args ); #ifndef __NO_ARGPOS__ } while( params.repeat ); if( params.arglst != argbuf ) hb_xfree( params.arglst ); #endif /* always set trailing \0 !!! */ if( bufsize ) buffer[ bufsize - 1 ] = 0; return ( int ) ( size - 1 ); }