VerificationType StackMapFrame::get_local(
int32_t index, VerificationType type, TRAPS) {
if (index >= _max_locals) {
verifier()->verify_error(
ErrorContext::bad_local_index(_offset, index),
"Local variable table overflow");
return VerificationType::bogus_type();
}
bool subtype = type.is_assignable_from(_locals[index],
verifier(), false, CHECK_(VerificationType::bogus_type()));
if (!subtype) {
verifier()->verify_error(
ErrorContext::bad_type(_offset,
TypeOrigin::local(index, this),
TypeOrigin::implicit(type)),
"Bad local variable type");
return VerificationType::bogus_type();
}
if(index >= _locals_size) { _locals_size = index + 1; }
return _locals[index];
}
// Pop and return the top type on stack type array after verifying it
// is assignable to type.
inline VerificationType pop_stack(VerificationType type, TRAPS) {
if (_stack_size != 0) {
VerificationType top = _stack[_stack_size - 1];
bool subtype = type.is_assignable_from(
top, verifier(), false, CHECK_(VerificationType::bogus_type()));
if (subtype) {
--_stack_size;
return top;
}
}
return pop_stack_ex(type, THREAD);
}
inline void push_stack_2(
VerificationType type1, VerificationType type2, TRAPS) {
assert(type1.is_long() || type1.is_double(), "must be long/double");
assert(type2.is_long2() || type2.is_double2(), "must be long/double_2");
if (_stack_size >= _max_stack - 1) {
verifier()->verify_error(
ErrorContext::stack_overflow(_offset, this),
"Operand stack overflow");
return;
}
_stack[_stack_size++] = type1;
_stack[_stack_size++] = type2;
}
Case * DiableHumain::choisirUneCase() {
int x, y;
bool ok;
Case * c;
// l’utilisateur choisit un coup
do {
// l’utilisateur tape un coup
cout << "Diable > x ? ";
cin >> x;
cout << "Diable > y ? ";
cin >> y;
// le programme verifie le coup
if (ok=verifier(x,y)) c = maPartie->monDamier->mesCases[x-1][y-1];
} while (!ok);
return c;
}
/*
* Verify a Certificate Verify message
*/
bool Certificate_Verify::verify(const X509_Certificate& cert,
const Handshake_State& state,
const Policy& policy) const
{
std::unique_ptr<Public_Key> key(cert.subject_public_key());
policy.check_peer_key_acceptable(*key);
std::pair<std::string, Signature_Format> format =
state.parse_sig_format(*key.get(), m_hash_algo, m_sig_algo,
true, policy);
PK_Verifier verifier(*key, format.first, format.second);
return verifier.verify_message(state.hash().get_contents(), m_signature);
}
void du_fichier(void)
{
int i,choix;
info("Lecture des valeurs x[i] et y[i] à partir d'un fichier:");
info("Le fichier doit contenir un point par ligne comme suit:\n");
info("\tx[i]\ty[i]\n\t\tx[i+1]\ty[i+1]\n\t\t...");
ouvrir_fichier();
x = MALLOC(double,n);
y = MALLOC(double,n);
if((x == NULL) || (y == NULL))
{
erreur("Impossible d\'allouer la mémoire pour x et y (dans du_fichier())");
perror("Description système de l\'erreur");
menu();
return;
}
for(i = 0; i < n; i ++)
{
fscanf(donnees,"%lf\t%lf\n",x+i,y+i);
}
fclose(donnees);
if(verifier() == 0)
{
erreur("Les valeurs des xi ne sont pas deux a deux distinctes.");
info("Vous pouvez :\n\t1 - Recommencer\n\t2 - Abandonner");
invite("Votre choix :");
scanf("%d",&choix);
vider_stdin();
if(choix == 1)
{
du_fichier();
return; //plus rien à faire ici
} else { // il abandonne
menu();
return;
}
}
menu();
}
VerificationType StackMapFrame::set_locals_from_arg(
const methodHandle m, VerificationType thisKlass, TRAPS) {
symbolHandle signature(THREAD, m->signature());
SignatureStream ss(signature);
int init_local_num = 0;
if (!m->is_static()) {
init_local_num++;
// add one extra argument for instance method
if (m->name() == vmSymbols::object_initializer_name() &&
thisKlass.name() != vmSymbols::java_lang_Object()) {
_locals[0] = VerificationType::uninitialized_this_type();
_flags |= FLAG_THIS_UNINIT;
} else {
_locals[0] = thisKlass;
}
}
// local num may be greater than size of parameters because long/double occupies two slots
while(!ss.at_return_type()) {
init_local_num += _verifier->change_sig_to_verificationType(
&ss, &_locals[init_local_num],
CHECK_VERIFY_(verifier(), VerificationType::bogus_type()));
ss.next();
}
_locals_size = init_local_num;
switch (ss.type()) {
case T_OBJECT:
case T_ARRAY:
{
symbolOop sig = ss.as_symbol(CHECK_(VerificationType::bogus_type()));
return VerificationType::reference_type(symbolHandle(THREAD, sig));
}
case T_INT: return VerificationType::integer_type();
case T_BYTE: return VerificationType::byte_type();
case T_CHAR: return VerificationType::char_type();
case T_SHORT: return VerificationType::short_type();
case T_BOOLEAN: return VerificationType::boolean_type();
case T_FLOAT: return VerificationType::float_type();
case T_DOUBLE: return VerificationType::double_type();
case T_LONG: return VerificationType::long_type();
case T_VOID: return VerificationType::bogus_type();
default:
ShouldNotReachHere();
}
return VerificationType::bogus_type();
}
// TODO: Verify that this test is actually working correctly and not just
// spuriously passing. Have no reason to suspect test is wrong. It just
// seems complex.
TEST(ByteCodeInterpreter, OutOfOrderMatches)
{
ShardId c_numShards = 1;
char const * text =
"RankDown {"
" Delta: 2,"
" Child: LoadRowJz {"
" Row: Row(0, 0, 0, false),"
" Child: AndRowJz {"
" Row: Row(1, 0, 1, false),"
" Child: AndRowJz {"
" Row: Row(2, 0, 2, false),"
" Child: Report {"
" Child: "
" }"
" }"
" }"
" }"
"}";
const Rank initialRank = 2;
ByteCodeVerifier verifier(GetIndex(c_numShards), initialRank);
verifier.DeclareRow("3");
verifier.DeclareRow("5");
verifier.DeclareRow("7");
for (auto iteration : verifier.GetIterations())
{
const size_t slice = verifier.GetSliceNumber(iteration);
const size_t offset = verifier.GetOffset(iteration);
for (size_t i = 0; i < 4; ++i)
{
const uint64_t row0 = verifier.GetRowData(0, offset + i, slice);
const uint64_t row1 = verifier.GetRowData(1, (offset + i) >> 1, slice);
const uint64_t row2 = verifier.GetRowData(2, (offset + i) >> 2, slice);
verifier.ExpectResult(row0 & row1 & row2, offset + i, slice);
}
}
verifier.Verify(text);
}
// TODO remove it
// verify the signature using crypto++ verifier
int cryptopp_test(ECPPoint Q, Integer r, Integer s, byte *message, unsigned message_length){
std::vector<byte> signature(64);
r.Encode(signature.data(), 32);
s.Encode(signature.data()+32, 32);
ECDSA<ECP, SHA256>::PublicKey publicKey;
publicKey.Initialize(ASN1::secp256k1(), Q);
ECDSA<ECP, SHA256>::Signer signer;
ECDSA<ECP, SHA256>::Verifier verifier(publicKey);
bool result = verifier.VerifyMessage( message, message_length, signature.data(), 64);
if(!result){
// cerr << "FAIL cryptopp" << endl;
return 1;
}
return 0;
}
void MemChecker::verify()
{
if (!needMemCheck())
{
return;
}
ModuleLoader *loader = testcase->getLoader();
typedef void (*verify_t)(void);
verify_t verifier = (verify_t)loader->findSymbol("verifyMemChecker");
verifier();
//delete info; // Note: this will cause linux run exception
//delete failure;
//info = 0;
//failure = 0;
}
/**
* Verify a Server Key Exchange message
*/
bool Server_Key_Exchange::verify(const Public_Key& server_key,
const Handshake_State& state,
const Policy& policy) const
{
policy.check_peer_key_acceptable(server_key);
std::pair<std::string, Signature_Format> format =
state.parse_sig_format(server_key, m_hash_algo, m_sig_algo,
false, policy);
PK_Verifier verifier(server_key, format.first, format.second);
verifier.update(state.client_hello()->random());
verifier.update(state.server_hello()->random());
verifier.update(params());
return verifier.check_signature(m_signature);
}
Test::Result
PK_Signature_Verification_Test::run_one_test(const std::string&, const VarMap& vars)
{
const std::vector<uint8_t> message = get_req_bin(vars, "Msg");
const std::vector<uint8_t> signature = get_req_bin(vars, "Signature");
const std::string padding = get_opt_str(vars, "Padding", default_padding(vars));
std::unique_ptr<Botan::Public_Key> pubkey = load_public_key(vars);
Test::Result result(algo_name() + "/" + padding + " signature verification");
Botan::PK_Verifier verifier(*pubkey, padding);
result.test_eq("correct signature valid", verifier.verify_message(message, signature), true);
check_invalid_signatures(result, verifier, message, signature);
return result;
}
void Inscription::confirmation(){
grbConfirm = new QGroupBox("Confirmation", this);
hboxConfirm = new QHBoxLayout(this);
grbConfirm->setLayout(hboxConfirm);
btnConfirmConfirmer = new QPushButton("Confirmer", this);
hboxConfirm->addWidget(btnConfirmConfirmer);
connect(btnConfirmConfirmer, SIGNAL(clicked()), this, SLOT(confirmer()));
btnConfirmVerifier = new QPushButton("Vérifier", this);
hboxConfirm->addWidget(btnConfirmVerifier);
connect(btnConfirmVerifier, SIGNAL(clicked()), this, SLOT(verifier()));
btnConfirmSortir = new QPushButton("Sortir", this);
hboxConfirm->addWidget(btnConfirmSortir);
connect(btnConfirmSortir, SIGNAL(clicked()), this, SLOT(quitter()));
vboxMain->addWidget(grbConfirm);
}
TEST(ByteCodeInterpreter, OrMatches)
{
ShardId c_numShards = 1;
char const * text =
"Or {"
" Children: ["
" LoadRowJz {"
" Row: Row(0, 0, 0, false),"
" Child: Report {"
" Child: "
" }"
" },"
" LoadRowJz {"
" Row: Row(1, 0, 0, false),"
" Child: Report {"
" Child: "
" }"
" }"
" ]"
"}";
const Rank initialRank = 0;
ByteCodeVerifier verifier(GetIndex(c_numShards), initialRank);
verifier.DeclareRow("3");
verifier.DeclareRow("5");
for (auto iteration : verifier.GetIterations())
{
const size_t slice = verifier.GetSliceNumber(iteration);
const size_t offset = verifier.GetOffset(iteration);
const uint64_t row0 = verifier.GetRowData(0, offset, slice);
const uint64_t row1 = verifier.GetRowData(1, offset, slice);
verifier.ExpectResult(row0, offset, slice);
verifier.ExpectResult(row1, offset, slice);
}
verifier.Verify(text);
}
void InvertibleRSAFunction::GenerateRandom(RandomNumberGenerator &rng, const NameValuePairs &alg)
{
int modulusSize = 2048;
alg.GetIntValue(Name::ModulusSize(), modulusSize) || alg.GetIntValue(Name::KeySize(), modulusSize);
assert(modulusSize >= 16);
if (modulusSize < 16)
throw InvalidArgument("InvertibleRSAFunction: specified modulus size is too small");
m_e = alg.GetValueWithDefault(Name::PublicExponent(), Integer(17));
assert(m_e >= 3); assert(!m_e.IsEven());
if (m_e < 3 || m_e.IsEven())
throw InvalidArgument("InvertibleRSAFunction: invalid public exponent");
RSAPrimeSelector selector(m_e);
AlgorithmParameters primeParam = MakeParametersForTwoPrimesOfEqualSize(modulusSize)
(Name::PointerToPrimeSelector(), selector.GetSelectorPointer());
m_p.GenerateRandom(rng, primeParam);
m_q.GenerateRandom(rng, primeParam);
m_d = m_e.InverseMod(LCM(m_p-1, m_q-1));
assert(m_d.IsPositive());
m_dp = m_d % (m_p-1);
m_dq = m_d % (m_q-1);
m_n = m_p * m_q;
m_u = m_q.InverseMod(m_p);
if (FIPS_140_2_ComplianceEnabled())
{
RSASS<PKCS1v15, SHA>::Signer signer(*this);
RSASS<PKCS1v15, SHA>::Verifier verifier(signer);
SignaturePairwiseConsistencyTest_FIPS_140_Only(signer, verifier);
RSAES<OAEP<SHA> >::Decryptor decryptor(*this);
RSAES<OAEP<SHA> >::Encryptor encryptor(decryptor);
EncryptionPairwiseConsistencyTest_FIPS_140_Only(encryptor, decryptor);
}
}
TEST(ByteCodeInterpreter, AndRowJzDelta1Inverted)
{
ShardId c_numShards = 1;
char const * text =
"LoadRowJz {"
" Row: Row(1, 0, 0, false),"
" Child: AndRowJz {"
" Row: Row(0, 0, 1, true),"
" Child: Report {"
" Child: "
" }"
" }"
"}";
const Rank initialRank = 0;
ByteCodeVerifier verifier(GetIndex(c_numShards), initialRank);
// IMPORTANT: row0 must be a row whose value differs
// across adjacent quadwords in order to correctly
// test the rank delta. If row0 has the same value in
// adjacent quadwords,
// GetRowData(0, slice, offset)
// will return the same value as
// GetRowData(0, slice, offset /2);
verifier.DeclareRow("3");
verifier.DeclareRow("2");
for (auto iteration : verifier.GetIterations())
{
const size_t slice = verifier.GetSliceNumber(iteration);
const size_t offset = verifier.GetOffset(iteration);
const uint64_t row1 = verifier.GetRowData(1, offset, slice);
const uint64_t row0 = verifier.GetRowData(0, offset / 2, slice);
verifier.ExpectResult(row1 & ~row0, offset, slice);
}
verifier.Verify(text);
}
void CLispEng::Verify(CObMap& obMap) {
CVerifier verifier(obMap);
/*!!!
{ //!!!
for (int i=0; i<m_consMan.m_size; i++)
{
CConsValue *p = m_consMan.m_pBase+i;
if (*(byte*)p != 0xFF)
{
if (Type(p->m_cdr) == TS_FRAME_PTR)
Throw(E_FAIL);
}
}
}*/
for (size_t i=0; i<m_packageMan.m_size; ++i) {
CPackage *pack = m_packageMan.Base+i;
if (*(byte*)pack != 0xFF) {
CVerifyCallback c = { &verifier };
pack->m_mapSym.ForEachSymbolValue(c);
}
}
}
/*
* Check the signature on an object
*/
bool X509_Object::check_signature(const Public_Key& pub_key) const
{
try {
std::vector<std::string> sig_info =
split_on(OIDS::lookup(m_sig_algo.oid), '/');
if(sig_info.size() != 2 || sig_info[0] != pub_key.algo_name())
return false;
std::string padding = sig_info[1];
Signature_Format format =
(pub_key.message_parts() >= 2) ? DER_SEQUENCE : IEEE_1363;
PK_Verifier verifier(pub_key, padding, format);
return verifier.verify_message(tbs_data(), signature());
}
catch(std::exception&)
{
return false;
}
}
bool
IsotropicBallModel::doParse(type::ModelCmdType cmd, std::list<std::string>& tokens)
{
if (tokens.empty())
return false;
switch (cmd)
{
case type::MODEL_SET_TIME:
case type::MODEL_SET_PHI:
case type::MODEL_SET_THETA:
case type::MODEL_SET_CATALOG_TYPE:
{
return IsotropicSphereModel::doParse(cmd, tokens);
}
case type::MODEL_SET_RADIUS:
{
SyntaxVerifier verifier(tokens);
if (!verifier.verifyRange())
{
std::stringstream ss;
ss << "Parsing failed. Model '" << ModelMapper::instance()->getKey(getType())
<< "'. Command '" << ModelCmdMapper::instance()->getKey(cmd)
<< "' requires range format.";
Exception exc(type::EXCEPTION_WARNING + type::EXCEPTION_MOD_NO_PREFIX,
ss.str(), PRETTY_FUNCTION);
throw exc;
}
_minValue = std::strtod(verifier.getExtracted()[0]->c_str(), 0);
_maxValue = std::strtod(verifier.getExtracted()[1]->c_str(), 0);
tokens.clear();
return true;
}
default:
break;
}
return false;
}
/*
* Verify a Certificate Verify message
*/
bool Certificate_Verify::verify(const X509_Certificate& cert,
const Handshake_State& state,
const Policy& policy) const
{
std::unique_ptr<Public_Key> key(cert.subject_public_key());
policy.check_peer_key_acceptable(*key);
std::pair<std::string, Signature_Format> format =
state.parse_sig_format(*key.get(), m_hash_algo, m_sig_algo,
true, policy);
PK_Verifier verifier(*key, format.first, format.second);
const bool signature_valid =
verifier.verify_message(state.hash().get_contents(), m_signature);
#if defined(BOTAN_UNSAFE_FUZZER_MODE)
return true;
#else
return signature_valid;
#endif
}
TEST(NativeCode, AndRowJzMatches)
{
ShardId c_numShards = 1;
char const * text =
"LoadRowJz {"
" Row: Row(0, 0, 0, false),"
" Child: AndRowJz {"
" Row: Row(1, 0, 0, false),"
" Child: AndRowJz {"
" Row: Row(2, 0, 0, false),"
" Child: Report {"
" Child: "
" }"
" }"
" }"
"}";
const Rank initialRank = 0;
NativeCodeVerifier verifier(GetIndex(c_numShards), initialRank);
verifier.DeclareRow("2");
verifier.DeclareRow("3");
verifier.DeclareRow("5");
for (auto iteration : verifier.GetIterations())
{
const size_t slice = verifier.GetSliceNumber(iteration);
const size_t offset = verifier.GetOffset(iteration);
const uint64_t row0 = verifier.GetRowData(0, offset, slice);
const uint64_t row1 = verifier.GetRowData(1, offset, slice);
const uint64_t row2 = verifier.GetRowData(2, offset, slice);
verifier.ExpectResult(row0 & row1 & row2, offset, slice);
}
verifier.Verify(text);
}
bool StackMapFrame::has_flag_match_exception(
const StackMapFrame* target) const {
// We allow flags of {UninitThis} to assign to {} if-and-only-if the
// target frame does not depend upon the current type.
// This is slightly too strict, as we need only enforce that the
// slots that were initialized by the <init> (the things that were
// UninitializedThis before initialize_object() converted them) are unused.
// However we didn't save that information so we'll enforce this upon
// anything that might have been initialized. This is a rare situation
// and javac never generates code that would end up here, but some profilers
// (such as NetBeans) might, when adding exception handlers in <init>
// methods to cover the invokespecial instruction. See 7020118.
assert(max_locals() == target->max_locals() &&
stack_size() == target->stack_size(), "StackMap sizes must match");
VerificationType top = VerificationType::top_type();
VerificationType this_type = verifier()->current_type();
if (!flag_this_uninit() || target->flags() != 0) {
return false;
}
for (int i = 0; i < target->locals_size(); ++i) {
if (locals()[i] == this_type && target->locals()[i] != top) {
return false;
}
}
for (int i = 0; i < target->stack_size(); ++i) {
if (stack()[i] == this_type && target->stack()[i] != top) {
return false;
}
}
return true;
}
int main(){
int nombreutilisateur,nombreverifie,nombrealeatoire;
bool victoire=false;
int compteur=0,rejouer;
nombrealeatoire = alea(1,10000);
while(victoire==false){
nombreutilisateur = demander();
print_newline();
print_newline();
nombreverifie = verifier(nombreutilisateur);
victoire = comparer(nombreverifie,nombrealeatoire);
compteur = compteur+1;}
print_text("Vous avez trouvé la solution en ");
print_int(compteur);
print_text(" coups");
print_newline();
print_newline();
print_text("Voulez vous rejouer ? : Oui ? tapez(1), Non ? tapez (2) : ");
print_newline();
print_newline();
rejouer=read_int();
if(rejouer==1){main();}
else{print_text("Au revoir !"); print_newline();print_newline();}
return 0;}
bool ValidateESIGN()
{
cout << "\nESIGN validation suite running...\n\n";
bool pass = true, fail;
static const char plain[] = "test";
static const byte signature[] =
"\xA3\xE3\x20\x65\xDE\xDA\xE7\xEC\x05\xC1\xBF\xCD\x25\x79\x7D\x99\xCD\xD5\x73\x9D\x9D\xF3\xA4\xAA\x9A\xA4\x5A\xC8\x23\x3D\x0D\x37\xFE\xBC\x76\x3F\xF1\x84\xF6\x59"
"\x14\x91\x4F\x0C\x34\x1B\xAE\x9A\x5C\x2E\x2E\x38\x08\x78\x77\xCB\xDC\x3C\x7E\xA0\x34\x44\x5B\x0F\x67\xD9\x35\x2A\x79\x47\x1A\x52\x37\x71\xDB\x12\x67\xC1\xB6\xC6"
"\x66\x73\xB3\x40\x2E\xD6\xF2\x1A\x84\x0A\xB6\x7B\x0F\xEB\x8B\x88\xAB\x33\xDD\xE4\x83\x21\x90\x63\x2D\x51\x2A\xB1\x6F\xAB\xA7\x5C\xFD\x77\x99\xF2\xE1\xEF\x67\x1A"
"\x74\x02\x37\x0E\xED\x0A\x06\xAD\xF4\x15\x65\xB8\xE1\xD1\x45\xAE\x39\x19\xB4\xFF\x5D\xF1\x45\x7B\xE0\xFE\x72\xED\x11\x92\x8F\x61\x41\x4F\x02\x00\xF2\x76\x6F\x7C"
"\x79\xA2\xE5\x52\x20\x5D\x97\x5E\xFE\x39\xAE\x21\x10\xFB\x35\xF4\x80\x81\x41\x13\xDD\xE8\x5F\xCA\x1E\x4F\xF8\x9B\xB2\x68\xFB\x28";
FileSource keys("TestData/esig1536.dat", true, new HexDecoder);
ESIGN<SHA>::Signer signer(keys);
ESIGN<SHA>::Verifier verifier(signer);
fail = !SignatureValidate(signer, verifier);
pass = pass && !fail;
fail = !verifier.VerifyMessage((byte *)plain, strlen(plain), signature, verifier.SignatureLength());
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ");
cout << "verification check against test vector\n";
cout << "Generating signature key from seed..." << endl;
signer.AccessKey().GenerateRandom(GlobalRNG(), MakeParameters("Seed", ConstByteArrayParameter((const byte *)"test", 4))("KeySize", 3*512));
verifier = signer;
fail = !SignatureValidate(signer, verifier);
pass = pass && !fail;
return pass;
}
/**
* Verify a Certificate Verify message
*/
bool Certificate_Verify::verify(const X509_Certificate& cert,
HandshakeHash& hash)
{
// FIXME: duplicate of Server_Key_Exchange::verify
std::auto_ptr<Public_Key> key(cert.subject_public_key());
std::string padding = "";
Signature_Format format = IEEE_1363;
if(key->algo_name() == "RSA")
padding = "EMSA3(TLS.Digest.0)";
else if(key->algo_name() == "DSA")
{
padding == "EMSA1(SHA-1)";
format = DER_SEQUENCE;
}
else
throw Invalid_Argument(key->algo_name() +
" is invalid/unknown for TLS signatures");
PK_Verifier verifier(*key, padding, format);
return verifier.verify_message(hash.final(), signature);
}
void TestSignatureScheme(TestData &v)
{
std::string name = GetRequiredDatum(v, "Name");
std::string test = GetRequiredDatum(v, "Test");
member_ptr<PK_Signer> signer(ObjectFactoryRegistry<PK_Signer>::Registry().CreateObject(name.c_str()));
member_ptr<PK_Verifier> verifier(ObjectFactoryRegistry<PK_Verifier>::Registry().CreateObject(name.c_str()));
TestDataNameValuePairs pairs(v);
if (test == "GenerateKey")
{
signer->AccessPrivateKey().GenerateRandom(GlobalRNG(), pairs);
verifier->AccessPublicKey().AssignFrom(signer->AccessPrivateKey());
}
else
{
std::string keyFormat = GetRequiredDatum(v, "KeyFormat");
if (keyFormat == "DER")
verifier->AccessMaterial().Load(StringStore(GetDecodedDatum(v, "PublicKey")).Ref());
else if (keyFormat == "Component")
verifier->AccessMaterial().AssignFrom(pairs);
if (test == "Verify" || test == "NotVerify")
{
VerifierFilter verifierFilter(*verifier, NULL, VerifierFilter::SIGNATURE_AT_BEGIN);
PutDecodedDatumInto(v, "Signature", verifierFilter);
PutDecodedDatumInto(v, "Message", verifierFilter);
verifierFilter.MessageEnd();
if (verifierFilter.GetLastResult() == (test == "NotVerify"))
SignalTestFailure();
return;
}
else if (test == "PublicKeyValid")
{
if (!verifier->GetMaterial().Validate(GlobalRNG(), 3))
SignalTestFailure();
return;
}
if (keyFormat == "DER")
signer->AccessMaterial().Load(StringStore(GetDecodedDatum(v, "PrivateKey")).Ref());
else if (keyFormat == "Component")
signer->AccessMaterial().AssignFrom(pairs);
}
if (test == "GenerateKey" || test == "KeyPairValidAndConsistent")
{
TestKeyPairValidAndConsistent(verifier->AccessMaterial(), signer->GetMaterial());
VerifierFilter verifierFilter(*verifier, NULL, VerifierFilter::THROW_EXCEPTION);
verifierFilter.Put((const byte *)"abc", 3);
StringSource ss("abc", true, new SignerFilter(GlobalRNG(), *signer, new Redirector(verifierFilter)));
}
else if (test == "Sign")
{
SignerFilter f(GlobalRNG(), *signer, new HexEncoder(new FileSink(cout)));
StringSource ss(GetDecodedDatum(v, "Message"), true, new Redirector(f));
SignalTestFailure();
}
else if (test == "DeterministicSign")
{
// This test is specialized for RFC 6979. The RFC is a drop-in replacement
// for DSA and ECDSA, and access to the seed or secret is not needed. If
// additional determinsitic signatures are added, then the test harness will
// likely need to be extended.
string signature;
SignerFilter f(GlobalRNG(), *signer, new HexEncoder(new StringSink(signature)));
StringSource ss(GetDecodedDatum(v, "Message"), true, new Redirector(f));
if (GetDecodedDatum(v, "Signature") != signature)
SignalTestFailure();
return;
}
else if (test == "RandomSign")
{
SignalTestError();
assert(false); // TODO: implement
}
else
{
SignalTestError();
assert(false);
}
}
void TestSignatureScheme(TestData &v)
{
std::string name = GetRequiredDatum(v, "Name");
std::string test = GetRequiredDatum(v, "Test");
std::auto_ptr<PK_Signer> signer(ObjectFactoryRegistry<PK_Signer>::Registry().CreateObject(name.c_str()));
std::auto_ptr<PK_Verifier> verifier(ObjectFactoryRegistry<PK_Verifier>::Registry().CreateObject(name.c_str()));
TestDataNameValuePairs pairs(v);
std::string keyFormat = GetRequiredDatum(v, "KeyFormat");
if (keyFormat == "DER")
verifier->AccessMaterial().Load(StringStore(GetDecodedDatum(v, "PublicKey")).Ref());
else if (keyFormat == "Component")
verifier->AccessMaterial().AssignFrom(pairs);
if (test == "Verify" || test == "NotVerify")
{
VerifierFilter verifierFilter(*verifier, NULL, VerifierFilter::SIGNATURE_AT_BEGIN);
PutDecodedDatumInto(v, "Signature", verifierFilter);
PutDecodedDatumInto(v, "Message", verifierFilter);
verifierFilter.MessageEnd();
if (verifierFilter.GetLastResult() == (test == "NotVerify"))
SignalTestFailure();
}
else if (test == "PublicKeyValid")
{
if (!verifier->GetMaterial().Validate(GlobalRNG(), 3))
SignalTestFailure();
}
else
goto privateKeyTests;
return;
privateKeyTests:
if (keyFormat == "DER")
signer->AccessMaterial().Load(StringStore(GetDecodedDatum(v, "PrivateKey")).Ref());
else if (keyFormat == "Component")
signer->AccessMaterial().AssignFrom(pairs);
if (test == "KeyPairValidAndConsistent")
{
TestKeyPairValidAndConsistent(verifier->AccessMaterial(), signer->GetMaterial());
}
else if (test == "Sign")
{
SignerFilter f(GlobalRNG(), *signer, new HexEncoder(new FileSink(cout)));
StringSource ss(GetDecodedDatum(v, "Message"), true, new Redirector(f));
SignalTestFailure();
}
else if (test == "DeterministicSign")
{
SignalTestError();
assert(false); // TODO: implement
}
else if (test == "RandomSign")
{
SignalTestError();
assert(false); // TODO: implement
}
else if (test == "GenerateKey")
{
SignalTestError();
assert(false);
}
else
{
SignalTestError();
assert(false);
}
}
void FIPS140_SampleApplication()
{
if (!FIPS_140_2_ComplianceEnabled())
{
cerr << "FIPS 140-2 compliance was turned off at compile time.\n";
abort();
}
// check self test status
if (GetPowerUpSelfTestStatus() != POWER_UP_SELF_TEST_PASSED)
{
cerr << "Automatic power-up self test failed.\n";
abort();
}
cout << "0. Automatic power-up self test passed.\n";
// simulate a power-up self test error
SimulatePowerUpSelfTestFailure();
try
{
// trying to use a crypto algorithm after power-up self test error will result in an exception
AES::Encryption aes;
// should not be here
cerr << "Use of AES failed to cause an exception after power-up self test error.\n";
abort();
}
catch (SelfTestFailure &e)
{
cout << "1. Caught expected exception when simulating self test failure. Exception message follows: ";
cout << e.what() << endl;
}
// clear the self test error state and redo power-up self test
DoDllPowerUpSelfTest();
if (GetPowerUpSelfTestStatus() != POWER_UP_SELF_TEST_PASSED)
{
cerr << "Re-do power-up self test failed.\n";
abort();
}
cout << "2. Re-do power-up self test passed.\n";
// encrypt and decrypt
const byte key[] = {0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef, 0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef, 0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef};
const byte iv[] = {0x12,0x34,0x56,0x78,0x90,0xab,0xcd,0xef};
const byte plaintext[] = { // "Now is the time for all " without tailing 0
0x4e,0x6f,0x77,0x20,0x69,0x73,0x20,0x74,
0x68,0x65,0x20,0x74,0x69,0x6d,0x65,0x20,
0x66,0x6f,0x72,0x20,0x61,0x6c,0x6c,0x20};
byte ciphertext[24];
byte decrypted[24];
CFB_FIPS_Mode<DES_EDE3>::Encryption encryption_DES_EDE3_CFB;
encryption_DES_EDE3_CFB.SetKeyWithIV(key, sizeof(key), iv);
encryption_DES_EDE3_CFB.ProcessString(ciphertext, plaintext, 23);
CFB_FIPS_Mode<DES_EDE3>::Decryption decryption_DES_EDE3_CFB;
decryption_DES_EDE3_CFB.SetKeyWithIV(key, sizeof(key), iv);
decryption_DES_EDE3_CFB.ProcessString(decrypted, ciphertext, 24);
if (memcmp(plaintext, decrypted, 24) != 0)
{
cerr << "DES-EDE3-CFB Encryption/decryption failed.\n";
abort();
}
cout << "3. DES-EDE3-CFB Encryption/decryption succeeded.\n";
// hash
const byte message[] = {'a', 'b', 'c'};
const byte expectedDigest[] = {0xA9,0x99,0x3E,0x36,0x47,0x06,0x81,0x6A,0xBA,0x3E,0x25,0x71,0x78,0x50,0xC2,0x6C,0x9C,0xD0,0xD8,0x9D};
byte digest[20];
SHA1 sha;
sha.Update(message, 3);
sha.Final(digest);
if (memcmp(digest, expectedDigest, 20) != 0)
{
cerr << "SHA-1 hash failed.\n";
abort();
}
cout << "4. SHA-1 hash succeeded.\n";
// create auto-seeded X9.17 RNG object, if available
#ifdef OS_RNG_AVAILABLE
AutoSeededX917RNG<DES_EDE3> rng;
#else
// this is used to allow this function to compile on platforms that don't have auto-seeded RNGs
RandomNumberGenerator &rng(NullRNG());
#endif
// generate DSA key
DSA::PrivateKey dsaPrivateKey;
dsaPrivateKey.GenerateRandomWithKeySize(rng, 1024);
DSA::PublicKey dsaPublicKey;
dsaPublicKey.AssignFrom(dsaPrivateKey);
if (!dsaPrivateKey.Validate(rng, 3) || !dsaPublicKey.Validate(rng, 3))
{
cerr << "DSA key generation failed.\n";
abort();
}
cout << "5. DSA key generation succeeded.\n";
// encode DSA key
std::string encodedDsaPublicKey, encodedDsaPrivateKey;
dsaPublicKey.DEREncode(StringSink(encodedDsaPublicKey).Ref());
dsaPrivateKey.DEREncode(StringSink(encodedDsaPrivateKey).Ref());
// decode DSA key
DSA::PrivateKey decodedDsaPrivateKey;
decodedDsaPrivateKey.BERDecode(StringStore(encodedDsaPrivateKey).Ref());
DSA::PublicKey decodedDsaPublicKey;
decodedDsaPublicKey.BERDecode(StringStore(encodedDsaPublicKey).Ref());
if (!decodedDsaPrivateKey.Validate(rng, 3) || !decodedDsaPublicKey.Validate(rng, 3))
{
cerr << "DSA key encode/decode failed.\n";
abort();
}
cout << "6. DSA key encode/decode succeeded.\n";
// sign and verify
byte signature[40];
DSA::Signer signer(dsaPrivateKey);
assert(signer.SignatureLength() == 40);
signer.SignMessage(rng, message, 3, signature);
DSA::Verifier verifier(dsaPublicKey);
if (!verifier.VerifyMessage(message, 3, signature, sizeof(signature)))
{
cerr << "DSA signature and verification failed.\n";
abort();
}
cout << "7. DSA signature and verification succeeded.\n";
// try to verify an invalid signature
signature[0] ^= 1;
if (verifier.VerifyMessage(message, 3, signature, sizeof(signature)))
{
cerr << "DSA signature verification failed to detect bad signature.\n";
abort();
}
cout << "8. DSA signature verification successfully detected bad signature.\n";
// try to use an invalid key length
try
{
ECB_Mode<DES_EDE3>::Encryption encryption_DES_EDE3_ECB;
encryption_DES_EDE3_ECB.SetKey(key, 5);
// should not be here
cerr << "DES-EDE3 implementation did not detect use of invalid key length.\n";
abort();
}
catch (InvalidArgument &e)
{
cout << "9. Caught expected exception when using invalid key length. Exception message follows: ";
cout << e.what() << endl;
}
cout << "\nFIPS 140-2 Sample Application completed normally.\n";
}
void code_heap::verify_all_blocks_set()
{
all_blocks_set_verifier verifier(&all_blocks);
allocator->iterate(verifier);
}
void MethodInfo::verify(Toplevel *toplevel, AbcEnv* abc_env)
{
AvmAssert(declaringTraits()->isResolved());
resolveSignature(toplevel);
AvmCore* core = this->pool()->core;
if (isNative())
{
union {
GprMethodProc implGPR;
AvmThunkNativeThunker thunker;
AvmThunkNativeThunkerN thunkerN;
} u;
#ifdef DEBUGGER
if (core->debugger())
{
MethodSignaturep ms = getMethodSignature();
if (ms->returnTraitsBT() == BUILTIN_number)
u.thunkerN = MethodInfo::debugEnterExitWrapperN;
else
u.thunker = MethodInfo::debugEnterExitWrapper32;
}
else
#endif
{
u.thunker = this->thunker();
}
this->setNativeImpl(u.implGPR);
}
else
{
#ifdef DEBUGGER
// just a fake CallStackNode here, so that if we throw a verify error,
// we get a stack trace with the method being verified as its top entry.
CallStackNode callStackNode(this);
#endif /* DEBUGGER */
PERFM_NTPROF("verify-ticks");
CodeWriter* coder = NULL;
Verifier verifier(this, toplevel, abc_env);
/*
These "buf" declarations are an unfortunate but expedient hack:
the existing CodeWriter classes (eg CodegenLIR, etc) have historically
always been stack-allocated, thus they have no WB protection on member
fields. Recent changes were made to allow for explicit cleanup() of them
in the event of exception, but there was a latent bug waiting to happen:
the actual automatic var was going out of scope, but still being referenced
(via the 'coder' pointer) in the exception handler, but the area being
pointed to may or may not still be valid. The ideal fix for this would
simply be to heap-allocate the CodeWriters, but that would require going
thru the existing code carefully and inserting WB where appropriate.
Instead, this "expedient" hack uses placement new to ensure the memory
stays valid into the exception handler.
Note: the lack of a call to the dtor of the CodeWriter(s) is not an oversight.
Calling cleanup() on coder is equivalent to running the dtor for all
of the CodeWriters here.
Note: allocated using arrays of intptr_t (rather than char) to ensure alignment is acceptable.
*/
#define MAKE_BUF(name, type) \
intptr_t name[(sizeof(type)+sizeof(intptr_t)-1)/sizeof(intptr_t)]
#if defined FEATURE_NANOJIT
MAKE_BUF(jit_buf, CodegenLIR);
#if defined AVMPLUS_WORD_CODE
MAKE_BUF(teeWriter_buf, TeeWriter);
#endif
#ifdef FEATURE_CFGWRITER
MAKE_BUF(cfg_buf, CFGWriter);
#endif
#endif
#if defined AVMPLUS_WORD_CODE
MAKE_BUF(translator_buf, WordcodeEmitter);
#else
MAKE_BUF(stubWriter_buf, CodeWriter);
#endif
TRY(core, kCatchAction_Rethrow)
{
#if defined FEATURE_NANOJIT
if ((core->IsJITEnabled()) && !suggestInterp())
{
PERFM_NTPROF("verify & IR gen");
// note placement-new usage!
CodegenLIR* jit = new(jit_buf) CodegenLIR(this);
#if defined AVMPLUS_WORD_CODE
WordcodeEmitter* translator = new(translator_buf) WordcodeEmitter(this, toplevel);
TeeWriter* teeWriter = new(teeWriter_buf) TeeWriter(translator, jit);
coder = teeWriter;
#else
coder = jit;
#endif
#ifdef FEATURE_CFGWRITER
// analyze code and generate LIR
CFGWriter* cfg = new(cfg_buf) CFGWriter(this, coder);
coder = cfg;
#endif
verifier.verify(coder);
PERFM_TPROF_END();
if (!jit->overflow) {
// assembler LIR into native code
jit->emitMD();
}
// the MD buffer can overflow so we need to re-iterate
// over the whole thing, since we aren't yet robust enough
// to just rebuild the MD code.
// mark it as interpreted and try to limp along
if (jit->overflow) {
if (core->JITMustSucceed()) {
Exception* e = new (core->GetGC()) Exception(core, core->newStringLatin1("JIT failed")->atom());
e->flags |= Exception::EXIT_EXCEPTION;
core->throwException(e);
}
setInterpImpl();
}
#ifdef AVMPLUS_WORD_CODE
else {
if (_abc.word_code.translated_code)
{
set_word_code(core->GetGC(), NULL);
}
if (_abc.word_code.exceptions)
{
_abc.word_code.exceptions = NULL;
}
}
#endif
}
else
{
// NOTE copied below
#if defined AVMPLUS_WORD_CODE
WordcodeEmitter* translator = new(translator_buf) WordcodeEmitter(this, toplevel);
coder = translator;
#else
CodeWriter* stubWriter = new(stubWriter_buf) CodeWriter();
coder = stubWriter;
#endif
verifier.verify(coder); // pass2 dataflow
setInterpImpl();
// NOTE end copy
}
#else // FEATURE_NANOJIT
// NOTE copied from above
#if defined AVMPLUS_WORD_CODE
WordcodeEmitter* translator = new(translator_buf) WordcodeEmitter(this, toplevel);
coder = translator;
#else
CodeWriter* stubWriter = new(stubWriter_buf) CodeWriter();
coder = stubWriter;
#endif
verifier.verify(coder); // pass2 dataflow
setInterpImpl();
// NOTE end copy
#endif // FEATURE_NANOJIT
if (coder)
{
coder->cleanup();
coder = NULL;
}
}
CATCH (Exception *exception)
{
// clean up verifier
verifier.~Verifier();
// call cleanup all the way down the chain
// each stage calls cleanup on the next one
if (coder)
coder->cleanup();
// re-throw exception
core->throwException(exception);
}
END_CATCH
END_TRY
PERFM_TPROF_END();
}
