void TestAES256CBC(const std::string &hexkey, const std::string &hexiv, bool pad, const std::string &hexin, const std::string &hexout)
{
std::vector<unsigned char> key = ParseHex(hexkey);
std::vector<unsigned char> iv = ParseHex(hexiv);
std::vector<unsigned char> in = ParseHex(hexin);
std::vector<unsigned char> correctout = ParseHex(hexout);
std::vector<unsigned char> realout(in.size() + AES_BLOCKSIZE);
// Encrypt the plaintext and verify that it equals the cipher
AES256CBCEncrypt enc(key.data(), iv.data(), pad);
int size = enc.Encrypt(in.data(), in.size(), realout.data());
realout.resize(size);
BOOST_CHECK(realout.size() == correctout.size());
BOOST_CHECK_MESSAGE(realout == correctout, HexStr(realout) + std::string(" != ") + hexout);
// Decrypt the cipher and verify that it equals the plaintext
std::vector<unsigned char> decrypted(correctout.size());
AES256CBCDecrypt dec(key.data(), iv.data(), pad);
size = dec.Decrypt(correctout.data(), correctout.size(), decrypted.data());
decrypted.resize(size);
BOOST_CHECK(decrypted.size() == in.size());
BOOST_CHECK_MESSAGE(decrypted == in, HexStr(decrypted) + std::string(" != ") + hexin);
// Encrypt and re-decrypt substrings of the plaintext and verify that they equal each-other
for(std::vector<unsigned char>::iterator i(in.begin()); i != in.end(); ++i)
{
std::vector<unsigned char> sub(i, in.end());
std::vector<unsigned char> subout(sub.size() + AES_BLOCKSIZE);
int _size = enc.Encrypt(sub.data(), sub.size(), subout.data());
if (_size != 0)
{
subout.resize(_size);
std::vector<unsigned char> subdecrypted(subout.size());
_size = dec.Decrypt(subout.data(), subout.size(), subdecrypted.data());
subdecrypted.resize(_size);
BOOST_CHECK(decrypted.size() == in.size());
BOOST_CHECK_MESSAGE(subdecrypted == sub, HexStr(subdecrypted) + std::string(" != ") + HexStr(sub));
}
}
}
/*static*/ bool SkBitmapHasher::ComputeDigestInternal(const SkBitmap& bitmap,
SkHashDigest *result) {
size_t pixelBufferSize = bitmap.width() * bitmap.height() * 4;
size_t totalBufferSize = pixelBufferSize + 2 * sizeof(uint32_t);
SkAutoMalloc bufferManager(totalBufferSize);
char *bufferStart = static_cast<char *>(bufferManager.get());
SkMemoryWStream out(bufferStart, totalBufferSize);
// start with the x/y dimensions
write_int_to_buffer(SkToU32(bitmap.width()), &out);
write_int_to_buffer(SkToU32(bitmap.height()), &out);
// add all the pixel data
SkAutoTDelete<SkImageEncoder> enc(CreateARGBImageEncoder());
if (!enc->encodeStream(&out, bitmap, SkImageEncoder::kDefaultQuality)) {
return false;
}
*result = SkCityHash::Compute64(bufferStart, totalBufferSize);
return true;
}
int main(int argc, char const *argv[])
{
if(argc < 3)
{
cout << "Usage: encryptor InputFileName OutputFileName" << endl << "Terminating..." << endl;
return 0;
}
//Text hiding method by guestgulkan on cplusplus forum
HANDLE hStdin = GetStdHandle(STD_INPUT_HANDLE);
DWORD mode = 0;
GetConsoleMode(hStdin, &mode);
SetConsoleMode(hStdin, mode & (~ENABLE_ECHO_INPUT));
string key;
string input;
string output;
FileHandler inputFile(true);
if(!inputFile.setFileName(argv[1]))
{
return 0;
}
FileHandler outputFile(false);
outputFile.setFileName(argv[2]);
cout << "Please enter your session key:" << endl;
getline(cin, key);
input = *inputFile.get();
Encryptor enc(key, input);
output = enc.crypt();
outputFile.write(output);
return 0;
}
int main(int argc, char **argv) {
if (argc > 1 && strcmp(argv[1], "-n") == 0) {
cpu_force_no_simd( );
}
/* Read 1080p UYVY422 frames on stdin. Dump M-JPEG stream on stdout. */
RawFrame frame(1920, 1080, RawFrame::CbYCrY8422);
Mjpeg422Encoder enc(1920, 1080);
Mjpeg422Decoder dec(1920, 1080);
ssize_t ret;
std::string comment;
for (;;) {
ret = frame.read_from_fd(STDIN_FILENO);
if (ret < 0) {
perror("frame.read_from_fd");
exit(1);
} else if (ret == 0) {
break;
} else {
enc.set_comment("Hello JPEG world!");
enc.encode(&frame);
RawFrame *out = dec.decode(enc.get_data( ), enc.get_data_size( ));
comment = " ";
dec.get_comment(comment);
fprintf(stderr, "comment: %s\n", comment.c_str( ));
if (out->write_to_fd(STDOUT_FILENO) < 0) {
perror("write_to_fd");
break;
}
delete out;
}
}
}
int main () {
enable_uart(25);
initENC();
initservos(625,ON,ON);
initPWM10();
initADC();
initcommsunit();
SetDir('B',0,'O');
SetDir('B',1,'O');
SetDir('B',2,'O');
SetDir('B',3,'O');
SetDir('B',4,'I');
SetDir('B',5,'I');
uprintf("Type INIT <enter> to begin\r");
while(strncmp(dumb,"INIT",4) == 1) {
uscanf(dumb,10,ON);
}
//uprintf("AVR Initalized\r");
op = 1;
while (op == 1) {
uscanf(ReceiveStr,50,ON);
if(strncmp(ReceiveStr,"Forward",7) == 0) {Forward();}
if(strncmp(ReceiveStr,"Backward",8) == 0) {Backward();}
if(strncmp(ReceiveStr,"SpinL",5) == 0) {SpinL();}
if(strncmp(ReceiveStr,"SpinR",5) == 0) {SpinR();}
if(strncmp(ReceiveStr,"TurnL",5) == 0) {TurnL();}
if(strncmp(ReceiveStr,"TurnR",5) == 0) {TurnR();}
if(strncmp(ReceiveStr,"Stop",4) == 0) {Stop();}
if(strncmp(ReceiveStr,"Tservop",7) == 0) {tservop();}
if(strncmp(ReceiveStr,"Pservop",7) == 0) {pservop();}
if(strncmp(ReceiveStr,"LGH",3) == 0) {lgh();}
if(strncmp(ReceiveStr,"SNR",3) == 0) {snr();}
if(strncmp(ReceiveStr,"BMP",3) == 0) {bmp();}
if(strncmp(ReceiveStr,"ENC",3) == 0) {enc();}
if(strncmp(ReceiveStr,"DISABLE",7) == 0) {op = 0;}
}
uprintf("Disaled\r");
while (1) {}
}
bool Use_StreamCipher(_Stream_Cipher_Parameters_){
if( key == NULL ||
plain == NULL ||
cipher == NULL ||
key_len == 0 ||
key_len != AlgType::DEFAULT_KEYLENGTH ||
plain_len == 0 ||
cipher_len == 0 ||
iv == NULL ||
iv_len == 0
) return false;
if(direct){
AlgType::Encryption enc(key,key_len,iv);
enc.ProcessData(cipher,plain,cipher_len);
}else{
AlgType::Decryption dec(key,key_len,iv);
dec.ProcessData(plain,cipher,plain_len);
}
return true;
};
const bool Decode(const std::string &encoded, std::vector<unsigned char> &data)
{
std::string::size_type pos=0;
unsigned char byte;
int bytepart=0;
std::string enc(encoded);
// make upper case lower case
for(std::string::iterator i=enc.begin(); i!=enc.end(); i++)
{
if((*i)>=65 && (*i)<71)
{
(*i)=(*i)+32;
}
}
data.reserve(enc.size()/2);
pos=enc.find_first_of(hexchars);
while(pos!=std::string::npos)
{
if(bytepart==0)
{
byte=(hexchars.find(enc[pos]) << 4) & 0xF0;
bytepart=1;
}
else
{
byte|=hexchars.find(enc[pos]) & 0x0F;
data.push_back(byte);
bytepart=0;
}
pos=enc.find_first_of(hexchars,pos+1);
}
return true;
}
Test::Result run_one_test(const std::string& algo, const VarMap& vars) override
{
const std::vector<uint8_t> key = get_req_bin(vars, "Key");
const std::vector<uint8_t> nonce = get_opt_bin(vars, "Nonce");
const std::vector<uint8_t> input = get_req_bin(vars, "In");
const std::vector<uint8_t> expected = get_req_bin(vars, "Out");
Test::Result result(algo);
std::unique_ptr<Botan::Cipher_Mode> enc(Botan::get_cipher_mode(algo, Botan::ENCRYPTION));
std::unique_ptr<Botan::Cipher_Mode> dec(Botan::get_cipher_mode(algo, Botan::DECRYPTION));
if(!enc || !dec)
{
result.note_missing(algo);
return result;
}
result.test_eq("mode not authenticated", enc->authenticated(), false);
enc->set_key(key);
enc->start(nonce);
Botan::secure_vector<uint8_t> buf(input.begin(), input.end());
// TODO: should first update if possible
enc->finish(buf);
result.test_eq("encrypt", buf, expected);
buf.assign(expected.begin(), expected.end());
dec->set_key(key);
dec->start(nonce);
dec->finish(buf);
result.test_eq("decrypt", buf, input);
return result;
}
static void encodeArray(it const ita, it const ite, std::ostream & out, std::iostream & indexout)
{
std::sort(ita,ite);
this_type enc(out,indexout);
it itl = ita;
while ( itl != ite )
{
it ith = itl;
while ( ith != ite && *ith == *itl )
++ith;
enc.encode(*itl,ith-itl);
itl = ith;
}
enc.term();
out.flush();
}
TEST(Dict, Compress) {
const char* dictStr = "quickfoxdogjumps";
DictFlex dict;
dict.setDict( (const uint8_t*) dictStr, strlen(dictStr) );
const char* toEncode = "The quick brown fox jumps over the lazy dog123";
DictEncStream stream(1024*1024);
DictEncoder enc(&dict);
enc.append( (const uint8_t*) toEncode, strlen(toEncode), stream);
dumpHex(std::cout, stream.data, stream.getNumBytes());
// check
ASSERT_EQ(42, stream.getNumBytes());
ASSERT_EQ(0xFF, stream.data[4]);
ASSERT_EQ(0x00, stream.data[5]);
ASSERT_EQ(0x05, stream.data[6]);
ASSERT_EQ(0xFF, stream.data[14]);
ASSERT_EQ(0x00, stream.data[15]);
ASSERT_EQ(0x53, stream.data[16]); // (offset 5) * 16 + (length 3)
ASSERT_EQ(0xFF, stream.data[18]);
ASSERT_EQ(0x00, stream.data[19]);
ASSERT_EQ(0xB5, stream.data[20]); // (offset 11) * 16 + (length 5)
ASSERT_EQ(0xFF, stream.data[36]);
ASSERT_EQ(0x00, stream.data[37]);
ASSERT_EQ(0x83, stream.data[38]); // (offset 8) * 16 + (length 3)
}
bool TestHKDF(KeyDerivationFunction &kdf, const HKDF_TestTuple *testSet, unsigned int testSetSize)
{
bool pass = true;
for (unsigned int i=0; i<testSetSize; i++)
{
const HKDF_TestTuple &tuple = testSet[i];
std::string secret, salt, info, expected;
StringSource(tuple.hexSecret, true, new HexDecoder(new StringSink(secret)));
StringSource(tuple.hexSalt ? tuple.hexSalt : "", true, new HexDecoder(new StringSink(salt)));
StringSource(tuple.hexInfo ? tuple.hexInfo : "", true, new HexDecoder(new StringSink(info)));
StringSource(tuple.hexExpected, true, new HexDecoder(new StringSink(expected)));
SecByteBlock derived(expected.size());
unsigned int ret = kdf.DeriveKey(derived, derived.size(),
reinterpret_cast<const unsigned char*>(secret.data()), secret.size(),
(tuple.hexSalt ? reinterpret_cast<const unsigned char*>(salt.data()) : NULL), salt.size(),
(tuple.hexInfo ? reinterpret_cast<const unsigned char*>(info.data()) : NULL), info.size());
bool fail = !VerifyBufsEqual(derived, reinterpret_cast<const unsigned char*>(expected.data()), derived.size());
pass = pass && (ret == tuple.len) && !fail;
HexEncoder enc(new FileSink(std::cout));
std::cout << (fail ? "FAILED " : "passed ");
std::cout << " " << tuple.hexSecret << " ";
std::cout << (tuple.hexSalt ? (strlen(tuple.hexSalt) ? tuple.hexSalt : "<0-LEN SALT>") : "<NO SALT>");
std::cout << " ";
std::cout << (tuple.hexInfo ? (strlen(tuple.hexInfo) ? tuple.hexInfo : "<0-LEN INFO>") : "<NO INFO>");
std::cout << " ";
enc.Put(derived, derived.size());
std::cout << std::endl;
}
return pass;
}
int main (){
BYTE plainText[MAX_BLK_CNT*(BLOCK_SIZE/8)];
BYTE *tmp;
BYTE *ret_tmp;
int i = 0;
printf("*********************************************************************\n");
printf("*********************************************************************\n");
srand((unsigned) time(NULL));
key_and_cipher_init(&ki,&ci);
printf("byteCnt: %d\n",byteCnt);
printf("-----------------------------------------------------------------------------\n");
for (i=0;i<25;i++)
plainText[i]=(BYTE)((rand()%94)+32);
tmp=enc(plainText,25);
ret_tmp=dec(tmp,25);
free(tmp);
free(ret_tmp);
/*printf("\n\n");printf("-----------------------------------------------------------------------------\n");
int new_byteCnt=28;
for (i=0;i<new_byteCnt;i++)
plainText[i]=(BYTE)('a');
tmp=enc(plainText,new_byteCnt);
ret_tmp=dec(tmp);
free(tmp);
free(ret_tmp);
*/
return 1;
}
int main()
{
typedef CommData::InvokeOnRecvSound Enc;
typedef RecvSoundEvent Evt;
typedef EncoderTest<Enc, Evt> Test;
RawSoundHeader h(2, 16000, 16, RAW_SOUND_LITTLE_ENDIAN); //TODO: Magic number
RawSound sound(h, 50000); //TODO: Magic number
Enc enc(1.000, "me", "you", sound);
Evt evt;
Test test;
if (test(enc, evt)) {
printf("time : %f\n", evt.time());
printf("callter : %s\n", evt.getCaller());
RawSound *s = evt.getRawSound();
RawSoundHeader &h = s->getHeader();
printf("channel num : %d\n", h.getChannelNum());
printf("sampling rate : %d\n", h.getSamplingRate());
printf("bits per sample : %d\n", h.getBitPerSample());
}
return 0;
}
static std::vector<std::string> encodeArray(it const gita, it const gite, std::string const & fnprefix, uint64_t const tparts, uint64_t const blocksize = 64*1024)
{
std::sort(gita,gite);
uint64_t const partsize = (gite-gita+tparts-1)/(tparts);
std::vector<uint64_t> partstarts;
it gitc = gita;
while ( gitc != gite )
{
while ( gitc != gita && gitc != gite && (*(gitc-1)) == *gitc )
++gitc;
assert ( gitc == gita || gitc == gite || ((*(gitc-1)) != (*gitc)) );
if ( gitc != gite )
partstarts.push_back(gitc-gita);
gitc += std::min(partsize,static_cast<uint64_t>(gite-gitc));
}
uint64_t const parts = partstarts.size();
std::vector<std::string> partfn(parts);
partstarts.push_back(gite-gita);
for ( uint64_t p = 0; p < parts; ++p )
{
std::ostringstream fnostr;
fnostr << fnprefix << "_" << std::setw(6) << std::setfill('0') << p;
std::string const fn = fnostr.str();
partfn[p] = fn;
std::string const indexfn = fn+".idx";
libmaus2::util::TempFileRemovalContainer::addTempFile(indexfn);
libmaus2::aio::OutputStreamInstance COS(fn);
libmaus2::aio::InputOutputStream::unique_ptr_type Pindexstr(
libmaus2::aio::InputOutputStreamFactoryContainer::constructUnique(
indexfn,std::ios::in|std::ios::out|std::ios::trunc|std::ios::binary
)
);
// libmaus2::aio::CheckedInputOutputStream indexstr(indexfn);
this_type enc(
COS,*Pindexstr,
(p==0)?(-1):gita[partstarts[p]-1],
blocksize
);
it itl = gita + partstarts[p];
it ite = gita + partstarts[p+1];
while ( itl != ite )
{
it ith = itl;
while ( ith != ite && *ith == *itl )
++ith;
enc.encode(*itl,ith-itl);
itl = ith;
}
enc.term();
COS.flush();
Pindexstr.reset();
libmaus2::aio::FileRemoval::removeFile(indexfn);
}
return partfn;
}
// confirm certificate signature
bool CertDecoder::ConfirmSignature(Source& pub)
{
HashType ht;
mySTL::auto_ptr<HASH> hasher;
if (signatureOID_ == MD5wRSA) {
hasher.reset(NEW_TC MD5);
ht = MD5h;
}
else if (signatureOID_ == MD2wRSA) {
hasher.reset(NEW_TC MD2);
ht = MD2h;
}
else if (signatureOID_ == SHAwRSA || signatureOID_ == SHAwDSA) {
hasher.reset(NEW_TC SHA);
ht = SHAh;
}
else if (signatureOID_ == SHA256wRSA || signatureOID_ == SHA256wDSA) {
hasher.reset(NEW_TC SHA256);
ht = SHA256h;
}
#ifdef WORD64_AVAILABLE
else if (signatureOID_ == SHA384wRSA) {
hasher.reset(NEW_TC SHA384);
ht = SHA384h;
}
else if (signatureOID_ == SHA512wRSA) {
hasher.reset(NEW_TC SHA512);
ht = SHA512h;
}
#endif
else {
source_.SetError(UNKOWN_SIG_E);
return false;
}
byte digest[MAX_SHA2_DIGEST_SIZE]; // largest size
hasher->Update(source_.get_buffer() + certBegin_, sigIndex_ - certBegin_);
hasher->Final(digest);
if (keyOID_ == RSAk) {
// put in ASN.1 signature format
Source build;
Signature_Encoder(digest, hasher->getDigestSize(), ht, build);
RSA_PublicKey pubKey(pub);
RSAES_Encryptor enc(pubKey);
if (pubKey.FixedCiphertextLength() != sigLength_) {
source_.SetError(SIG_LEN_E);
return false;
}
return enc.SSL_Verify(build.get_buffer(), build.size(), signature_);
}
else { // DSA
// extract r and s from sequence
byte seqDecoded[DSA_SIG_SZ];
memset(seqDecoded, 0, sizeof(seqDecoded));
DecodeDSA_Signature(seqDecoded, signature_, sigLength_);
DSA_PublicKey pubKey(pub);
DSA_Verifier ver(pubKey);
return ver.Verify(digest, seqDecoded);
}
}
static krb5_error_code
krb5int_aes_encrypt_iov(const krb5_keyblock *key,
const krb5_data *ivec,
krb5_crypto_iov *data,
size_t num_data)
{
aes_ctx ctx;
char tmp[BLOCK_SIZE], tmp2[BLOCK_SIZE];
int nblocks = 0, blockno;
size_t input_length, i;
struct iov_block_state input_pos, output_pos;
if (aes_enc_key(key->contents, key->length, &ctx) != aes_good)
abort();
if (ivec != NULL)
memcpy(tmp, ivec->data, BLOCK_SIZE);
else
memset(tmp, 0, BLOCK_SIZE);
for (i = 0, input_length = 0; i < num_data; i++) {
krb5_crypto_iov *iov = &data[i];
if (ENCRYPT_IOV(iov))
input_length += iov->data.length;
}
IOV_BLOCK_STATE_INIT(&input_pos);
IOV_BLOCK_STATE_INIT(&output_pos);
nblocks = (input_length + BLOCK_SIZE - 1) / BLOCK_SIZE;
if (nblocks == 1) {
krb5int_c_iov_get_block((unsigned char *)tmp, BLOCK_SIZE,
data, num_data, &input_pos);
enc(tmp2, tmp, &ctx);
krb5int_c_iov_put_block(data, num_data, (unsigned char *)tmp2,
BLOCK_SIZE, &output_pos);
} else if (nblocks > 1) {
char blockN2[BLOCK_SIZE]; /* second last */
char blockN1[BLOCK_SIZE]; /* last block */
for (blockno = 0; blockno < nblocks - 2; blockno++) {
char blockN[BLOCK_SIZE];
krb5int_c_iov_get_block((unsigned char *)blockN, BLOCK_SIZE, data, num_data, &input_pos);
xorblock(tmp, blockN);
enc(tmp2, tmp, &ctx);
krb5int_c_iov_put_block(data, num_data, (unsigned char *)tmp2, BLOCK_SIZE, &output_pos);
/* Set up for next block. */
memcpy(tmp, tmp2, BLOCK_SIZE);
}
/* Do final CTS step for last two blocks (the second of which
may or may not be incomplete). */
/* First, get the last two blocks */
memset(blockN1, 0, sizeof(blockN1)); /* pad last block with zeros */
krb5int_c_iov_get_block((unsigned char *)blockN2, BLOCK_SIZE, data, num_data, &input_pos);
krb5int_c_iov_get_block((unsigned char *)blockN1, BLOCK_SIZE, data, num_data, &input_pos);
/* Encrypt second last block */
xorblock(tmp, blockN2);
enc(tmp2, tmp, &ctx);
memcpy(blockN2, tmp2, BLOCK_SIZE); /* blockN2 now contains first block */
memcpy(tmp, tmp2, BLOCK_SIZE);
/* Encrypt last block */
xorblock(tmp, blockN1);
enc(tmp2, tmp, &ctx);
memcpy(blockN1, tmp2, BLOCK_SIZE);
/* Put the last two blocks back into the iovec (reverse order) */
krb5int_c_iov_put_block(data, num_data, (unsigned char *)blockN1, BLOCK_SIZE, &output_pos);
krb5int_c_iov_put_block(data, num_data, (unsigned char *)blockN2, BLOCK_SIZE, &output_pos);
if (ivec != NULL)
memcpy(ivec->data, blockN1, BLOCK_SIZE);
}
return 0;
}
int main(int argc,char** argv){
const char* fname;
if(argc==2)
fname=argv[1];
else if(argc==1)
fname="/dev/stdout";
else
usage(1);
mwg::bio::ftape tape(fname,"rb");
if(!tape){
std::fprintf(stderr,"failed to open the file %s.\n",fname);
usage(1);
}
mwg::bio::tape_head<mwg::bio::ftape,mwg::bio::little_endian_flag> head(tape);
struct gzip_member_header{
mwg::byte id1;
mwg::byte id2;
mwg::byte cm;
mwg::byte flg;
mwg::u4t mtime;
mwg::byte xfl;
mwg::byte os;
} header={0};
head.read(header.id1 );
head.read(header.id2 );
head.read(header.cm );
head.read(header.flg );
head.read(header.mtime);
head.read(header.xfl );
head.read(header.os );
//mwg_assert(c1==31&&c2==139,"c1=%02x c2=%02x",c1,c2);
if(!(header.id1==31&&header.id2==139)){
std::fprintf(stderr,"gzcut: invalid ID1/ID2 %d/%d\n",header.id1,header.id2);
std::exit(1);
}
if(header.cm!=8){
std::fprintf(stderr,"gzcut: unrecognized compression method %d\n",header.cm);
std::exit(1);
}
if(header.flg&0xE0){
std::fprintf(stderr,"gzcut: unrecognized flag bits 0x%02X\n",header.flg&0xE0);
std::exit(1);
}
if(!(header.xfl==2||header.xfl==4||header.xfl==0)){
std::fprintf(stderr,"gzcut: unrecognized compression flag bits combination: 0x%02X\n",header.xfl);
std::exit(1);
}
enum{
FTEXT =0x01,
FHCRC =0x02,
FEXTRA =0x04,
FNAME =0x08,
FCOMMENT=0x10,
};
if(header.flg&FEXTRA){
mwg::u4t xlen;
head.read(xlen);
head.seek(xlen,SEEK_CUR);
}
if(header.flg&FNAME){
mwg::byte d=0;
std::fprintf(stderr,"gzcut: filename: ");
while(head.read(d)&&d!=0)putc(d,stderr);
putc('\n',stderr);
}
if(header.flg&FCOMMENT){
mwg::byte d=0;
std::fprintf(stderr,"gzcut: comment: ");
while(head.read(d)&&d!=0)putc(d,stderr);
putc('\n',stderr);
}
if(header.flg&FHCRC){
mwg::u2t crc16=0;
head.read(crc16);
std::fprintf(stderr,"gzcut: crc16: 0x%04X\n",crc16);
}
mwg::i8t csize=0;
{
mwg::i8t cur=head.tell();
auto mark=head.mark();
head.seek(-8,SEEK_END);
csize=head.tell()-cur;
mwg::u4t crc32;
mwg::u4t isize;
head.read(crc32);
head.read(isize);
std::fprintf(stderr,"gzcut: crc32: 0x%04X\n",crc32);
std::fprintf(stderr,"gzcut: compressed size: %lld\n",(long long)csize);
std::fprintf(stderr,"gzcut: original size: %lld mod 2^32\n",(long long)isize);
}
{
a85encoder enc(stdout);
mwg::byte b;
for(mwg::i8t i=0;i<csize&&head.read(b);i++)
enc.consume(b);
}
return 0;
}
// generate KeyA pair, return public key as ASCII
LPSTR __cdecl cpp_init_keya(HANDLE context, int features) {
pCNTX ptr = get_context_on_id(context); if(!ptr) return NULL;
pSIMDATA p = (pSIMDATA) cpp_alloc_pdata(ptr);
int send_features = FEATURES;
if(p->KeyP) send_features |= FEATURES_PSK;
SAFE_DELETE(p->dh);
if(features & FEATURES_NEWPG) {
Integer p0("0x865734026113B4DF0082CED84C197718516088FBDA406CFDFD7F033694E11E46F01C8F01E0E5AE6B09F6284691C7DD30A5BA8A74BA4B780198624B84BC8DAF6E0DFF874C0440ABB5C043C82E9E9C9E6F1A470B6A2A6BCEAC9460C43B1BB1331DF0FFD898DB74D22E8A71DB2659F1B0F52F337718D233DED611DA25AEAA90F3BE0C42FA9E541D0487DF58A77E2F44D295AD0C54C369CE260C969CA12F690EAAFAEEF8676C631AF29A3DE3389D3000B94EFA775E31FCA879AEB00A4D05EEF50D4C084A049EB12EF4CDFBD48E36B29CEAF8978D535D6C70BB274D1FEA02ABD521D2EF482A76326C17AF597FCB9B8BF37D9110E22AB0746D6A9779DF5133822E3F15");
Integer q0("0xF1515160E1BFC7636338C13AD5BA775318E287147A1F96B73CF0FB4D97EFFB9D1FCDCF31AB9D92C4F49C9F8D50F06E697D2313E2EBAC7781312A51F458D66FFC687960CAA86BDF150A36ED53D79FBDB4F501FD25E37C181B45F9555D7F1C6124CAB29A822AD1E7BF5DA93C2FDB12A61919B5E5359793CBB16E71516919040A7F");
Integer g0("0x434158F2FF2CF667E3CC1A707770DDE7B56048F6C5005473C6DC4A5E3FC490667F2908C44F9ADC2071EB8A8A1EC6AD6901CDAAAFE806626E3F4C5E69D4FCBF9DF1B67D574DC61C687C4BEF3ACF77A7256752F4D3A7EAEEE5874ED4912AB10C5B122A24E698B14CAC3E0FD006E0DB02714E028AECCA25BAB9DDCA2CF6405E862B403C61BC381D64B46BD96D3FEFBE22B7497FCBDA2B49C840C1B2853502A5216B036F83D2EAD8F835B603FC5BA1EFB816C7634915B1D43963FDD1B1ED626F48CCF8F152392E4693D38C566016708FA9E9598AECF95A8B067212669247552418E538A706564F855D3D5D50717D356259A20D8FD0C6B2A9FCC045D3F7AED1E857C5");
p->dh = new DH(p0,q0,g0);
}
else {
Integer p0("0xD494AAFBCD2EAC6A36DB8E7DD4A2A64512A5BBB15B9BFB581C7C1CAFB647D4612973C3770C2166D75EEA695F67EA8261557591DB78BCF5A886AA5294F3AEE4D25B57C8EE8C7FE8DBF70C132CD7FFCB6F89426F807F552C5DAE2FB1F329E340094E4B30D8EF6265AB4D350E9837B151C86AC524DE4E1FC04746C668BE318275E420D51AEDDFBDF887D435CDEEF6AC81293DB45287132F8236A43AD8F4D6642D7CA6732DA06A1DE008259008C9D74403B68ADAC788CF8AB5BEFFC310DCCCD32901D1F290E5B7A993D2CF6A652AF81B6DA0FD2E70678D1AE086150E41444522F20621195AD2A1F0975652B4AF7DE5261A9FD46B9EA8B443641F3BBA695B9B020103");
Integer g0("0x12A567BC9ABCDEF1234567823BCDEF1E");
p->dh = new DH(p0,g0);
}
BYTE priv1[KEYSIZE]; // private key of 2048 bit
BYTE publ1[KEYSIZE+2]; // public key of 2048 bit + faetures field
memset(priv1,0,sizeof(priv1));
memset(publ1,0,sizeof(publ1));
AutoSeededRandomPool autorng;
p->dh->GenerateKeyPair(autorng, priv1, publ1);
SAFE_FREE(p->PubA);
p->PubA = (PBYTE) malloc(KEYSIZE);
memcpy(p->PubA,publ1,KEYSIZE);
SAFE_FREE(p->KeyA);
p->KeyA = (PBYTE) malloc(KEYSIZE);
memcpy(p->KeyA,priv1,KEYSIZE);
if(p->KeyP) {
// encrypt PUBLIC use PSK
string ciphered;
CFB_Mode<AES>::Encryption enc(p->KeyP,Tiger::DIGESTSIZE,IV);
StreamTransformationFilter cbcEncryptor(enc,new StringSink(ciphered));
cbcEncryptor.Put(publ1,KEYSIZE);
cbcEncryptor.MessageEnd();
memcpy(publ1,ciphered.data(),ciphered.length());
#if defined(_DEBUG) || defined(NETLIB_LOG)
Sent_NetLog("cpp_init_keya: %d %d",KEYSIZE,ciphered.length());
#endif
}
memcpy((PVOID)&publ1[KEYSIZE],(PVOID)&send_features,2);
SAFE_FREE(ptr->tmp);
if(ptr->mode & MODE_BASE64 || features & FEATURES_NEWPG)
ptr->tmp = base64encode((LPSTR)&publ1,KEYSIZE+2);
else
ptr->tmp = base16encode((LPSTR)&publ1,KEYSIZE+2);
return ptr->tmp;
}
Test::Result run_one_test(const std::string& algo, const VarMap& vars) override
{
Test::Result result("OCB wide block long test");
const std::vector<uint8_t> expected = vars.get_req_bin("Output");
std::unique_ptr<Botan::BlockCipher> cipher;
size_t bs = 0;
if(algo == "SHACAL2")
{
#if defined(BOTAN_HAS_SHACAL2)
cipher = Botan::BlockCipher::create_or_throw("SHACAL2");
bs = 32;
#else
return {result};
#endif
}
else
{
if(algo == "Toy128")
bs = 16;
else if(algo == "Toy192")
bs = 24;
else if(algo == "Toy256")
bs = 32;
else if(algo == "Toy512")
bs = 64;
else
throw Test_Error("Unknown cipher for OCB wide block long test");
cipher.reset(new OCB_Wide_Test_Block_Cipher(bs));
}
Botan::OCB_Encryption enc(cipher.release(), std::min<size_t>(bs, 32));
/*
Y, string of length min(B, 256) bits
Y is defined as follows.
K = (0xA0 || 0xA1 || 0xA2 || ...)[1..B]
C = <empty string>
for i = 0 to 127 do
S = (0x50 || 0x51 || 0x52 || ...)[1..8i]
N = num2str(3i+1,16)
C = C || OCB-ENCRYPT(K,N,S,S)
N = num2str(3i+2,16)
C = C || OCB-ENCRYPT(K,N,<empty string>,S)
N = num2str(3i+3,16)
C = C || OCB-ENCRYPT(K,N,S,<empty string>)
end for
N = num2str(385,16)
Y = OCB-ENCRYPT(K,N,C,<empty string>)
*/
std::vector<uint8_t> key(bs);
for(size_t i = 0; i != bs; ++i)
key[i] = 0xA0 + i;
enc.set_key(key);
const std::vector<uint8_t> empty;
std::vector<uint8_t> N(2);
std::vector<uint8_t> C;
for(size_t i = 0; i != 128; ++i)
{
std::vector<uint8_t> S(i);
for(size_t j = 0; j != S.size(); ++j)
S[j] = 0x50 + j;
Botan::store_be(static_cast<uint16_t>(3 * i + 1), &N[0]);
ocb_encrypt(result, C, enc, N, S, S);
Botan::store_be(static_cast<uint16_t>(3 * i + 2), &N[0]);
ocb_encrypt(result, C, enc, N, S, empty);
Botan::store_be(static_cast<uint16_t>(3 * i + 3), &N[0]);
ocb_encrypt(result, C, enc, N, empty, S);
}
Botan::store_be(static_cast<uint16_t>(385), &N[0]);
std::vector<uint8_t> final_result;
ocb_encrypt(result, final_result, enc, N, empty, C);
result.test_eq("correct value", final_result, expected);
return result;
}
void PolynomialMod2::DEREncodeAsOctetString(BufferedTransformation &bt, size_t length) const
{
DERGeneralEncoder enc(bt, OCTET_STRING);
Encode(enc, length);
enc.MessageEnd();
}
std::shared_ptr<Decoder> DecoderFactory::get(const std::string& chain) {
// return a cached encoder if we have one
auto i = Cache.find(chain);
if (i != Cache.end()) {
return i->second;
}
// parse the transformation chain
std::vector<std::string> charchar, bytebyte;
std::string charbyte;
std::tie(charchar, charbyte, bytebyte) = parseChain(chain);
// assemble the transformation chain
std::unique_ptr<Decoder> enc(new ByteSource(nullptr, nullptr));
for (auto bb = bytebyte.crbegin(); bb != bytebyte.crend(); ++bb) {
if (*bb == "identity") {
// do nothing
}
else if (*bb == "OCE") {
enc.reset(new OCEDecoder(std::move(enc)));
}
else if (bb->substr(0, 3) == "XOR") {
enc.reset(new XORDecoder(
boost::lexical_cast<byte>(bb->substr(3)), std::move(enc)
));
}
}
if (charbyte == "ASCII") {
enc.reset(new ASCIIDecoder(std::move(enc)));
}
else if (charbyte == "UTF-8") {
enc.reset(new UTF8Decoder(std::move(enc)));
}
else if (charbyte == "UTF-16LE") {
enc.reset(new UTF16LEDecoder(std::move(enc)));
}
else if (charbyte == "UTF-16BE") {
enc.reset(new UTF16BEDecoder(std::move(enc)));
}
else if (charbyte == "UTF-32LE") {
enc.reset(new UTF32LEDecoder(std::move(enc)));
}
else if (charbyte == "UTF-32BE") {
enc.reset(new UTF32BEDecoder(std::move(enc)));
}
else {
enc.reset(new ICUDecoder(charbyte.c_str(), std::move(enc)));
}
for (auto cc = charchar.crbegin(); cc != charchar.crend(); ++cc) {
if (*cc == "identity") {
// do nothing
}
else if (cc->substr(0, 3) == "rot") {
enc.reset(new RotDecoder(
boost::lexical_cast<uint32_t>(cc->substr(3)), std::move(enc)
));
}
}
return std::shared_ptr<Decoder>(std::move(enc));
}
static int enc(K*k,lua_State *L)
{
switch (lua_type(L, -1)) {
case LUA_TSTRING: { size_t len;const char *str = lua_tolstring(L,-1,&len);(*k)=kpn(str,len);R 1;} break;
case LUA_TNUMBER: { F num = lua_tonumber(L,-1);(*k) = (num==floor(num))?kj((J)num):kf(num);R 1;} break;
case LUA_TBOOLEAN: { (*k)=kb( lua_toboolean(L,-1) );R 1;} break;
case LUA_TNIL: { (*k)=ktn(0,0);R 1;} break;
case LUA_TTABLE: {
double p;
int max = 0;
int items = 0;
int t_integer = 0, t_number = 0, t_boolean = 0, t_other= 0;
lua_pushnil(L);
/* table, startkey */
while (lua_next(L, -2) != 0) {
items++;
/* table, key, value */
switch (lua_type(L, -1)) {
case LUA_TNUMBER: t_number++; p = lua_tonumber(L,-1); t_integer += (floor(p) == p); break;
case LUA_TBOOLEAN: t_boolean++; break;
default: t_other++; break; /* or anything else */
};
if (lua_type(L, -2) == LUA_TNUMBER &&
(p = lua_tonumber(L, -2))) {
/* Integer >= 1 ? */
if (floor(p) == p && p >= 1) {
if (p > max)
max = p;
lua_pop(L, 1);
continue;
}
}
/* Must not be an array (non integer key) */
for (lua_pop(L,1); lua_next(L, -2) != 0; lua_pop(L,1)) ++items;
max = 0;
break;
}
lua_pushnil(L);
if (max != items) {
/* build K dictionary */
K keys = ktn(KS,items);
K values = ktn(0,items);
int n = 0;
/* table, startkey */
while (lua_next(L, -2) != 0) {
kS(keys)[n] = ss(lua_tostring(L, -2));
if(!enc(kK(values)+n,L))R 0;
lua_pop(L,1);
++n;
}
*k = xD(keys,values);
R 1;
}
/* build K list */
if(t_other || ((!!t_boolean)+(!!t_number)) > 1) {
K a = ktn(0,items);
while (lua_next(L, -2) != 0) {
p = lua_tonumber(L, -2);
if(!enc(kK(a)+LI(p),L))R 0;
lua_pop(L, 1);
}
*k = a;
R 1;
}
if(t_boolean) {
K a = ktn(KB,items);
while (lua_next(L, -2) != 0) {
p = lua_tonumber(L, -2);
kG(a)[LI(p)] = lua_toboolean(L,-1);
lua_pop(L, 1);
}
*k = a;
R 1;
}
if(t_number == t_integer) {
K a = ktn(KJ,items);
while (lua_next(L, -2) != 0) {
p = lua_tonumber(L, -2);
kJ(a)[LI(p)] = (int)floor(lua_tonumber(L,-1));
lua_pop(L, 1);
}
*k = a;
R 1;
}
if(t_number) {
K a = ktn(KF,items);
while (lua_next(L, -2) != 0) {
p = lua_tonumber(L, -2);
kF(a)[LI(p)] = lua_tonumber(L,-1);
lua_pop(L, 1);
}
*k = a;
R 1;
}
*k = ktn(0,0);
R 1;
}; break;
default:
luaL_error(L, "Cannot serialise %s: %s", lua_typename(L, lua_type(L, -1)), "can't serialize type");
R 0;
};
}
std::string PackRpcValues(ArrayRef<std::shared_ptr<Value>> values) {
WireEncoder enc(0x0300);
for (auto& value : values) enc.WriteValue(*value);
return enc.ToStringRef();
}
char * MAC(char* data,int dataLength, char * ran, char * key16)
{
int key16Length =32 ;
char keya[17];
char keyb[17];
char d3[17];
char d4[17];
char result[17];
memcpy( keya ,key16, key16Length / 2);
memcpy( keyb , (char*)&key16[key16Length / 2],key16Length / 2);
keya[16]=0;
keyb[16]=0;
memset( d3 ,0x00,sizeof(d3));
memset( d4 ,0x00,sizeof(d3));
memset( result,0x00,sizeof(16));
echomac("bb");
if (dataLength >= 16)
{
unsigned char Ran9[9];
unsigned char PrTemp[17];
memcpy(d3, data, 16);
PrTemp[16] = 0x00;
d3[16]=0;
XOR(PadRight(Substring(ran,0,8,Ran9), 16, '0',PrTemp), d3,16,result);
echomac("bb");
if (dataLength % 16 == 0)
{
int i ;
for ( i = 1; i <dataLength / 16; i++)
{
unsigned char resultBin[8],keyaBin[8] ; ;
enc(Hex2Bin(keya,keyaBin), Hex2Bin(result,resultBin));
Bin2Hex(resultBin,8,result);
printf( result);
Substring(data,i * 16, 16,d3);
XOR(result, d3,16,result);
memcpy(d4 , (char*)&"8000000000000000",16);
echomac("bb");
}
if (dataLength == 16)
{
memcpy(d4 ,"8000000000000000",16);
}
echomac("bb");
unsigned char temp222[8];Hex2Bin(result,temp222);
unsigned char keyaXXX[8];Hex2Bin(keya,keyaXXX);
unsigned char keybXXX[8];Hex2Bin(keyb,keybXXX);
enc(keyaXXX, temp222);
Bin2Hex(temp222,8,result);
XOR(result, d4,16,result);
Hex2Bin(result,temp222);
enc(keyaXXX, temp222);
Bin2Hex(temp222,8,result);
dec(keybXXX, temp222);
Bin2Hex(temp222,8,result);
enc(keyaXXX, temp222);
Bin2Hex(temp222,8,result);
echomac("bb");
}
else
{
int i ;
unsigned char keyaXXX1[8];Hex2Bin(keya,keyaXXX1);
unsigned char keybXXX1[8];Hex2Bin(keyb,keybXXX1);
echomac("bb");
for ( i = 1; i < dataLength / 16; i++)
{
unsigned char temp4441[8];Hex2Bin(result,temp4441);
unsigned char temp4442keya[8];Hex2Bin(keya,temp4442keya);
enc(temp4442keya, temp4441);
Bin2Hex(temp4441,8,result);
Substring(data, i * 16, 16,d3);
XOR(result, d3,16,result);
}
Substring(data,dataLength - dataLength % 16, dataLength % 16,d4);
strcat(d4,"8");//可能有问题
PadRight(d4,16, '0',d4);
unsigned char temp555[8];Hex2Bin(result,temp555);
enc(keyaXXX1, temp555);
Bin2Hex(temp555,8,result);
XOR(result, d4,16,result);
Hex2Bin(result,temp555);//temp555=Hex2Bin(result);
enc(keyaXXX1, temp555);
dec(keybXXX1, temp555);
enc(keyaXXX1, temp555);
Bin2Hex(temp555,8,result);
echomac("bb");
}
}
else
{
echomac("bb");
unsigned char Ran9[9];
unsigned char temp4442keya[8];Hex2Bin(keya,temp4442keya);
unsigned char temp4442keyb[8];Hex2Bin(keyb,temp4442keyb);
sprintf(d3,"%s%s",data,"8");
PadRight(d3,16, '0',d3);
PadRight(Substring(ran,0,8,Ran9),16,'0',result);
XOR( result, d3,16,result);
unsigned char temp777[8];Hex2Bin(result,temp777);
enc(temp4442keya, temp777);
Bin2Hex(temp777,8,result);;
dec(temp4442keyb, temp777);
Bin2Hex(temp777,8,result);
enc(temp4442keya, temp777);
Bin2Hex(temp777,8,result);
echomac("bb");
}
memset(___MAC,0x00,9);
memcpy(___MAC,result,8);
return ___MAC;
}
EXPORT char * MAC8(char * data,int dataLength, char * ran, char * key8)
{
char result[17] ;
char d3[17] ;
char d4[17];
unsigned char Ran9[9];
unsigned char Prtwmp[17];
unsigned char key8aaa[strlen(key8)/2];Hex2Bin(key8,key8aaa);
if (dataLength >= 16)
{
Substring(data,0, 16,d3);
Prtwmp[16] = 0x00;
XOR(PadRight( Substring(ran,0,8,Ran9),16,'0',Prtwmp),d3,dataLength,result);
result[16]=0;
if (dataLength % 16 == 0)
{
unsigned char temp777[8];
int i;
for ( i = 1; i < dataLength / 16; i++)
{
Hex2Bin(result,temp777);//temp777=Hex2Bin(result);
enc(key8aaa, temp777);
Bin2Hex(temp777,8,result);
Substring(data,i * 16, 16,d3);
XOR(result, d3,16,result);
memcpy(d4,(char *)"8000000000000000",16);
d4[16] = 0x00;
}
if (dataLength == 16)
{
memcpy(d4,(char*)"8000000000000000",16);
d4[16] = 0x00;
}
Hex2Bin(result,temp777);
enc(key8aaa, temp777);
Bin2Hex(temp777,8,result);
XOR(result, d4,16,result);
Hex2Bin(result,temp777);
enc(key8aaa, temp777);
Bin2Hex(temp777,8,result);
}
else
{
int i;
unsigned char tmp999[8];
char *tmpx99x;
unsigned char tmp999keya[strlen(key8)/2];Hex2Bin(key8,tmp999keya);
for ( i= 1; i < dataLength / 16; i++)
{
unsigned char tmp888[8];Hex2Bin(result,tmp888);
enc(key8aaa, tmp888);
Substring(data,i * 16, 16,d3);
Bin2Hex(tmp888,8,result);
XOR(result, d3,16,result);
}
Substring(data,dataLength - dataLength % 16, dataLength % 16,d4);
strcat(d4,"8");
PadRight(d4,16, '0',d4);
Hex2Bin(result,tmp999);
enc(tmp999keya, tmp999);
Bin2Hex(tmp999,8,result);
XOR(result, d4,16,result);
Hex2Bin(result,tmp999);
enc(tmp999keya, tmp999);
Bin2Hex(tmp999,8,result);
}
}
else
{
unsigned char tmp888111[8];
unsigned char PdTemp[17];
sprintf(d3,"%s%s", data, "8");
PadRight(d3,16, '0',d3);
PdTemp[16] = 0;
XOR(PadRight( Substring(ran,0, 8,Ran9),16, '0',PdTemp), d3,16,result);
Hex2Bin(result,tmp888111);
enc(key8aaa, tmp888111);
Bin2Hex(tmp888111,8,result);
}
memset(___MAC8,0x00,9);
memcpy(___MAC8,result,8);
return ___MAC8;
}
bool VLFeat::CalculateCommon(int f, bool all, int l) {
string msg = "VLFeat::CalculateCommon("+ToStr(f)+","+ToStr(all)+","+
ToStr(l)+") : ";
// if (!do_fisher && !do_vlad) {
// cerr << msg
// << "either encoding=fisher or encoding=vlad should be specified"
// << endl;
// return false;
// }
if (!gmm && !kmeans) {
cerr << msg << "either gmm=xxx or kmeans=xxx option should be given"
<< endl;
return false;
}
cox::tictac::func tt(tics, "VLFeat::CalculateCommon");
// obs! only some parameters here, should be in ProcessOptionsAndRemove()
// too, also scales and geometry should be made specifiable...
bool normalizeSift = false, renormalize = true, flat_window = true;
size_t step = 3, binsize = 8;
EnsureImage();
int width = Width(true), height = Height(true);
if (FrameVerbose())
cout << msg+"wxh="
<< width << "x" << height << "=" << width*height << endl;
vector<float> rgbcoeff { 0.2989, 0.5870, 0.1140 };
imagedata idata = CurrentFrame();
idata.convert(imagedata::pixeldata_float);
idata.force_one_channel(rgbcoeff);
vector<float> dsift;
size_t descr_size_orig = 0, descr_size_final = 0;
vector<float> scales { 1.0000, 0.7071, 0.5000, 0.3536, 0.2500 };
// vector<float> scales { 1.0000 };
for (size_t i=0; i<scales.size(); i++) {
if (KeyPointVerbose())
cout << "Starting vl_dsift_process() in scale " << scales[i] << endl;
imagedata simg = idata;
if (scales[i]!=1) {
scalinginfo si(simg.width(), simg.height(),
(int)floor(scales[i]*simg.width()+0.5),
(int)floor(scales[i]*simg.height()+0.5));
simg.rescale(si, 1);
}
// VlDsiftFilter *sf = vl_dsift_new(simg.width(), simg.height());
VlDsiftFilter *sf = vl_dsift_new_basic(simg.width(), simg.height(),
step, binsize);
// opts.scales = logspace(log10(1), log10(.25), 5) ;
// void vl_dsift_set_bounds ( VlDsiftFilter * self,
// int minX,
// int minY,
// int maxX,
// int maxY
// );
// VlDsiftDescriptorGeometry geom = { 8, 4, 4, 0, 0 };
// vl_dsift_set_geometry(sf, &geom);
//vl_dsift_set_steps(sf, 3, 3);
//vl_dsift_set_window_size(sf, 8);
vl_dsift_set_flat_window(sf, flat_window); // aka fast in matlab
vector<float> imgvec = simg.get_float();
const float *img_fp = &imgvec[0];
// cout << "IMAGE = " << img_fp[0] << " " << img_fp[1] << " "
// << img_fp[2] << " ... " << img_fp[41] << endl;
vl_dsift_process(sf, img_fp);
// if opts.rootSift // false
// descrs{si} = sqrt(descrs{si}) ;
// end
// if opts.normalizeSift //true
// descrs{si} = snorm(descrs{si}) ;
// end
descr_size_orig = sf->descrSize;
size_t nf = sf->numFrames;
const VlDsiftKeypoint *k = sf->frames;
float *d = sf->descrs;
if (KeyPointVerbose())
cout << " found " << sf->numFrames << " 'frames' in "
<< simg.info() << endl
<< " descriptor dim " << descr_size_orig << endl;
if (PixelVerbose())
for (size_t i=0; i<nf; i++) {
cout << " i=" << i << " x=" << k[i].x << " y=" << k[i].y
<< " s=" << k[i].s << " norm=" << k[i].norm;
if (FullVerbose()) {
cout << " RAW";
for (size_t j=0; j<descr_size_orig; j++)
cout << " " << d[i*descr_size_orig+j];
}
cout << endl;
}
if (normalizeSift) {
for (size_t i=0; i<nf; i++) {
if (PixelVerbose())
cout << " i=" << i << " x=" << k[i].x << " y=" << k[i].y
<< " s=" << k[i].s << " norm=" << k[i].norm;
double mul = 0.0;
for (size_t j=0; j<descr_size_orig; j++)
mul += d[i*descr_size_orig+j]*d[i*descr_size_orig+j];
if (mul)
mul = 1.0/sqrt(mul);
if (FullVerbose())
cout << " NORM";
for (size_t j=0; j<descr_size_orig; j++) {
d[i*descr_size_orig+j] *= mul;
if (FullVerbose())
cout << " " << d[i*descr_size_orig+j];
}
if (PixelVerbose())
cout << endl;
}
}
if (!pca.vector_length()) {
dsift.insert(dsift.end(), d, d+nf*descr_size_orig);
descr_size_final = descr_size_orig;
} else {
for (size_t i=0; i<nf; i++) {
vector<float> vin(d+i*descr_size_orig, d+(i+1)*descr_size_orig);
vector<float> vout = pca.projection_coeff(vin);
dsift.insert(dsift.end(), vout.begin(), vout.end());
}
descr_size_final = pca.base_size();
}
vl_dsift_delete(sf);
}
size_t numdata = dsift.size()/descr_size_final;
const float *datain = &dsift[0];
vector<float> enc((do_fisher?2:1)*descriptor_dim()*nclusters());
float *dataout = &enc[0];
if (do_fisher) {
if (FrameVerbose())
cout << msg << "fisher encoding " << numdata
<< " descriptors of size " << descr_size_orig
<< " => " << descr_size_final
<< " with gmm dimensionality " << descriptor_dim()
<< endl;
if (descr_size_final!=descriptor_dim()) {
cerr << msg << "dimensionality mismatch descr_size_final="
<< descr_size_final << " descriptor_dim()=" << descriptor_dim()
<< endl;
return false;
}
vl_fisher_encode(dataout, VL_TYPE_FLOAT, means(), descriptor_dim(),
nclusters(), covariances(), priors(),
datain, numdata, VL_FISHER_FLAG_IMPROVED) ;
}
if (do_vlad) {
//obs! correct use of pca?
if (FrameVerbose())
cout << msg << "vlad encoding " << numdata
<< " descriptors of size " << descr_size_final << endl;
vector<vl_uint32> indexes(numdata);
vector<float> distances(numdata);
if (kdtree)
vl_kdforest_query_with_array(kdtree, &indexes[0], 1, numdata, &distances[0], datain);
else
vl_kmeans_quantize(kmeans, &indexes[0], &distances[0], datain, numdata);
vector<float> assignments(numdata*nclusters());
for (size_t i=0; i<numdata; i++)
assignments[i * nclusters() + indexes[i]] = 1;
int vlad_flags = VL_VLAD_FLAG_SQUARE_ROOT|VL_VLAD_FLAG_NORMALIZE_COMPONENTS;
vl_vlad_encode(dataout, VL_TYPE_FLOAT, means(), descriptor_dim(),
nclusters(), datain, numdata, &assignments[0],
vlad_flags);
}
if (renormalize) {
if (PixelVerbose())
cout << " RENORM:";
double mul = 0.0;
for (size_t j=0; j<enc.size(); j++)
mul += enc[j]*enc[j];
if (mul)
mul = 1.0/sqrt(mul);
for (size_t j=0; j<enc.size(); j++) {
if (PixelVerbose())
cout << " " << enc[j];
enc[j] *= mul;
if (PixelVerbose())
cout << "->" << enc[j];
}
if (PixelVerbose())
cout << endl;
}
((VectorData*)GetData(0))->setVector(enc);
return true;
}
static krb5_error_code
krb5int_camellia_encrypt(krb5_key key, const krb5_data *ivec,
krb5_crypto_iov *data, size_t num_data)
{
unsigned char tmp[BLOCK_SIZE], tmp2[BLOCK_SIZE];
int nblocks = 0, blockno;
size_t input_length, i;
struct iov_block_state input_pos, output_pos;
if (key->cache == NULL) {
key->cache = malloc(sizeof(struct camellia_key_info_cache));
if (key->cache == NULL)
return ENOMEM;
CACHE(key)->enc_ctx.keybitlen = CACHE(key)->dec_ctx.keybitlen = 0;
}
if (CACHE(key)->enc_ctx.keybitlen == 0) {
if (camellia_enc_key(key->keyblock.contents, key->keyblock.length,
&CACHE(key)->enc_ctx) != camellia_good)
abort();
}
if (ivec != NULL)
memcpy(tmp, ivec->data, BLOCK_SIZE);
else
memset(tmp, 0, BLOCK_SIZE);
for (i = 0, input_length = 0; i < num_data; i++) {
krb5_crypto_iov *iov = &data[i];
if (ENCRYPT_IOV(iov))
input_length += iov->data.length;
}
IOV_BLOCK_STATE_INIT(&input_pos);
IOV_BLOCK_STATE_INIT(&output_pos);
nblocks = (input_length + BLOCK_SIZE - 1) / BLOCK_SIZE;
if (nblocks == 1) {
krb5int_c_iov_get_block(tmp, BLOCK_SIZE, data, num_data, &input_pos);
enc(tmp2, tmp, &CACHE(key)->enc_ctx);
krb5int_c_iov_put_block(data, num_data, tmp2, BLOCK_SIZE, &output_pos);
} else if (nblocks > 1) {
unsigned char blockN2[BLOCK_SIZE]; /* second last */
unsigned char blockN1[BLOCK_SIZE]; /* last block */
for (blockno = 0; blockno < nblocks - 2; blockno++) {
unsigned char blockN[BLOCK_SIZE], *block;
krb5int_c_iov_get_block_nocopy(blockN, BLOCK_SIZE,
data, num_data, &input_pos, &block);
xorblock(tmp, block);
enc(block, tmp, &CACHE(key)->enc_ctx);
krb5int_c_iov_put_block_nocopy(data, num_data, blockN, BLOCK_SIZE,
&output_pos, block);
/* Set up for next block. */
memcpy(tmp, block, BLOCK_SIZE);
}
/* Do final CTS step for last two blocks (the second of which
may or may not be incomplete). */
/* First, get the last two blocks */
memset(blockN1, 0, sizeof(blockN1)); /* pad last block with zeros */
krb5int_c_iov_get_block(blockN2, BLOCK_SIZE, data, num_data,
&input_pos);
krb5int_c_iov_get_block(blockN1, BLOCK_SIZE, data, num_data,
&input_pos);
/* Encrypt second last block */
xorblock(tmp, blockN2);
enc(tmp2, tmp, &CACHE(key)->enc_ctx);
memcpy(blockN2, tmp2, BLOCK_SIZE); /* blockN2 now contains first block */
memcpy(tmp, tmp2, BLOCK_SIZE);
/* Encrypt last block */
xorblock(tmp, blockN1);
enc(tmp2, tmp, &CACHE(key)->enc_ctx);
memcpy(blockN1, tmp2, BLOCK_SIZE);
/* Put the last two blocks back into the iovec (reverse order) */
krb5int_c_iov_put_block(data, num_data, blockN1, BLOCK_SIZE,
&output_pos);
krb5int_c_iov_put_block(data, num_data, blockN2, BLOCK_SIZE,
&output_pos);
if (ivec != NULL)
memcpy(ivec->data, blockN1, BLOCK_SIZE);
}
return 0;
}
int ClientSession::run(std::string strUsername, std::string strPassword)
{
int rval;
San2::Utils::bytes request, response;
San2::Utils::bytes srpA;
San2::Utils::bytes username, password;
char line[SH_TERMINAL_MAXLINLEN];
username = strUsername;
password = strPassword;
sca = srpclient.getAuthenticator(username, password);
srpA = sca.getA();
rval = enc_construct_A_message(strUsername, srpA, request);
if (rval)
{
printf("ClientSession::run:enc_construct_A_message failed: %d\n", rval);
return -1;
}
if (m_swtx.sendReliableMessage(request, response) == false)
{
printf("sending A message failed\n");
return -2;
}
unsigned char errorCode;
San2::Utils::bytes srpB;
San2::Utils::bytes srpSalt;
rval = enc_parse_P_message(response, srpSalt, srpB, errorCode);
if (rval)
{
printf("ClientSession::run:enc_parse_P_message failed: %d\n", rval);
return -3;
}
if (errorCode == SH_ERRORCODE_USERNOTFOUND)
{
printf("User was not found in the servers database\n");
return -9;
}
if (errorCode)
{
printf("ClientSession::run:enc_parse_P_message errorCode is non zero: %d\n", errorCode);
return -4;
}
San2::Utils::bytes srpM1;
try
{
srpM1 = srpclient.getM1(srpSalt, srpB, sca);
}
catch(DragonSRP::DsrpException &e)
{
std::cout << "DsrpException: " << e.what() << std::endl;
return -5;
}
rval = enc_construct_B_message(srpM1, request);
if (rval)
{
printf("ClientSession::run:enc_construct_B_message failed: %d\n", rval);
return -6;
}
if (m_swtx.sendReliableMessage(request, response) == false)
{
printf("sending B message failed\n");
return -7;
}
San2::Utils::bytes srpM2;
rval = enc_parse_Q_message(response, srpM2, errorCode);
if (rval)
{
printf("ClientSession::run:enc_parse_Q_message failed: %d\n", rval);
return -8;
}
if (errorCode == SH_ERRORCODE_AUTHENTICATIONFAILED)
{
printf("Authentication FAILED - bad password\n");
return -9;
}
if (errorCode)
{
printf("ClientSession::run:enc_parse_Q_message errorCode is non zero: %d\n", errorCode);
return -9;
}
// check M2
San2::Utils::bytes K; // session key
try
{
K = sca.getSessionKey(srpM2);
}
catch(DragonSRP::DsrpException &e)
{
std::cout << "Authentication failed - bad password or other protocol failure." << std::endl;
std::cout << "DsrpException: " << e.what() << std::endl;
return -10;
}
std::cout << "Authentication SUCCESSFUL." << std::endl;
// ==============================================================================
// Setup key derivator
DragonSRP::HashKeyDerivator keydrv(K, SH_AES256_KEYLEN, SH_IVLEN, SH_SHA1_OUTPUTLEN);
// Oposite keys on server!
// Uses client keys!
DragonSRP::DatagramEncryptor enc(keydrv.getClientEncryptionKey(), keydrv.getClientIV(), keydrv.getClientMacKey());
// Uses server keys!
DragonSRP::DatagramDecryptor dec(keydrv.getServerEncryptionKey(), keydrv.getServerIV(), keydrv.getServerMacKey());
// ==============================================================================
San2::Utils::bytes shellRequest, shellResponse;
shellRequest = "hostname";
getShellServerResponse(enc, dec, shellRequest, shellResponse);
std::string shell = San2::Utils::bytes::bytes2string(shellResponse) + ">";
while(1)
{
std::cout << shell;
std::cin.getline(line, SH_TERMINAL_MAXLINLEN);
if (strlen(line) == 0) continue;
if (strcmp(line, "exit") == 0)
{
return 0; // ??
}
shellRequest = line;
if (getShellServerResponse(enc, dec, shellRequest, shellResponse))
{
break;
}
for (unsigned int b = 0; b < shellResponse.size(); b++) printf("%c", shellResponse[b]); printf("\n");
}
// shellRequest = "This is a sample message";
// getShellServerResponse(enc, dec, shellRequest, shellResponse);
// printf("decpacket: "); for (int b = 0; b < shellResponse.size(); b++) printf("%c", shellResponse[b]); printf("\n");
return 0;
}
void C1AffineSet<MatrixType, Policies>::move(DynSysType & dynsys, C1AffineSet& result) const
{
// important: here we assume that m_r contains zero
// this is assured by each constructor and each step of this algorithm
const size_type dim = m_x.dimension();
VectorType y(dim), rem(dim), enc(dim);
MatrixType jacPhi(dim,dim), jacEnc(dim,dim), jacRem(dim,dim);
MatrixType B(dim,dim), Q(dim,dim);
VectorType xx = VectorType(*this);
// the following function can throw an exception leaving output parameters in an inconsistent state
// do not overwrite parameters of the set until we are sure that they are computed correctly
dynsys.encloseC1Map(this->getCurrentTime(),
this->m_x, xx, // input parameters
y, rem, enc, // C^0 output
jacPhi, jacRem, jacEnc // C^1 output
);
result.m_x = y + rem;
B = result.m_B = jacPhi * m_B;
// ---------- C^0 - part -----------------
// here we compute enclosure of the image after one iteration of the map/flow
result.m_currentSet = result.m_x + result.m_B*this->m_r;
// here we compute representation for the new set
// xx is unnecessary now
split(result.m_x, xx);
// we assume that Policies provides algorithms for computation
// of B, its inverse invB and updates
this->Policies::computeBinvB(result.m_B,result.m_invB,this->m_r);
// eventually we compute new representation of r
result.m_r = (result.m_invB * B) * m_r + result.m_invB * xx;
// ---------- C^1 - part -----------------
MatrixType J = jacPhi + jacRem;
result.m_D = J*this->m_D;
B = result.m_Bjac = J*this->m_Bjac;
// here we compute enclosure of the image after one iteration of the map/flow
result.m_currentMatrix = J*this->m_currentMatrix;
intersection(result.m_currentMatrix,result.m_D + result.m_Bjac*m_R,result.m_currentMatrix);
// here we compute representation for the new set
// jacRem is unnecessary now
split(result.m_D, jacRem);
// we assume that Policies provides algorithms for computation
// of B, its inverse invB and updates
this->Policies::computeBinvB(result.m_Bjac,result.m_invBjac,this->m_R);
// eventually we compute new representation of r
result.m_R = (result.m_invBjac * B) * m_R + result.m_invBjac * jacRem;
result.setCurrentTime(this->getCurrentTime()+dynsys.getStep());
result.setLastEnclosure(enc);
result.setLastMatrixEnclosure(jacEnc);
}
Botan::SecureVector<boost::uint8_t> RsaEncoderDecoder::getEncodedSessionKey()
{
Botan::PK_Encryptor_EME enc(*remoteKey_, "EME-PKCS1-v1_5");
return enc.encrypt(sessionKey_.bits_of(), rng_);
}
