/**
* cdk_keygen_set_algo_info: set the length and type of the key
* @hd: the keygen object.
* @type: key type (primary=0, subkey=1)
* @algo: algorithm compliant with rfc2440
* @bits: lengt of the key in bits
*
**/
cdk_error_t
cdk_keygen_set_algo_info( cdk_keygen_ctx_t hd, int type,
enum cdk_pk_algo_t algo, int bits )
{
int rc;
int usage = type? PK_USAGE_ENCR : PK_USAGE_SIGN;
if( !hd )
return CDK_Inv_Value;
if( type < 0 || type > 1 )
return CDK_Inv_Value;
if( bits % 128 != 0 )
bits = bits + ( bits % 128 );
rc = _cdk_pk_test_algo( algo, usage );
if( rc )
return rc;
/* type=0 primary type=1 sub */
hd->key[type].algo = algo;
hd->key[type].len = check_bits( bits, algo );
return 0;
}
void fix_bit(int correct){
int nowfor=0;
check_bits(nowfor+1, correct, 0);
}
int main(int argc, char **argv) {
if (argc != 4) {
printUsage();
}
int number = atoi(argv[1]);
int pos_1 = atoi(argv[2]);
int pos_2 = atoi(argv[3]);
char *pointer = dec_to_bin(number);
int check = check_bits(pointer, pos_1, pos_2);
print_match(check);
free(pointer);
return 0;
}
void check_bits(int nowfor, int correct, int befornum){
char tmp[MBITS+1];
for (int tmpcount=0; tmpcount<MBITS; tmpcount++){tmp[tmpcount]=answer[tmpcount];}
for (int b = befornum; b<MBITS; b++) {
answer[b]=input[b];
if (nowfor==correct) {
for (int count=0; count<MBITS; count++) {
if (answer[count]=='\0') {
answer[count]=changechar(input[count]);
}
}
printf("%s\n",answer);
for (int tmpcount=0; tmpcount<MBITS; tmpcount++){answer[tmpcount]=tmp[tmpcount];}
} else {
check_bits(nowfor+1, correct, b+1);
for (int tmpcount=0; tmpcount<MBITS; tmpcount++){answer[tmpcount]=tmp[tmpcount];}
}
}
}
static void
test_behavior ()
{
union {
float f;
double d;
#ifndef _RWSTD_NO_LONG_DOUBLE
long double l;
#endif // _RWSTD_NO_LONG_DOUBLE
char buf [sizeof (long double) * 2];
} u;
#if !defined (__SUNPRO_CC) || __SUNPRO_CC > 0x530
// make sure functions do not overflow buffer
clear_bytes (u.buf, sizeof u);
const float f = std::modf (3.141592f, &u.f);
if(!( 3000 == int (u.f * 1000) && 141592 == int (f * 1000000)
&& check_bits (u.buf + sizeof u.f, sizeof u - sizeof u.f)))
{
failures++;
std_log(LOG_FILENAME_LINE,"Reason: Failing modf function");
}
rw_assert ( 3000 == int (u.f * 1000) && 141592 == int (f * 1000000)
&& check_bits (u.buf + sizeof u.f, sizeof u - sizeof u.f),
0, __LINE__, "float std::modf (float)");
#endif // SunPro > 5.3
clear_bytes (u.buf, sizeof u);
const double d = std::modf (3.1415926, &u.d);
if(!(3000 == int (u.d * 1000) && 1415926 == int (d * 10000000)
&& check_bits (u.buf + sizeof u.d, sizeof u - sizeof u.d)))
{
failures++;
std_log(LOG_FILENAME_LINE,"Reason: Failing modf function");
}
rw_assert ( 3000 == int (u.d * 1000) && 1415926 == int (d * 10000000)
&& check_bits (u.buf + sizeof u.d, sizeof u - sizeof u.d),
0, __LINE__, "double std::modf (double)");
#ifndef __SYMBIAN32__
#ifndef _RWSTD_NO_LONG_DOUBLE
# if !defined (__SUNPRO_CC) || __SUNPRO_CC > 0x530
clear_bytes (u.buf, sizeof u);
const long double l = std::modf (3.1415926L, &u.l);
bool test=check_bits (u.buf + sizeof u.l, sizeof u - sizeof u.l);
if(!(3000 == int (u.l * 1000) && 1415926 == int (l * 10000000)
&& test))
{
failures++;
std_log(LOG_FILENAME_LINE,"Reason: Failing modf function");
}
rw_assert ( 3000 == int (u.l * 1000) && 1415926 == int (l * 10000000)
&& check_bits (u.buf + sizeof u.l, sizeof u - sizeof u.l),
0, __LINE__, "long double std::modf (long double)");
# endif // SunPro > 5.3
#endif // _RWSTD_NO_LONG_DOUBLE
#endif // __SYMBIAN32__
// check overloads of std::pow()
for (int i = -10; i != 10; ++i) {
for (int j = -10; j != 10; ++j) {
if (-9 < j && j < 9) {
// verify that both versions are equivalent
const float xf = std::pow (float (i), int (j));
const float yf = std::pow (float (i), float (j));
if(!(rw_equal (xf, yf) || !i && j < 0))
{
failures++;
std_log(LOG_FILENAME_LINE,"Reason: Failing pow function for i=%d,j=%d",i,j);
}
rw_assert (rw_equal (xf, yf) || !i && j < 0,
0, __LINE__,
"std::pow (%d.0f, %d) = %g, "
"std::pow (%d,0f, %d.0f) = %g",
i, j, xf, i, j, yf);
}
const float xd = std::pow (double (i), int (j));
const float yd = std::pow (double (i), double (j));
if(!(rw_equal (xd, yd) || !i && j < 0))
{
failures++;
std_log(LOG_FILENAME_LINE,"Reason: Failing pow function for i=%d,j=%d",i,j);
}
rw_assert (rw_equal (xd, yd) || !i && j < 0,
0, __LINE__,
"std::pow (%d.0, %d) = %g, "
"std::pow (%d.0, %d.0) = %g",
i, j, xd, i, j, yd);
#ifndef _RWSTD_NO_LONG_DOUBLE
const long double xl = std::pow ((long double)i, int (j));
const long double yl = std::pow ((long double)i, (long double)j);
if(!(rw_equal (xl, yl) || !i && j < 0))
{
failures++;
std_log(LOG_FILENAME_LINE,"Reason: Failing pow function ");
}
rw_assert (rw_equal (xl, yl) || !i && j < 0,
0, __LINE__,
"std::pow (%d.0L, %d) = %Lg, "
"std::pow (%d.0L, %d.0L) = %Lg",
i, j, xl, i, j, yl);
#endif // _RWSTD_NO_LONG_DOUBLE
}
}
}
int main(int argc, char** argv)
{
int offset, padding;
int width, logn, maxlogn;
qio_chtype_t type;
qio_hint_t hints[] = {QIO_METHOD_DEFAULT, QIO_METHOD_READWRITE, QIO_METHOD_PREADPWRITE, QIO_METHOD_FREADFWRITE, QIO_METHOD_MEMORY, QIO_METHOD_MMAP, QIO_METHOD_MMAP|QIO_HINT_PARALLEL, QIO_METHOD_PREADPWRITE | QIO_HINT_NOFAST};
int nhints = sizeof(hints)/sizeof(qio_hint_t);
int file_hint, ch_hint;
{
//for( file_hint = 0; file_hint < nhints; file_hint++ ) {
// check_write_read_pat(1, 262144, 0, 0, file_hint, file_hint, 0);
//}
//check_write_read_pat(32,4096,0,3,QIO_METHOD_PREADPWRITE,0,1);
//check_write_read_pat(32,4096,0,3,0,0,1);
//exit(0);
//check_write_read_pat(width=32, num=4096, pat=0, type=3, file_hints=default_type default, ch_hints=buffered default, reopen=1)
// Run unit tests.
for( offset = 0; offset < 63; offset++ ) {
for( padding = 0; padding < 63; padding++ ) {
check_bits(offset, padding);
}
}
maxlogn = 19;
if( valgrind ) maxlogn = 10;
for( logn = 0; logn < maxlogn; logn+=9 ) {
for( width = 1; width <= 64; width++ ) {
for( file_hint = 0; file_hint < nhints; file_hint++ ) {
ch_hint = file_hint;
type = 0;
check_write_read_pat(width,1 << logn,0,type,file_hint,ch_hint,0);
check_write_read_pat(width,1 << logn,1,type,file_hint,ch_hint,1);
}
}
}
}
// Do extra testing that showed a bug at one point...
if( !valgrind ) {
int i;
int n = 256*1024*1024;
qio_file_t* f;
qio_channel_t* writing;
qio_channel_t* reading;
uint64_t got;
uint64_t expect;
qioerr err;
//qbytes_iobuf_size = 256;
err = qio_file_open_mem(&f, NULL, NULL);
assert(!err);
//err = qio_file_open_access(&f, "test.bin", "w+", 0, NULL);
//assert(!err);
err = qio_channel_create(&writing, f, 0, 0, 1, 0, INT64_MAX, NULL);
assert(!err);
for( i = 0; i < n; i++ ) {
err = qio_channel_write_bits(false, writing, i & 0x1f, 5);
//err = qio_channel_write_bits(false, writing, 0x1f, 5);
assert(!err);
}
qio_channel_release(writing);
if( argc > 2 ) {
err = qio_channel_create(&reading, f, 0, 1, 0, 0, INT64_MAX, NULL);
assert(!err);
for( i = 0; i < n; i++ ) {
got = 0;
err = qio_channel_read_bits(false, reading, &got, 5);
assert(!err);
expect = i & 0x1f;
//expect = 0x1f;
if( got != expect ) {
printf("Failed at i=%i got %llx expect %llx\n", i, (long long int) got, (long long int) expect);
assert( got == expect );
}
}
qio_channel_release(reading);
}
qio_file_release(f);
}
printf("qio_bits_test PASS\n");
return 0;
}
/*-
* _gnutls_x509_cert_verify_peers - return the peer's certificate status
* @session: is a gnutls session
*
* This function will try to verify the peer's certificate and return its status (TRUSTED, REVOKED etc.).
* The return value (status) should be one of the gnutls_certificate_status_t enumerated elements.
* However you must also check the peer's name in order to check if the verified certificate belongs to the
* actual peer. Returns a negative error code in case of an error, or GNUTLS_E_NO_CERTIFICATE_FOUND if no certificate was sent.
-*/
int
_gnutls_x509_cert_verify_peers (gnutls_session_t session,
unsigned int *status)
{
cert_auth_info_t info;
gnutls_certificate_credentials_t cred;
gnutls_x509_crt_t *peer_certificate_list;
int peer_certificate_list_size, i, x, ret;
CHECK_AUTH (GNUTLS_CRD_CERTIFICATE, GNUTLS_E_INVALID_REQUEST);
info = _gnutls_get_auth_info (session);
if (info == NULL)
{
gnutls_assert ();
return GNUTLS_E_INVALID_REQUEST;
}
cred = (gnutls_certificate_credentials_t)
_gnutls_get_cred (session->key, GNUTLS_CRD_CERTIFICATE, NULL);
if (cred == NULL)
{
gnutls_assert ();
return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
}
if (info->raw_certificate_list == NULL || info->ncerts == 0)
return GNUTLS_E_NO_CERTIFICATE_FOUND;
if (info->ncerts > cred->verify_depth && cred->verify_depth > 0)
{
gnutls_assert ();
return GNUTLS_E_CONSTRAINT_ERROR;
}
/* generate a list of gnutls_certs based on the auth info
* raw certs.
*/
peer_certificate_list_size = info->ncerts;
peer_certificate_list =
gnutls_calloc (peer_certificate_list_size, sizeof (gnutls_x509_crt_t));
if (peer_certificate_list == NULL)
{
gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
for (i = 0; i < peer_certificate_list_size; i++)
{
ret = gnutls_x509_crt_init (&peer_certificate_list[i]);
if (ret < 0)
{
gnutls_assert ();
CLEAR_CERTS;
return ret;
}
ret =
gnutls_x509_crt_import (peer_certificate_list[i],
&info->raw_certificate_list[i],
GNUTLS_X509_FMT_DER);
if (ret < 0)
{
gnutls_assert ();
CLEAR_CERTS;
return ret;
}
if (ret < 0)
{
gnutls_assert ();
CLEAR_CERTS;
return ret;
}
ret = check_bits (peer_certificate_list[i], cred->verify_bits);
if (ret < 0)
{
gnutls_assert ();
CLEAR_CERTS;
return ret;
}
}
/* Verify certificate
*/
ret = gnutls_x509_crt_list_verify (peer_certificate_list,
peer_certificate_list_size,
cred->x509_ca_list, cred->x509_ncas,
cred->x509_crl_list, cred->x509_ncrls,
cred->verify_flags | session->internals.
priorities.additional_verify_flags,
status);
CLEAR_CERTS;
if (ret < 0)
{
gnutls_assert ();
return ret;
}
return 0;
}
static void
test_behavior ()
{
union {
float f;
double d;
#ifndef _RWSTD_NO_LONG_DOUBLE
long double l;
#endif // _RWSTD_NO_LONG_DOUBLE
char buf [sizeof (long double) * 2];
} u;
#if !defined (__SUNPRO_CC) || __SUNPRO_CC > 0x530
// make sure functions do not overflow buffer
clear_bytes (u.buf, sizeof u);
const float f = std::modf (3.141592f, &u.f);
rw_assert ( 3000 == int (u.f * 1000) && 141592 == int (f * 1000000)
&& check_bits (u.buf + sizeof (u.f), sizeof (u) - sizeof (u.f)),
__FILE__, __LINE__, "float std::modf (float)");
#endif // SunPro > 5.3
clear_bytes (u.buf, sizeof u);
const double d = std::modf (3.1415926, &u.d);
rw_assert ( 3000 == int (u.d * 1000) && 1415926 == int (d * 10000000)
&& check_bits (u.buf + sizeof (u.d), sizeof (u) - sizeof (u.d)),
__FILE__, __LINE__, "double std::modf (double)");
#ifndef _RWSTD_NO_LONG_DOUBLE
# if !defined (__SUNPRO_CC) || __SUNPRO_CC > 0x530
clear_bytes (u.buf, sizeof u);
const long double l = std::modf (3.1415926L, &u.l);
rw_assert ( 3000 == int (u.l * 1000) && 1415926 == int (l * 10000000)
&& check_bits (u.buf + sizeof (u.l), sizeof (u) - sizeof (u.l)),
__FILE__, __LINE__, "long double std::modf (long double)");
# endif // SunPro > 5.3
#endif // _RWSTD_NO_LONG_DOUBLE
// check overloads of std::pow()
for (int i = -10; i != 10; ++i) {
for (int j = -10; j != 10; ++j) {
if (-9 < j && j < 9) {
const float fi = float (i);
const float fj = float (j);
// verify that both versions are equivalent
const float xf = std::pow (fi, j);
const float yf = std::pow (fi, fj);
rw_assert (rw_equal (xf, yf) || (!i && j < 0),
0, __LINE__,
"std::pow (%d.0f, %d) = %g, "
"std::pow (%d,0f, %d.0f) = %g",
i, j, xf, i, j, yf);
}
const double id = double (i);
const double jd = double (j);
const double xd = std::pow (id, j);
const double yd = std::pow (id, jd);
rw_assert (rw_equal (xd, yd) || (!i && j < 0),
0, __LINE__,
"std::pow (%d.0, %d) = %g, "
"std::pow (%d.0, %d.0) = %g",
i, j, xd, i, j, yd);
#ifndef _RWSTD_NO_LONG_DOUBLE
const long double il = _RWSTD_STATIC_CAST (long double, i);
const long double jl = _RWSTD_STATIC_CAST (long double, j);
const long double xl = std::pow (il, j);
const long double yl = std::pow (il, jl);
rw_assert (rw_equal (xl, yl) || (!i && j < 0),
0, __LINE__,
"std::pow (%d.0L, %d) = %Lg, "
"std::pow (%d.0L, %d.0L) = %Lg",
i, j, xl, i, j, yl);
#endif // _RWSTD_NO_LONG_DOUBLE
}
}
}
